Update CHANGELOG.md

0.5.15

.github/workflows/build.yml

@@ -1,16 +1,12 @@
-name: Build
-
+name: Regular build
 on: [push]
-
 jobs:
   build:
     runs-on: ubuntu-latest
-
     steps:
       - uses: actions/checkout@v2
-      - name: Set up JDK 1.8
-        uses: actions/setup-java@v1
+      - uses: actions/setup-java@v1
         with:
           java-version: 1.8
-      - name: Build with Gradle
+      - name: Build
         run: ./gradlew build

.github/workflows/dokka_push.yml

@@ -0,0 +1,21 @@
+name: Publish KDocs
+on:
+  push:
+    branches:
+      - master
+jobs:
+  publishing:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v1
+        with:
+          java-version: 1.8
+      - name: Build
+        run: ./gradlew dokkaHtml
+      - name: Publish KDocs
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./dokka/build/dokka/html
+          publish_branch: kdocs

.github/workflows/packages_push.yml

@@ -0,0 +1,24 @@
+
+name: Publish package to GitHub Packages
+on: [push]
+jobs:
+  publishing:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v1
+        with:
+          java-version: 1.8
+      - name: Rewrite version
+        run: |
+          branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
+          cat gradle.properties | sed -e "s/^version=\([0-9\.]*\)/version=\1-branch_$branch-build${{ github.run_number }}/" > gradle.properties.tmp
+          rm gradle.properties
+          mv gradle.properties.tmp gradle.properties
+      - name: Build
+        run: ./gradlew build
+      - name: Publish
+        run: ./gradlew --no-parallel publishAllPublicationsToGithubPackagesRepository -x signJsPublication -x signJvmPublication -x signKotlinMultiplatformPublication -x signAndroidDebugPublication -x signAndroidReleasePublication -x signKotlinMultiplatformPublication
+        env:
+          GITHUBPACKAGES_USER: ${{ github.actor }}
+          GITHUBPACKAGES_PASSWORD: ${{ secrets.GITHUB_TOKEN }}

.space.kts

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

.travis.yml

@@ -1,27 +0,0 @@
-language: android
-install: true
-
-os: linux
-dist: trusty
-jdk: oraclejdk8
-
-android:
-  components:
-    - tools
-    - platform-tools
-    - build-tools-30.0.2
-    - android-30
-    - add-on
-    - extra
-
-before_script:
-  - yes | /usr/local/android-sdk/tools/bin/sdkmanager "build-tools;30.0.2"
-  - yes | /usr/local/android-sdk/tools/bin/sdkmanager "platforms;android-30"
-
-jobs:
-  include:
-    - stage: build
-      script: ./gradlew build -s -x jvmTest -x jsIrTest -x jsIrBrowserTest -x jsIrNodeTest -x jsLegacyTest -x jsLegacyBrowserTest -x jsLegacyNodeTest
-#    Tests are temporarily disabled on public travis due to the problems of launching
-#    - state: test
-#      script: ./gradlew allTests

CHANGELOG.md

@@ -1,5 +1,289 @@
 # Changelog
 
+## 0.5.16
+
+* `Versions`
+  * `Coroutines`: `1.5.0` -> `1.5.1`
+  * `Serialization`: `1.2.1` -> `1.2.2`
+  * `Ktor`: `1.6.0` -> `1.6.1`
+  * `Klock`: `2.1.2` -> `2.2.0`
+  * `Core KTX`: `1.5.0` -> `1.6.0`
+
+## 0.5.15 HOTFIX FOR 0.5.14
+
+* `Coroutines`
+    * Fixes in `subscribeAsync`
+
+## 0.5.14 NOT RECOMMENDED
+
+* `Versions`
+    * `Kotlin`: `1.5.10` -> `1.5.20`
+* `Coroutines`
+    * `subscribeSafelyWithoutExceptions` got new parameter `onException` by analogue with `safelyWithoutExceptions`
+    * New extensions `Flow#subscribeAsync` and subsequent analogs of `subscribe` with opportunity to set up custom marker
+
+## 0.5.13
+
+* `Common`:
+    * Add functionality for multiplatform working with files:
+        * Main class for files `MPPFile`
+        * Inline class for filenames work encapsulation `FileName`
+* `FSM`
+    * Module inited and in preview state
+
+## 0.5.12
+
+* `Common`:
+    * `Android`
+        * Extension `View#changeVisibility` has been fixed
+* `Android`
+    * `RecyclerView`
+        * Default adapter got `dataCountFlow` property
+        * New subtype of adapter based on `StateFlow`: `StateFlowBasedRecyclerViewAdapter`
+
+## 0.5.11
+
+* `Repos`:
+    * `Common`:
+        * Fixes in `WriteOneToManyRepo#add`
+    * `Exposed`:
+        * Fixes in `ExposedOneToManyKeyValueRepo#add`
+
+## 0.5.10
+
+* `Versions`
+    * `Core KTX`: `1.3.2` -> `1.5.0`
+    * `AndroidX Recycler`: `1.2.0` -> `1.2.1`
+    * `AppCompat`: `1.2.0` -> `1.3.0`
+* `Android`
+    * `RecyclerView`:
+        * `data` of `RecyclerViewAdapter` became an abstract field
+            * New function `RecyclerViewAdapter`
+    * `Common`:
+        * New extension `View#changeVisibility`
+    * `Repos`:
+        * `Common`:
+            * `WriteOneToManyRepo` got new function `clearWithValue`
+            * `Android`:
+                * New extension `SQLiteDatabase#selectDistinct`
+                * Fixes in `OneToManyAndroidRepo`
+* `Ktor`
+    * `Server`
+        * All elements in configurators became a `fun interface`
+* `Pagination`
+    * New function `doForAllWithCurrentPaging`
+
+## 0.5.9
+
+* `Repos`
+    * `Common`
+        * `OneToManyAndroidRepo` got new primary constructor
+
+## 0.5.8
+
+* `Common`:
+    * New extension `Iterable#firstNotNull`
+* `Coroutines`
+    * New extension `Flow#firstNotNull`
+    * New extensions `CoroutineContext#LinkedSupervisorJob`, `CoroutineScope#LinkedSupervisorJob` and
+      `CoroutineScope#LinkedSupervisorScope`
+
+## 0.5.7
+
+* `Pagination`
+    * `Ktor`
+        * `Server`
+            * Fixes in extension `extractPagination`
+* `Repos`
+    * `Cache`
+        * All standard cache repos have been separated to read and read/write repos
+
+## 0.5.6
+
+* `Versions`
+    * `Exposed`: `0.31.1` -> `0.32.1`
+* `Coroutines`
+    * `JVM`
+        * `launchSynchronously` and subsequent functions got improved mechanism
+    * New method `safelyWithResult`
+
+## 0.5.5
+
+* `Versions`
+    * `Ktor`: `1.5.4` -> `1.6.0`
+
+## 0.5.4
+
+* `Versions`:
+    * `Klock`: `2.1.0` -> `2.1.2`
+
+## 0.5.3
+
+* `Versions`:
+    * `Kotlin`: `1.5.0` -> `1.5.10`
+* `Coroutines`:
+    * Extensions `doInUI` and `doInDefault` were replaced in common and available on any supported platform
+    * Extension `doInIO` replaced into `jvm` and available on any `JVM` platform
+    * Old extension `safelyWithouException` without `onException` has been replaced by its copy with `onException` and
+    default value
+        * New value `defaultSafelyWithoutExceptionHandlerWithNull` which is used in all `*WithoutExceptions` by default
+    * Analogs of `launch` and `async` for `safely` and `safelyWithoutExceptions` were added
+    * Analogs of `runCatching` for `safely` and `safelyWithoutExceptions` were added
+
+## 0.5.2
+
+* `Ktor`:
+    * `Client`:
+        * Fixes in `UnifiedRequester`
+
+## 0.5.1
+
+* `Versions`:
+    * `Kotlin Serialization`: `1.2.0` -> `1.2.1`
+
+## 0.5.0
+
+**Notice**: This version is still depend on Kotlin
+Exposed 0.31.1. That means that this version
+may work improperly in modules based on Kotlin
+Exposed
+
+* `Versions`:
+    * `Kotlin Exposed`: `0.30.2` -> `0.31.1`
+    * `Kotlin Coroutines`: `1.4.3` -> `1.5.0`
+    * `RecyclerView`: `1.1.0` -> `1.2.0`
+    * `Ktor`: `1.5.3` -> `1.5.4`
+    * `Klock`: `2.0.7` -> `2.1.0`
+    * `UUID`: `0.2.4` -> `0.3.0`
+* **ALL DEPRECATIONS WERE REMOVED**
+* `Android`:
+    * `Alerts`:
+        * `RecyclerView`:
+            * Classes `ActionViewHolder` and `ActionsRecyclerViewAdapter` became public
+* `Coroutines`:
+    * New extension and function `doSynchronously` which are the same as `launchSynchronously`
+    * New extensions `doInDefault` and `doInIO`
+
+## 0.4.36
+
+* All `Android` targets inside common mpp modules now includes JVM code
+
+## 0.4.35
+
+* `Versions`:
+    * `Kotlin Exposed`: `0.30.1` -> `0.30.2`
+* `Serialization`:
+    * `TypedSerializer`:
+        * Project has been inited
+
+## 0.4.34
+
+* `Versions`:
+    * `uuid`: `0.2.3` -> `0.2.4`
+* `Repos`:
+    * `AbstractExposedCRUDRepo` now implements `StandardCRUDRepo`
+    * `AbstractMutableAndroidCRUDRepo` now implements `StandardCRUDRepo`
+
+## 0.4.33
+
+* `Versions`:
+    * `Ktor`: `1.5.2` -> `1.5.3`
+* `Coroutines`
+    * Add `WeakJob` workaround:
+        * `CoroutineScope#weakLaunch`
+        * `CoroutineScope#weakAsync`
+
+## 0.4.32
+
+* `Versions`:
+    * `Kotlin Exposed`: `0.29.1` -> `0.30.1`
+
+## 0.4.31
+
+* `Versions`:
+    * `Kotlin`: `1.4.31` -> `1.4.32`
+* `Pagination`:
+    * New extensions `PaginationResult.changeResultsUnchecked` and `PaginationResult.changeResults` for mapping results
+    with the same parameters, but different data
+    * Extension `PaginationResult.thisPageIfNotEmpty` now is typed and will return `PaginationResult?` with the same
+    generic type as income `PaginationResult`
+    * New extension `PaginationResult.currentPageIfNotEmpty` - shortcut for `PaginationResult.thisPageIfNotEmpty`
+    * New common functions. They were created as replacements for currently available for more comfortable work
+    with repos pagination:
+        * `doForAll`
+        * `doForAllWithNextPaging`
+        * `doForAllWithCurrentPaging`
+        * `getAll`
+        * `getAllWithNextPaging`
+        * `getAllWithCurrentPaging`
+* `Coroutines`:
+    * Rewrite `subscribeSafelyWithoutExceptions`
+        * Now `subscribeSafelyWithoutExceptions` will use default handler instead of skipping
+    * New extension `subscribeSafelySkippingExceptions`
+* `Repos`
+    * New subproject `repos.cache` - this subproject will contain repos with data caching mechanisms
+    * Most old `doForAll` methods have been deprecated
+
+## 0.4.30
+
+* `Versions`:
+    * `Klock`: `2.0.6` -> `2.0.7`
+* `Pagination`:
+    * New variable `defaultPaginationPageSize` has been added to be able to change default pagination size
+    * Add new value `firstPageWithOneElementPagination` 
+
+## 0.4.29
+
+* `Versions`:
+    * `Coroutines`: `1.4.2` -> `1.4.3`
+* `Repos`:
+    * `Common`
+        * `Android`:
+            * New `blockingReadableTransaction`/`blockingWritableTransaction`
+                * Android databases realizations now use blocking transactions where it is possible
+            * Several improvements in transactions work
+
+## 0.4.28
+
+* `Versions`:
+    * `Kotlin`: `1.4.30` -> `1.4.31`
+    * `Ktor`: `1.5.1` -> `1.5.2`
+* `Coroutines`
+    * Add `createActionsActor`/`createSafeActionsActor` and `doWithSuspending`
+
+## 0.4.27
+
+* `Repos`
+    * `Exposed`
+        * Fix in `AbstractExposedWriteCRUDRepo`
+
+## 0.4.26
+
+* `Versions`:
+    * `Serialization`: `1.0.1` -> `1.1.0`
+
+## 0.4.25
+
+* `Matrix`:
+    * Subproject has been created
+
+## 0.4.24
+
+* `Versions`:
+    * `Kotlin`: `1.4.21` -> `1.4.30`
+    * `Klock`: `2.0.4` -> `2.0.6`
+* `Coroutines`:
+    * New class `DoWithFirstBuilder`
+    * Several new extensions like `firstOf`/`first`/`invokeOnFirstOf`
+
+## 0.4.23
+
+* `Versions`:
+    * `Ktor`: `1.5.0` -> `1.5.1`
+* `Serialization`
+    * `Base64`
+        * New serializer `Base64BytesToFromStringSerializer` has been added
+
 ## 0.4.22
 
 * `Versions`:

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

@@ -15,7 +15,7 @@ data class AlertAction(
     val callback: (DialogInterface) -> Unit
 )
 
-private class ActionViewHolder(
+class ActionViewHolder(
     container: ViewGroup, dialogInterfaceGetter: () -> DialogInterface
 ) : AbstractStandardViewHolder<AlertAction>(container, android.R.layout.simple_list_item_1) {
     private lateinit var action: AlertAction
@@ -34,10 +34,10 @@ private class ActionViewHolder(
     }
 }
 
-private class ActionsRecyclerViewAdapter(
-    data: List<AlertAction>,
+class ActionsRecyclerViewAdapter(
+    override val data: List<AlertAction>,
     private val dialogInterfaceGetter: () -> DialogInterface
-) : RecyclerViewAdapter<AlertAction>(data) {
+) : RecyclerViewAdapter<AlertAction>() {
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): AbstractViewHolder<AlertAction> = ActionViewHolder(
         parent, dialogInterfaceGetter
     )

android/recyclerview/build.gradle

@@ -11,6 +11,7 @@ kotlin {
         commonMain {
             dependencies {
                 api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
+                api project(":micro_utils.common")
             }
         }
         androidMain {

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

@@ -1,12 +1,21 @@
 package dev.inmo.micro_utils.android.recyclerview
 
 import android.view.View
+import android.view.ViewGroup
 import androidx.recyclerview.widget.RecyclerView
+import kotlinx.coroutines.flow.*
 
 
-abstract class RecyclerViewAdapter<T>(
-    val data: List<T>
-): RecyclerView.Adapter<AbstractViewHolder<T>>() {
+abstract class RecyclerViewAdapter<T>: RecyclerView.Adapter<AbstractViewHolder<T>>() {
+    protected abstract val data: List<T>
+
+    private val _dataCountState by lazy {
+        MutableStateFlow<Int>(data.size)
+    }
+    val dataCountState: StateFlow<Int> by lazy {
+        _dataCountState.asStateFlow()
+    }
+
     var emptyView: View? = null
         set(value) {
             field = value
@@ -18,31 +27,37 @@ abstract class RecyclerViewAdapter<T>(
             object : RecyclerView.AdapterDataObserver() {
                 override fun onItemRangeChanged(positionStart: Int, itemCount: Int) {
                     super.onItemRangeChanged(positionStart, itemCount)
+                    _dataCountState.value = data.size
                     checkEmpty()
                 }
 
                 override fun onItemRangeChanged(positionStart: Int, itemCount: Int, payload: Any?) {
                     super.onItemRangeChanged(positionStart, itemCount, payload)
+                    _dataCountState.value = data.size
                     checkEmpty()
                 }
 
                 override fun onChanged() {
                     super.onChanged()
+                    _dataCountState.value = data.size
                     checkEmpty()
                 }
 
                 override fun onItemRangeRemoved(positionStart: Int, itemCount: Int) {
                     super.onItemRangeRemoved(positionStart, itemCount)
+                    _dataCountState.value = data.size
                     checkEmpty()
                 }
 
                 override fun onItemRangeMoved(fromPosition: Int, toPosition: Int, itemCount: Int) {
                     super.onItemRangeMoved(fromPosition, toPosition, itemCount)
+                    _dataCountState.value = data.size
                     checkEmpty()
                 }
 
                 override fun onItemRangeInserted(positionStart: Int, itemCount: Int) {
                     super.onItemRangeInserted(positionStart, itemCount)
+                    _dataCountState.value = data.size
                     checkEmpty()
                 }
             }
@@ -58,7 +73,7 @@ abstract class RecyclerViewAdapter<T>(
 
     private fun checkEmpty() {
         emptyView ?. let {
-            if (data.isEmpty()) {
+            if (dataCountState.value == 0) {
                 it.visibility = View.VISIBLE
             } else {
                 it.visibility = View.GONE
@@ -66,3 +81,11 @@ abstract class RecyclerViewAdapter<T>(
         }
     }
 }
+
+fun <T> RecyclerViewAdapter(
+    data: List<T>,
+    onCreateViewHolder: (parent: ViewGroup, viewType: Int) -> AbstractViewHolder<T>
+) = object : RecyclerViewAdapter<T>() {
+    override val data: List<T> = data
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): AbstractViewHolder<T> = onCreateViewHolder(parent, viewType)
+}

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

@@ -0,0 +1,50 @@
+package dev.inmo.micro_utils.android.recyclerview
+
+import dev.inmo.micro_utils.common.Diff
+import dev.inmo.micro_utils.common.PreviewFeature
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+
+@PreviewFeature("This feature in preview state and may contains different bugs. " +
+                "Besides, this feature can be changed in future in non-compatible way")
+abstract class StateFlowBasedRecyclerViewAdapter<T>(
+    listeningScope: CoroutineScope,
+    dataState: StateFlow<List<T>>
+) : RecyclerViewAdapter<T>() {
+    override var data: List<T> = emptyList()
+
+    init {
+        dataState.onEach {
+            try {
+                val diffForRemoves = Diff(data, it)
+                val removedIndexes = diffForRemoves.removed.map { it.index }
+                val leftRemove = removedIndexes.toMutableList()
+                data = data.filterIndexed { i, _ ->
+                    if (i in leftRemove) {
+                        leftRemove.remove(i)
+                        true
+                    } else {
+                        false
+                    }
+                }
+                withContext(Dispatchers.Main) {
+                    removedIndexes.sortedDescending().forEach {
+                        notifyItemRemoved(it)
+                    }
+                }
+                val diffAddsAndReplaces = Diff(data, it)
+                data = it
+                withContext(Dispatchers.Main) {
+                    diffAddsAndReplaces.replaced.forEach { (from, to) ->
+                        notifyItemMoved(from.index, to.index)
+                    }
+                    diffAddsAndReplaces.added.forEach {
+                        notifyItemInserted(it.index)
+                    }
+                }
+            } catch (e: Throwable) {
+                // currently do nothing
+            }
+        }.launchIn(listeningScope)
+    }
+}

build.gradle

@@ -8,7 +8,7 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.0.2'
+        classpath 'com.android.tools.build:gradle:4.1.3'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
         classpath "com.getkeepsafe.dexcount:dexcount-gradle-plugin:$dexcount_version"
@@ -25,6 +25,15 @@ allprojects {
         google()
         maven { url "https://kotlin.bintray.com/kotlinx" }
     }
+
+    // temporal crutch until legacy tests will be stabled or legacy target will be removed
+    if (it != rootProject.findProject("docs")) {
+        tasks.whenTaskAdded { task ->
+            if(task.name == "jsLegacyBrowserTest" || task.name == "jsLegacyNodeTest") {
+                task.enabled = false
+            }
+        }
+    }
 }
 
 apply from: "./extensions.gradle"

common/build.gradle

@@ -5,3 +5,18 @@ plugins {
 }
 
 apply from: "$mppProjectWithSerializationPresetPath"
+
+kotlin {
+    sourceSets {
+        jvmMain {
+            dependencies {
+                api project(":micro_utils.coroutines")
+            }
+        }
+        androidMain {
+            dependencies {
+                api project(":micro_utils.coroutines")
+            }
+        }
+    }
+}

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

@@ -16,7 +16,7 @@ package dev.inmo.micro_utils.common
     AnnotationTarget.TYPEALIAS,
     AnnotationTarget.TYPE_PARAMETER
 )
-annotation class PreviewFeature
+annotation class PreviewFeature(val message: String = "It is possible, that behaviour of this thing will be changed or removed in future releases")
 
 @RequiresOptIn(
     "This thing is marked as warned. See message of warn to get more info",

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

@@ -1,89 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlin.experimental.and
-
-private const val BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-private const val BASE64_MASK: Byte = 0x3f
-private const val BASE64_PAD = '='
-private val BASE64_INVERSE_ALPHABET = IntArray(256) {
-    BASE64_ALPHABET.indexOf(it.toChar())
-}
-
-internal fun Int.toBase64(): Char = BASE64_ALPHABET[this]
-internal fun Byte.fromBase64(): Byte = BASE64_INVERSE_ALPHABET[toInt() and 0xff].toByte() and BASE64_MASK
-
-const val replacedInCrypto = "Replaced in crypto subproject"
-
-@Deprecated(replacedInCrypto, ReplaceWith("EncodedBase64String", "dev.inmo.micro_utils.crypto"))
-typealias EncodedBase64String = String
-@Deprecated(replacedInCrypto, ReplaceWith("EncodedByteArray", "dev.inmo.micro_utils.crypto"))
-typealias EncodedByteArray = ByteArray
-
-@Deprecated(replacedInCrypto, ReplaceWith("encodeBase64String()", "dev.inmo.micro_utils.crypto"))
-fun String.encodeBase64String(): EncodedBase64String = encodeToByteArray().encodeBase64String()
-@Deprecated(replacedInCrypto, ReplaceWith("encodeBase64()", "dev.inmo.micro_utils.crypto"))
-fun String.encodeBase64(): EncodedByteArray = encodeToByteArray().encodeBase64()
-
-@Deprecated(replacedInCrypto, ReplaceWith("encodeBase64String()", "dev.inmo.micro_utils.crypto"))
-fun ByteArray.encodeBase64String(): EncodedBase64String = buildString {
-    var i = 0
-    while (this@encodeBase64String.size > i) {
-        val read = kotlin.math.min(3, this@encodeBase64String.size - i)
-        val data = ByteArray(3) {
-            if (it < read) {
-                this@encodeBase64String[it + i]
-            } else {
-                0
-            }
-        }
-
-        val padSize = (data.size - read) * 8 / 6
-        val chunk = ((data[0].toInt() and 0xFF) shl 16) or
-            ((data[1].toInt() and 0xFF) shl 8) or
-            (data[2].toInt() and 0xFF)
-
-        for (index in data.size downTo padSize) {
-            val char = (chunk shr (6 * index)) and BASE64_MASK.toInt()
-            append(char.toBase64())
-        }
-
-        repeat(padSize) { append(BASE64_PAD) }
-
-        i += read
-    }
-}
-@Deprecated(replacedInCrypto, ReplaceWith("encodeBase64()", "dev.inmo.micro_utils.crypto"))
-fun ByteArray.encodeBase64(): EncodedByteArray = encodeBase64String().encodeToByteArray()
-
-@Deprecated(replacedInCrypto, ReplaceWith("decodeBase64()", "dev.inmo.micro_utils.crypto"))
-fun EncodedBase64String.decodeBase64() = dropLastWhile { it == BASE64_PAD }.encodeToByteArray().decodeBase64()
-@Deprecated(replacedInCrypto, ReplaceWith("decodeBase64String()", "dev.inmo.micro_utils.crypto"))
-fun EncodedBase64String.decodeBase64String() = decodeBase64().decodeToString()
-
-@Deprecated(replacedInCrypto, ReplaceWith("decodeBase64()", "dev.inmo.micro_utils.crypto"))
-fun EncodedByteArray.decodeBase64(): ByteArray {
-    val result = mutableListOf<Byte>()
-    val data = ByteArray(4)
-    (0 until size step 4).forEach { i ->
-        var read = 0
-        for (j in 0 until 4) {
-            if (j + i < size) {
-                data[j] = get(j + i)
-                read++
-            } else {
-                break
-            }
-        }
-        val chunk = data.foldIndexed(0) { index, result, current ->
-            result or (current.fromBase64().toInt() shl ((3 - index) * 6))
-        }
-        for (index in data.size - 2 downTo (data.size - read)) {
-            val origin = (chunk shr (8 * index)) and 0xff
-            result.add(origin.toByte())
-        }
-    }
-
-    return result.toByteArray()
-}
-@Deprecated(replacedInCrypto, ReplaceWith("decodeBase64String()", "dev.inmo.micro_utils.crypto"))
-fun EncodedByteArray.decodeBase64String() = decodeBase64().decodeToString()

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

@@ -7,9 +7,17 @@ import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 
 typealias ByteArrayAllocator = () -> ByteArray
+typealias SuspendByteArrayAllocator = suspend () -> ByteArray
 
 val ByteArray.asAllocator: ByteArrayAllocator
     get() = { this }
+val ByteArray.asSuspendAllocator: SuspendByteArrayAllocator
+    get() = { this }
+val ByteArrayAllocator.asSuspendAllocator: SuspendByteArrayAllocator
+    get() = { this() }
+suspend fun SuspendByteArrayAllocator.asAllocator(): ByteArrayAllocator {
+    return invoke().asAllocator
+}
 
 object ByteArrayAllocatorSerializer : KSerializer<ByteArrayAllocator> {
     private val realSerializer = ByteArraySerializer()
@@ -17,7 +25,7 @@ object ByteArrayAllocatorSerializer : KSerializer<ByteArrayAllocator> {
 
     override fun deserialize(decoder: Decoder): ByteArrayAllocator {
         val bytes = realSerializer.deserialize(decoder)
-        return { bytes }
+        return bytes.asAllocator
     }
 
     override fun serialize(encoder: Encoder, value: ByteArrayAllocator) {

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

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.common
+
+fun <T> Iterable<T?>.firstNotNull() = first { it != null }!!

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

@@ -0,0 +1,31 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.serialization.Serializable
+import kotlin.jvm.JvmInline
+
+@Serializable
+@JvmInline
+value class FileName(val string: String) {
+    val name: String
+        get() = string.takeLastWhile { it != '/' }
+    val extension: String
+        get() = name.takeLastWhile { it != '.' }
+    val nameWithoutExtension: String
+        get() {
+            val filename = name
+            return filename.indexOfLast { it == '.' }.takeIf { it > -1 } ?.let {
+                filename.substring(0, it)
+            } ?: filename
+        }
+    override fun toString(): String = string
+}
+
+
+@PreviewFeature
+expect class MPPFile
+
+expect val MPPFile.filename: FileName
+expect val MPPFile.filesize: Long
+expect val MPPFile.bytesAllocator: SuspendByteArrayAllocator
+suspend fun MPPFile.bytes() = bytesAllocator()
+

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

@@ -1,33 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlin.random.Random
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-
-
-class Base64Text {
-
-    val testText = """Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?"""
-    val base64Text = """TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlzIG5vc3RydWQgZXhlcmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1aXAgZXggZWEgY29tbW9kbyBjb25zZXF1YXQuIER1aXMgYXV0ZSBpcnVyZSBkb2xvciBpbiByZXByZWhlbmRlcml0IGluIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIGNpbGx1bSBkb2xvcmUgZXUgZnVnaWF0IG51bGxhIHBhcmlhdHVyLiBFeGNlcHRldXIgc2ludCBvY2NhZWNhdCBjdXBpZGF0YXQgbm9uIHByb2lkZW50LCBzdW50IGluIGN1bHBhIHF1aSBvZmZpY2lhIGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtLgpTZWQgdXQgcGVyc3BpY2lhdGlzIHVuZGUgb21uaXMgaXN0ZSBuYXR1cyBlcnJvciBzaXQgdm9sdXB0YXRlbSBhY2N1c2FudGl1bSBkb2xvcmVtcXVlIGxhdWRhbnRpdW0sIHRvdGFtIHJlbSBhcGVyaWFtLCBlYXF1ZSBpcHNhIHF1YWUgYWIgaWxsbyBpbnZlbnRvcmUgdmVyaXRhdGlzIGV0IHF1YXNpIGFyY2hpdGVjdG8gYmVhdGFlIHZpdGFlIGRpY3RhIHN1bnQgZXhwbGljYWJvLiBOZW1vIGVuaW0gaXBzYW0gdm9sdXB0YXRlbSBxdWlhIHZvbHVwdGFzIHNpdCBhc3Blcm5hdHVyIGF1dCBvZGl0IGF1dCBmdWdpdCwgc2VkIHF1aWEgY29uc2VxdXVudHVyIG1hZ25pIGRvbG9yZXMgZW9zIHF1aSByYXRpb25lIHZvbHVwdGF0ZW0gc2VxdWkgbmVzY2l1bnQuIE5lcXVlIHBvcnJvIHF1aXNxdWFtIGVzdCwgcXVpIGRvbG9yZW0gaXBzdW0gcXVpYSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIsIGFkaXBpc2NpIHZlbGl0LCBzZWQgcXVpYSBub24gbnVtcXVhbSBlaXVzIG1vZGkgdGVtcG9yYSBpbmNpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hbSBhbGlxdWFtIHF1YWVyYXQgdm9sdXB0YXRlbS4gVXQgZW5pbSBhZCBtaW5pbWEgdmVuaWFtLCBxdWlzIG5vc3RydW0gZXhlcmNpdGF0aW9uZW0gdWxsYW0gY29ycG9yaXMgc3VzY2lwaXQgbGFib3Jpb3NhbSwgbmlzaSB1dCBhbGlxdWlkIGV4IGVhIGNvbW1vZGkgY29uc2VxdWF0dXI/IFF1aXMgYXV0ZW0gdmVsIGV1bSBpdXJlIHJlcHJlaGVuZGVyaXQgcXVpIGluIGVhIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIHF1YW0gbmloaWwgbW9sZXN0aWFlIGNvbnNlcXVhdHVyLCB2ZWwgaWxsdW0gcXVpIGRvbG9yZW0gZXVtIGZ1Z2lhdCBxdW8gdm9sdXB0YXMgbnVsbGEgcGFyaWF0dXI/"""
-
-    @Test
-    fun decodeEncode() {
-        val encoded = testText.encodeBase64String()
-        assertEquals(base64Text, encoded)
-        val decoded = encoded.decodeBase64String()
-        assertEquals(testText, decoded)
-    }
-
-    val urlTestText = "https://example.com?isitexample=1"
-    val urlTestBase64Text = "aHR0cHM6Ly9leGFtcGxlLmNvbT9pc2l0ZXhhbXBsZT0x"
-
-    @Test
-    fun decodeEncodeUrl() {
-        val encoded = urlTestText.encodeBase64String()
-        assertEquals(urlTestBase64Text, encoded)
-        val decoded = encoded.decodeBase64String()
-        assertEquals(urlTestText, decoded)
-    }
-}

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

@@ -0,0 +1,32 @@
+package dev.inmo.micro_utils.common
+
+import org.khronos.webgl.ArrayBuffer
+import org.w3c.dom.ErrorEvent
+import org.w3c.files.File
+import org.w3c.files.FileReader
+import kotlin.js.Promise
+
+actual typealias MPPFile = File
+
+fun MPPFile.readBytesPromise() = Promise<ByteArray> { success, failure ->
+    val reader = FileReader()
+    reader.onload = {
+        success((reader.result as ArrayBuffer).toByteArray())
+        Unit
+    }
+    reader.onerror = {
+        failure(Exception((it as ErrorEvent).message))
+        Unit
+    }
+    reader.readAsArrayBuffer(this)
+}
+
+private suspend fun MPPFile.dirtyReadBytes(): ByteArray = readBytesPromise().await()
+
+actual val MPPFile.filename: FileName
+    get() = FileName(name)
+actual val MPPFile.filesize: Long
+    get() = size.toLong()
+@Warning("That is not optimized version of bytes allocator. Use asyncBytesAllocator everywhere you can")
+actual val MPPFile.bytesAllocator: SuspendByteArrayAllocator
+    get() = ::dirtyReadBytes

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

@@ -0,0 +1,8 @@
+package dev.inmo.micro_utils.common
+
+import kotlin.coroutines.*
+import kotlin.js.Promise
+
+suspend fun <T> Promise<T>.await(): T = suspendCoroutine { cont ->
+    then({ cont.resume(it) }, { cont.resumeWithException(it) })
+}

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

@@ -0,0 +1,20 @@
+package dev.inmo.micro_utils.common
+
+import dev.inmo.micro_utils.coroutines.doInIO
+import dev.inmo.micro_utils.coroutines.doOutsideOfCoroutine
+import java.io.File
+
+actual typealias MPPFile = File
+
+actual val MPPFile.filename: FileName
+    get() = FileName(name)
+actual val MPPFile.filesize: Long
+    get() = length()
+actual val MPPFile.bytesAllocator: SuspendByteArrayAllocator
+    get() = {
+        doInIO {
+            doOutsideOfCoroutine {
+                readBytes()
+            }
+        }
+    }

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

@@ -33,3 +33,15 @@ fun View.toggleVisibility(goneOnHide: Boolean = true) {
         show()
     }
 }
+
+fun View.changeVisibility(show: Boolean = !isShown, goneOnHide: Boolean = true) {
+    if (show) {
+        show()
+    } else {
+        if (goneOnHide) {
+            gone()
+        } else {
+            hide()
+        }
+    }
+}

coroutines/build.gradle

@@ -19,4 +19,4 @@ kotlin {
             }
         }
     }
-}
+}

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

@@ -0,0 +1,46 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
+import kotlin.coroutines.*
+
+interface ActorAction<T> {
+    suspend operator fun invoke(): T
+}
+
+/**
+ * Planned to use with [doWithSuspending]. Will execute incoming lambdas sequentially
+ *
+ * @see actor
+ */
+fun CoroutineScope.createActionsActor() = actor<suspend () -> Unit> {
+    it()
+}
+
+/**
+ * Planned to use with [doWithSuspending]. Will execute incoming lambdas sequentially
+ *
+ * @see safeActor
+ */
+inline fun CoroutineScope.createSafeActionsActor(
+    noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler
+) = safeActor<suspend () -> Unit>(Channel.UNLIMITED, onException) {
+    it()
+}
+
+/**
+ * Must be use with actor created by [createActionsActor] or [createSafeActionsActor]. Will send lambda which will
+ * execute [action] and return result.
+ *
+ * @see suspendCoroutine
+ * @see safely
+ */
+suspend fun <T> Channel<suspend () -> Unit>.doWithSuspending(
+    action: ActorAction<T>
+) = suspendCoroutine<T> {
+    trySend {
+        safely({ e -> it.resumeWithException(e) }) {
+            it.resume(action())
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import kotlin.coroutines.CoroutineContext
+
+inline val UI
+    get() = Dispatchers.Main
+inline val Default
+    get() = Dispatchers.Default
+
+suspend inline fun <T> doIn(context: CoroutineContext, noinline block: suspend CoroutineScope.() -> T) = withContext(
+    context,
+    block
+)
+
+suspend inline fun <T> doInUI(noinline block: suspend CoroutineScope.() -> T) = doIn(
+    UI,
+    block
+)
+suspend inline fun <T> doInDefault(noinline block: suspend CoroutineScope.() -> T) = doIn(
+    Default,
+    block
+)

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

@@ -9,6 +9,19 @@ class DeferredAction<T, O>(
     suspend operator fun invoke() = callback(deferred.await())
 }
 
+class DoWithFirstBuilder<T>(
+    private val scope: CoroutineScope
+) {
+    private val deferreds = mutableListOf<Deferred<T>>()
+    operator fun plus(block: suspend CoroutineScope.() -> T) {
+        deferreds.add(scope.async(start = CoroutineStart.LAZY, block = block))
+    }
+    inline fun add(noinline block: suspend CoroutineScope.() -> T) = plus(block)
+    inline fun include(noinline block: suspend CoroutineScope.() -> T) = plus(block)
+
+    fun build() = deferreds.toList()
+}
+
 fun <T, O> Deferred<T>.buildAction(callback: suspend (T) -> O) = DeferredAction(this, callback)
 
 suspend fun <O> Iterable<DeferredAction<*, O>>.invokeFirstOf(
@@ -32,9 +45,41 @@ suspend fun <T, O> Iterable<Deferred<T>>.invokeOnFirst(
     callback: suspend (T) -> O
 ): O = map { it.buildAction(callback) }.invokeFirstOf(scope, cancelOnResult)
 
+suspend fun <T, O> CoroutineScope.invokeOnFirstOf(
+    cancelOnResult: Boolean = true,
+    block: DoWithFirstBuilder<T>.() -> Unit,
+    callback: suspend (T) -> O
+) = firstOf(
+    DoWithFirstBuilder<T>(this).apply(block).build(),
+    cancelOnResult
+).let { callback(it) }
+
 suspend fun <T, O> invokeOnFirst(
     scope: CoroutineScope,
     vararg variants: Deferred<T>,
     cancelOnResult: Boolean = true,
     callback: suspend (T) -> O
 ): O = variants.toList().invokeOnFirst(scope, cancelOnResult, callback)
+
+suspend fun <T> CoroutineScope.firstOf(
+    variants: Iterable<Deferred<T>>,
+    cancelOnResult: Boolean = true
+) = variants.invokeOnFirst(this, cancelOnResult) { it }
+
+suspend fun <T> CoroutineScope.firstOf(
+    cancelOnResult: Boolean = true,
+    block: DoWithFirstBuilder<T>.() -> Unit
+) = firstOf(
+    DoWithFirstBuilder<T>(this).apply(block).build(),
+    cancelOnResult
+)
+
+suspend fun <T> CoroutineScope.firstOf(
+    vararg variants: Deferred<T>,
+    cancelOnResult: Boolean = true
+) = firstOf(variants.toList(), cancelOnResult)
+
+suspend fun <T> List<Deferred<T>>.first(
+    scope: CoroutineScope,
+    cancelOnResult: Boolean = true
+) = scope.firstOf(this, cancelOnResult)

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

@@ -0,0 +1,6 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+
+suspend fun <T> Flow<T?>.firstNotNull() = first { it != null }!!

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

@@ -4,6 +4,8 @@ package dev.inmo.micro_utils.coroutines
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 
 /**
  * Shortcut for chain if [Flow.onEach] and [Flow.launchIn]
@@ -25,13 +27,26 @@ inline fun <T> Flow<T>.subscribeSafely(
 }
 
 /**
- * Use [subscribeSafelyWithoutExceptions], but all exceptions inside of [safely] will be skipped
+ * Use [subscribeSafelyWithoutExceptions], but all exceptions will be passed to [defaultSafelyExceptionHandler]
  */
 inline fun <T> Flow<T>.subscribeSafelyWithoutExceptions(
     scope: CoroutineScope,
+    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
     noinline block: suspend (T) -> Unit
-) = subscribeSafely(
-    scope,
-    {},
-    block
-)
+) = subscribe(scope) {
+    safelyWithoutExceptions(onException) {
+        block(it)
+    }
+}
+
+/**
+ * Use [subscribeSafelyWithoutExceptions], but all exceptions inside of [safely] will be skipped
+ */
+inline fun <T> Flow<T>.subscribeSafelySkippingExceptions(
+    scope: CoroutineScope,
+    noinline block: suspend (T) -> Unit
+) = subscribe(scope) {
+    safelyWithoutExceptions({ /* skip exceptions */ }) {
+        block(it)
+    }
+}

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

@@ -0,0 +1,118 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.*
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+private class SubscribeAsyncReceiver<T>(
+    val scope: CoroutineScope,
+    output: suspend SubscribeAsyncReceiver<T>.(T) -> Unit
+) {
+    private val dataChannel: Channel<T> = Channel(Channel.UNLIMITED)
+    val channel: SendChannel<T>
+        get() = dataChannel
+
+    init {
+        scope.launchSafelyWithoutExceptions {
+            for (data in dataChannel) {
+                output(data)
+            }
+        }
+    }
+
+    fun isEmpty(): Boolean = dataChannel.isEmpty
+}
+
+private sealed interface AsyncSubscriptionCommand<T, M> {
+    suspend operator fun invoke(markersMap: MutableMap<M, SubscribeAsyncReceiver<T>>)
+}
+private data class AsyncSubscriptionCommandData<T, M>(
+    val data: T,
+    val scope: CoroutineScope,
+    val markerFactory: suspend (T) -> M,
+    val block: suspend (T) -> Unit,
+    val onEmpty: suspend (M) -> Unit
+) : AsyncSubscriptionCommand<T, M> {
+    override suspend fun invoke(markersMap: MutableMap<M, SubscribeAsyncReceiver<T>>) {
+        val marker = markerFactory(data)
+        markersMap.getOrPut(marker) {
+            SubscribeAsyncReceiver(scope.LinkedSupervisorScope()) {
+                safelyWithoutExceptions { block(it) }
+                if (isEmpty()) {
+                    onEmpty(marker)
+                }
+            }
+        }.channel.send(data)
+    }
+}
+
+private data class AsyncSubscriptionCommandClearReceiver<T, M>(
+    val marker: M
+) : AsyncSubscriptionCommand<T, M> {
+    override suspend fun invoke(markersMap: MutableMap<M, SubscribeAsyncReceiver<T>>) {
+        val receiver = markersMap[marker]
+        if (receiver ?.isEmpty() == true) {
+            markersMap.remove(marker)
+            receiver.scope.cancel()
+        }
+    }
+}
+
+fun <T, M> Flow<T>.subscribeAsync(
+    scope: CoroutineScope,
+    markerFactory: suspend (T) -> M,
+    block: suspend (T) -> Unit
+): Job {
+    val subscope = scope.LinkedSupervisorScope()
+    val markersMap = mutableMapOf<M, SubscribeAsyncReceiver<T>>()
+    val actor = subscope.actor<AsyncSubscriptionCommand<T, M>>(Channel.UNLIMITED) {
+        it.invoke(markersMap)
+    }
+
+    val job = subscribeSafelyWithoutExceptions(subscope) { data ->
+        val dataCommand = AsyncSubscriptionCommandData(data, subscope, markerFactory, block) { marker ->
+            actor.send(
+                AsyncSubscriptionCommandClearReceiver(marker)
+            )
+        }
+        actor.send(dataCommand)
+    }
+
+    job.invokeOnCompletion { if (subscope.isActive) subscope.cancel() }
+
+    return job
+}
+
+inline fun <T, M> Flow<T>.subscribeSafelyAsync(
+    scope: CoroutineScope,
+    noinline markerFactory: suspend (T) -> M,
+    noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
+    noinline block: suspend (T) -> Unit
+) = subscribeAsync(scope, markerFactory) {
+    safely(onException) {
+        block(it)
+    }
+}
+
+inline fun <T, M> Flow<T>.subscribeSafelyWithoutExceptionsAsync(
+    scope: CoroutineScope,
+    noinline markerFactory: suspend (T) -> M,
+    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
+    noinline block: suspend (T) -> Unit
+) = subscribeAsync(scope, markerFactory) {
+    safelyWithoutExceptions(onException) {
+        block(it)
+    }
+}
+
+inline fun <T, M> Flow<T>.subscribeSafelySkippingExceptionsAsync(
+    scope: CoroutineScope,
+    noinline markerFactory: suspend (T) -> M,
+    noinline block: suspend (T) -> Unit
+) = subscribeAsync(scope, markerFactory) {
+    safelyWithoutExceptions({ /* do nothing */}) {
+        block(it)
+    }
+}

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

@@ -22,34 +22,6 @@ var defaultSafelyWithoutExceptionHandler: ExceptionHandler<Unit> = {
     }
 }
 
-/**
- * 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]
@@ -114,6 +86,9 @@ suspend fun <T> safelyWithContextExceptionHandler(
  * * [CoroutineContext.get] with [SafelyExceptionHandlerKey] as key
  * * [defaultSafelyExceptionHandler]
  *
+ * Remember, that [ExceptionHandler] from [CoroutineContext.get] will be used anyway if it is available. After it will
+ * be called [onException]
+ *
  * @param [onException] Will be called when happen exception inside of [block]. By default will throw exception - this
  * exception will be available for catching
  *
@@ -133,24 +108,42 @@ suspend inline fun <T> safely(
     }
 }
 
+suspend inline fun <T> runCatchingSafely(
+    noinline onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
+    noinline block: suspend CoroutineScope.() -> T
+): Result<T> = runCatching {
+    safely(onException, block)
+}
+
+suspend inline fun <T> safelyWithResult(
+    noinline block: suspend CoroutineScope.() -> T
+): Result<T> = runCatchingSafely(defaultSafelyExceptionHandler, block)
+
+/**
+ * Use this handler in cases you wish to include handling of exceptions by [defaultSafelyWithoutExceptionHandler] and
+ * returning null at one time
+ *
+ * @see safelyWithoutExceptions
+ * @see launchSafelyWithoutExceptions
+ * @see asyncSafelyWithoutExceptions
+ */
+val defaultSafelyWithoutExceptionHandlerWithNull: ExceptionHandler<Nothing?> = {
+    defaultSafelyWithoutExceptionHandler.invoke(it)
+    null
+}
+
 /**
  * Shortcut for [safely] with exception handler, that as expected must return null in case of impossible creating of
- * result from exception (instead of throwing it)
+ * result from exception (instead of throwing it, by default always returns null)
  */
 suspend inline fun <T> safelyWithoutExceptions(
-    noinline onException: ExceptionHandler<T?>,
+    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
     noinline block: suspend CoroutineScope.() -> T
 ): T? = safely(onException, block)
 
-/**
- * Shortcut for [safely] without exception handler (instead of this you will always receive null as a result)
- */
-suspend inline fun <T> safelyWithoutExceptions(
+suspend inline fun <T> runCatchingSafelyWithoutExceptions(
+    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
     noinline block: suspend CoroutineScope.() -> T
-): T? = safelyWithoutExceptions(
-    {
-        defaultSafelyWithoutExceptionHandler.invoke(it)
-        null
-    },
-    block
-)
+): Result<T?> = runCatching {
+    safelyWithoutExceptions(onException, block)
+}

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

@@ -0,0 +1,41 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+
+inline fun CoroutineScope.launchSafely(
+    context: CoroutineContext = EmptyCoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
+    noinline block: suspend CoroutineScope.() -> Unit
+) = launch(context, start) {
+    safely(onException, block)
+}
+
+inline fun CoroutineScope.launchSafelyWithoutExceptions(
+    context: CoroutineContext = EmptyCoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    noinline onException: ExceptionHandler<Unit?> = defaultSafelyWithoutExceptionHandlerWithNull,
+    noinline block: suspend CoroutineScope.() -> Unit
+) = launch(context, start) {
+    safelyWithoutExceptions(onException, block)
+}
+
+inline fun <T> CoroutineScope.asyncSafely(
+    context: CoroutineContext = EmptyCoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    noinline onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
+    noinline block: suspend CoroutineScope.() -> T
+) = async(context, start) {
+    safely(onException, block)
+}
+
+inline fun <T> CoroutineScope.asyncSafelyWithoutExceptions(
+    context: CoroutineContext = EmptyCoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
+    noinline block: suspend CoroutineScope.() -> T
+) = async(context, start) {
+    safelyWithoutExceptions(onException, block)
+}

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

@@ -0,0 +1,17 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import kotlin.coroutines.CoroutineContext
+
+fun CoroutineContext.LinkedSupervisorJob(
+    additionalContext: CoroutineContext? = null
+) = SupervisorJob(job).let { if (additionalContext != null) it + additionalContext else it }
+fun CoroutineScope.LinkedSupervisorJob(
+    additionalContext: CoroutineContext? = null
+) = coroutineContext.LinkedSupervisorJob(additionalContext)
+
+fun CoroutineScope.LinkedSupervisorScope(
+    additionalContext: CoroutineContext? = null
+) = CoroutineScope(
+    coroutineContext + LinkedSupervisorJob(additionalContext)
+)

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

@@ -0,0 +1,31 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+
+private fun CoroutineScope.createWeakSubScope() = CoroutineScope(coroutineContext.minusKey(Job)).also { newScope ->
+    coroutineContext.job.invokeOnCompletion { newScope.cancel() }
+}
+
+fun CoroutineScope.weakLaunch(
+    context: CoroutineContext = EmptyCoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    block: suspend CoroutineScope.() -> Unit
+): Job {
+    val scope = createWeakSubScope()
+    val job = scope.launch(context, start, block)
+    job.invokeOnCompletion { scope.cancel() }
+    return job
+}
+
+fun <T> CoroutineScope.weakAsync(
+    context: CoroutineContext = EmptyCoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    block: suspend CoroutineScope.() -> T
+): Deferred<T> {
+    val scope = createWeakSubScope()
+    val deferred = scope.async(context, start, block)
+    deferred.invokeOnCompletion { scope.cancel() }
+    return deferred
+}

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

@@ -0,0 +1,11 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+
+val IO
+    get() = Dispatchers.IO
+
+suspend inline fun <T> doInIO(noinline block: suspend CoroutineScope.() -> T) = doIn(
+    IO,
+    block
+)

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

@@ -3,28 +3,24 @@ 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 = {
+    var result: Result<T>? = null
+    val objectToSynchronize = Object()
+    synchronized(objectToSynchronize) {
         launch {
-            safely(
-                {
-                    throwable = it
-                }
-            ) {
-                result = block()
-            }
+            result = safelyWithResult(block)
+        }.invokeOnCompletion {
             synchronized(objectToSynchronize) {
                 objectToSynchronize.notifyAll()
             }
         }
+        while (result == null) {
+            objectToSynchronize.wait()
+        }
     }
-    synchronized(objectToSynchronize) {
-        launchCallback()
-        objectToSynchronize.wait()
-    }
-    throw throwable ?: return result!!
+    return result!!.getOrThrow()
 }
 
 fun <T> launchSynchronously(block: suspend CoroutineScope.() -> T): T = CoroutineScope(Dispatchers.Default).launchSynchronously(block)
+
+fun <T> CoroutineScope.doSynchronously(block: suspend CoroutineScope.() -> T): T = launchSynchronously(block)
+fun <T> doSynchronously(block: suspend CoroutineScope.() -> T): T = launchSynchronously(block)

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

@@ -1,9 +1,8 @@
 package dev.inmo.micro_utils.coroutines
 
-import dev.inmo.micro_utils.coroutines.asDeferred
-import dev.inmo.micro_utils.coroutines.launchSynchronously
 import kotlinx.coroutines.*
-import kotlin.test.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
 
 class DoWithFirstTests {
     @Test

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

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

coroutines/src/main/kotlin/dev/inmo/micro_utils/coroutines/DoInUI.kt

@@ -1,10 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-
-suspend inline fun <T> doInUI(noinline block: suspend CoroutineScope.() -> T) = withContext(
-    Dispatchers.Main,
-    block
-)

defaultAndroidSettings.gradle

@@ -1,5 +1,30 @@
 apply plugin: 'com.getkeepsafe.dexcount'
 
+ext {
+    jvmKotlinFolderFile = {
+        String sep = File.separator
+        return new File("${project.projectDir}${sep}src${sep}jvmMain${sep}kotlin")
+    }
+
+    enableIncludingJvmCodeInAndroidPart = {
+        File jvmKotlinFolder = jvmKotlinFolderFile()
+        if (jvmKotlinFolder.exists()) {
+            android.sourceSets.main.java.srcDirs += jvmKotlinFolder.path
+        }
+    }
+
+    disableIncludingJvmCodeInAndroidPart = {
+        File jvmKotlinFolder = jvmKotlinFolderFile()
+        String[] oldDirs = android.sourceSets.main.java.srcDirs
+        android.sourceSets.main.java.srcDirs = []
+        for (oldDir in oldDirs) {
+            if (oldDir != jvmKotlinFolder.path) {
+                android.sourceSets.main.java.srcDirs += oldDir
+            }
+        }
+    }
+}
+
 android {
     compileSdkVersion "$android_compileSdkVersion".toInteger()
     buildToolsVersion "$android_buildToolsVersion"
@@ -35,6 +60,8 @@ android {
     }
 
     sourceSets {
-        main.java.srcDirs += 'src/main/kotlin'
+        String sep = File.separator
+        main.java.srcDirs += "src${sep}main${sep}kotlin"
+        enableIncludingJvmCodeInAndroidPart()
     }
 }

extensions.gradle

@@ -20,11 +20,11 @@ allprojects {
 
         releaseMode = (project.hasProperty('RELEASE_MODE') && project.property('RELEASE_MODE') == "true") || System.getenv('RELEASE_MODE') == "true"
 
-        mppProjectWithSerializationPresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerialization"
-        mppJavaProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJavaProject"
-        mppAndroidProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppAndroidProject"
+        mppProjectWithSerializationPresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerialization.gradle"
+        mppJavaProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJavaProject.gradle"
+        mppAndroidProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppAndroidProject.gradle"
 
-        defaultAndroidSettingsPresetPath = "${rootProject.projectDir.absolutePath}/defaultAndroidSettings"
+        defaultAndroidSettingsPresetPath = "${rootProject.projectDir.absolutePath}/defaultAndroidSettings.gradle"
 
         publishGradlePath = "${rootProject.projectDir.absolutePath}/publish.gradle"
         publishMavenPath = "${rootProject.projectDir.absolutePath}/maven.publish.gradle"

fsm/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 project(":micro_utils.coroutines")
+            }
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+package dev.inmo.micro_utils.fsm.common
+
+interface State {
+    val context: Any
+}

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

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.fsm.common
+
+import kotlin.reflect.KClass
+
+class StateHandlerHolder<I : State>(
+    private val inputKlass: KClass<I>,
+    private val strict: Boolean = false,
+    private val delegateTo: StatesHandler<I>
+) : StatesHandler<State> {
+    fun checkHandleable(state: State) = state::class == inputKlass || (!strict && inputKlass.isInstance(state))
+
+    override suspend fun StatesMachine.handleState(state: State): State? {
+        return delegateTo.run { handleState(state as I) }
+    }
+}

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

@@ -0,0 +1,5 @@
+package dev.inmo.micro_utils.fsm.common
+
+fun interface StatesHandler<I : State> {
+    suspend fun StatesMachine.handleState(state: I): State?
+}

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

@@ -0,0 +1,46 @@
+package dev.inmo.micro_utils.fsm.common
+
+import dev.inmo.micro_utils.coroutines.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.asFlow
+
+private suspend fun <I : State> StatesMachine.launchStateHandling(
+    state: State,
+    handlers: List<StateHandlerHolder<out I>>
+): State? {
+    return handlers.firstOrNull { it.checkHandleable(state) } ?.run {
+        handleState(state)
+    }
+}
+
+class StatesMachine (
+    private val statesManager: StatesManager,
+    private val handlers: List<StateHandlerHolder<*>>
+) : StatesHandler<State> {
+    override suspend fun StatesMachine.handleState(state: State): State? = launchStateHandling(state, handlers)
+
+    fun start(scope: CoroutineScope): Job = scope.launchSafelyWithoutExceptions {
+        val statePerformer: suspend (State) -> Unit = { state: State ->
+            val newState = launchStateHandling(state, handlers)
+            if (newState != null) {
+                statesManager.update(state, newState)
+            } else {
+                statesManager.endChain(state)
+            }
+        }
+        statesManager.onStartChain.subscribeSafelyWithoutExceptions(this) {
+            launch { statePerformer(it) }
+        }
+        statesManager.onChainStateUpdated.subscribeSafelyWithoutExceptions(this) {
+            launch { statePerformer(it.second) }
+        }
+
+        statesManager.getActiveStates().forEach {
+            launch { statePerformer(it) }
+        }
+    }
+
+    suspend fun startChain(state: State) {
+        statesManager.startChain(state)
+    }
+}

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

@@ -0,0 +1,92 @@
+package dev.inmo.micro_utils.fsm.common
+
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+interface StatesManager {
+    val onChainStateUpdated: Flow<Pair<State, State>>
+    val onStartChain: Flow<State>
+    val onEndChain: Flow<State>
+
+
+    /**
+     * Must set current set using [State.context]
+     */
+    suspend fun update(old: State, new: State)
+
+    /**
+     * Starts chain with [state] as first [State]. May returns false in case of [State.context] of [state] is already
+     * busy by the other [State]
+     */
+    suspend fun startChain(state: State)
+
+    /**
+     * Ends chain with context from [state]. In case when [State.context] of [state] is absent, [state] should be just
+     * ignored
+     */
+    suspend fun endChain(state: State)
+
+    suspend fun getActiveStates(): List<State>
+}
+
+/**
+ * @param onContextsConflictResolver Receive old [State], new one and the state currently placed on new [State.context]
+ * key. In case when this callback will returns true, the state placed on [State.context] of new will be replaced by
+ * new state by using [endChain] with that state
+ */
+class InMemoryStatesManager(
+    private val onContextsConflictResolver: suspend (old: State, new: State, currentNew: State) -> Boolean = { _, _, _ -> true }
+) : StatesManager {
+    private val _onChainStateUpdated = MutableSharedFlow<Pair<State, State>>(0)
+    override val onChainStateUpdated: Flow<Pair<State, State>> = _onChainStateUpdated.asSharedFlow()
+    private val _onStartChain = MutableSharedFlow<State>(0)
+    override val onStartChain: Flow<State> = _onStartChain.asSharedFlow()
+    private val _onEndChain = MutableSharedFlow<State>(0)
+    override val onEndChain: Flow<State> = _onEndChain.asSharedFlow()
+
+    private val contextsToStates = mutableMapOf<Any, State>()
+    private val mapMutex = Mutex()
+
+    override suspend fun update(old: State, new: State) = mapMutex.withLock {
+        when {
+            contextsToStates[old.context] != old -> return@withLock
+            old.context == new.context || !contextsToStates.containsKey(new.context) -> {
+                contextsToStates[old.context] = new
+                _onChainStateUpdated.emit(old to new)
+            }
+            else -> {
+                val stateOnNewOneContext = contextsToStates.getValue(new.context)
+                if (onContextsConflictResolver(old, new, stateOnNewOneContext)) {
+                    endChainWithoutLock(stateOnNewOneContext)
+                    contextsToStates.remove(old.context)
+                    contextsToStates[new.context] = new
+                    _onChainStateUpdated.emit(old to new)
+                }
+            }
+        }
+    }
+
+    override suspend fun startChain(state: State) = mapMutex.withLock {
+        if (!contextsToStates.containsKey(state.context)) {
+            contextsToStates[state.context] = state
+            _onStartChain.emit(state)
+        }
+    }
+
+    private suspend fun endChainWithoutLock(state: State) {
+        if (contextsToStates[state.context] == state) {
+            contextsToStates.remove(state.context)
+            _onEndChain.emit(state)
+        }
+    }
+
+    override suspend fun endChain(state: State) {
+        mapMutex.withLock {
+            endChainWithoutLock(state)
+        }
+    }
+
+    override suspend fun getActiveStates(): List<State> = contextsToStates.values.toList()
+
+}

fsm/common/src/commonMain/kotlin/dev/inmo/micro_utils/fsm/common/dsl/FSMBuilder.kt

@@ -0,0 +1,35 @@
+package dev.inmo.micro_utils.fsm.common.dsl
+
+import dev.inmo.micro_utils.fsm.common.*
+import kotlin.reflect.KClass
+
+class FSMBuilder(
+    var statesManager: StatesManager = InMemoryStatesManager()
+) {
+    private var states = mutableListOf<StateHandlerHolder<*>>()
+
+    fun <I : State> add(kClass: KClass<I>, handler: StatesHandler<I>) {
+        states.add(StateHandlerHolder(kClass, false, handler))
+    }
+
+    fun <I : State> addStrict(kClass: KClass<I>, handler: StatesHandler<I>) {
+        states.add(StateHandlerHolder(kClass, true, handler))
+    }
+
+    fun build() = StatesMachine(
+        statesManager,
+        states.toList()
+    )
+}
+
+inline fun <reified I : State> FSMBuilder.onStateOrSubstate(handler: StatesHandler<I>) {
+    add(I::class, handler)
+}
+
+inline fun <reified I : State> FSMBuilder.strictlyOn(handler: StatesHandler<I>) {
+    addStrict(I::class, handler)
+}
+
+fun buildFSM(
+    block: FSMBuilder.() -> Unit
+): StatesMachine = FSMBuilder().apply(block).build()

fsm/common/src/jvmTest/kotlin/PlayableMain.kt

@@ -0,0 +1,53 @@
+import dev.inmo.micro_utils.fsm.common.*
+import dev.inmo.micro_utils.fsm.common.dsl.buildFSM
+import dev.inmo.micro_utils.fsm.common.dsl.strictlyOn
+import kotlinx.coroutines.*
+
+sealed interface TrafficLightState : State {
+    val trafficLightNumber: Int
+    override val context: Int
+        get() = trafficLightNumber
+}
+data class GreenCommon(override val trafficLightNumber: Int) : TrafficLightState
+data class YellowCommon(override val trafficLightNumber: Int) : TrafficLightState
+data class RedCommon(override val trafficLightNumber: Int) : TrafficLightState
+
+class PlayableMain {
+//    @Test
+    fun test() {
+        runBlocking {
+            val countOfTrafficLights = 10
+            val initialStates = (0 until countOfTrafficLights).map {
+                when (0/*Random.nextInt(3)*/) {
+                    0 -> GreenCommon(it)
+                    1 -> YellowCommon(it)
+                    else -> RedCommon(it)
+                }
+            }
+
+            val statesManager = InMemoryStatesManager()
+
+            val machine = buildFSM {
+                strictlyOn<GreenCommon> {
+                    delay(1000L)
+                    YellowCommon(it.context).also(::println)
+                }
+                strictlyOn<YellowCommon> {
+                    delay(1000L)
+                    RedCommon(it.context).also(::println)
+                }
+                strictlyOn<RedCommon> {
+                    delay(1000L)
+                    GreenCommon(it.context).also(::println)
+                }
+                this.statesManager = statesManager
+            }
+
+            initialStates.forEach { machine.startChain(it) }
+
+            val scope = CoroutineScope(Dispatchers.Default)
+            machine.start(scope).join()
+
+        }
+    }
+}

fsm/common/src/main/AndroidManifest.xml

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

fsm/repos/common/build.gradle

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

fsm/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/fsm/repos/common/KeyValueBasedStatesManager.kt

@@ -0,0 +1,83 @@
+package dev.inmo.micro_utils.fsm.repos.common
+
+import dev.inmo.micro_utils.fsm.common.State
+import dev.inmo.micro_utils.fsm.common.StatesManager
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.mappers.withMapper
+import dev.inmo.micro_utils.repos.pagination.getAll
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+class KeyValueBasedStatesManager(
+    private val keyValueRepo: KeyValueRepo<Any, State>,
+    private val onContextsConflictResolver: suspend (old: State, new: State, currentNew: State) -> Boolean = { _, _, _ -> true }
+) : StatesManager {
+    private val _onChainStateUpdated = MutableSharedFlow<Pair<State, State>>(0)
+    override val onChainStateUpdated: Flow<Pair<State, State>> = _onChainStateUpdated.asSharedFlow()
+    private val _onEndChain = MutableSharedFlow<State>(0)
+    override val onEndChain: Flow<State> = _onEndChain.asSharedFlow()
+
+    override val onStartChain: Flow<State> = keyValueRepo.onNewValue.map { it.second }
+
+    private val mutex = Mutex()
+
+    override suspend fun update(old: State, new: State) {
+        mutex.withLock {
+            when {
+                keyValueRepo.get(old.context) != old -> return@withLock
+                old.context == new.context || !keyValueRepo.contains(new.context) -> {
+                    keyValueRepo.set(old.context, new)
+                    _onChainStateUpdated.emit(old to new)
+                }
+                else -> {
+                    val stateOnNewOneContext = keyValueRepo.get(new.context)!!
+                    if (onContextsConflictResolver(old, new, stateOnNewOneContext)) {
+                        endChainWithoutLock(stateOnNewOneContext)
+                        keyValueRepo.unset(old.context)
+                        keyValueRepo.set(new.context, new)
+                        _onChainStateUpdated.emit(old to new)
+                    }
+                }
+            }
+
+        }
+    }
+
+    override suspend fun startChain(state: State) {
+        if (!keyValueRepo.contains(state.context)) {
+            keyValueRepo.set(state.context, state)
+        }
+    }
+
+    private suspend fun endChainWithoutLock(state: State) {
+        if (keyValueRepo.get(state.context) == state) {
+            keyValueRepo.unset(state.context)
+            _onEndChain.emit(state)
+        }
+    }
+
+    override suspend fun endChain(state: State) {
+        mutex.withLock { endChainWithoutLock(state) }
+    }
+
+    override suspend fun getActiveStates(): List<State> {
+        return keyValueRepo.getAll { keys(it) }.map { it.second }
+    }
+
+}
+
+inline fun <reified TargetContextType, reified TargetStateType> createStatesManager(
+    targetKeyValueRepo: KeyValueRepo<TargetContextType, TargetStateType>,
+    noinline contextToOutTransformer: suspend Any.() -> TargetContextType,
+    noinline stateToOutTransformer: suspend State.() -> TargetStateType,
+    noinline outToContextTransformer: suspend TargetContextType.() -> Any,
+    noinline outToStateTransformer: suspend TargetStateType.() -> State,
+) = KeyValueBasedStatesManager(
+    targetKeyValueRepo.withMapper<Any, State, TargetContextType, TargetStateType>(
+        contextToOutTransformer,
+        stateToOutTransformer,
+        outToContextTransformer,
+        outToStateTransformer
+    )
+)

fsm/repos/common/src/main/AndroidManifest.xml

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

gradle.properties

@@ -5,30 +5,31 @@ kotlin.incremental=true
 kotlin.incremental.js=true
 android.useAndroidX=true
 android.enableJetifier=true
+org.gradle.jvmargs=-Xmx2g
 
-kotlin_version=1.4.21
-kotlin_coroutines_version=1.4.2
-kotlin_serialisation_core_version=1.0.1
-kotlin_exposed_version=0.29.1
+kotlin_version=1.5.20
+kotlin_coroutines_version=1.5.1
+kotlin_serialisation_core_version=1.2.2
+kotlin_exposed_version=0.32.1
 
-ktor_version=1.5.0
+ktor_version=1.6.1
 
-klockVersion=2.0.4
+klockVersion=2.2.0
 
 github_release_plugin_version=2.2.12
 
-uuidVersion=0.2.3
+uuidVersion=0.3.0
 
 # ANDROID
 
-core_ktx_version=1.3.2
-androidx_recycler_version=1.1.0
-appcompat_version=1.2.0
+core_ktx_version=1.6.0
+androidx_recycler_version=1.2.1
+appcompat_version=1.3.0
 
 android_minSdkVersion=19
 android_compileSdkVersion=30
-android_buildToolsVersion=30.0.2
-dexcount_version=2.0.0
+android_buildToolsVersion=30.0.3
+dexcount_version=2.1.0-RC01
 junit_version=4.12
 test_ext_junit_version=1.1.2
 espresso_core=3.3.0
@@ -39,10 +40,10 @@ crypto_js_version=4.0.0
 
 # Dokka
 
-dokka_version=1.4.20
+dokka_version=1.4.32
 
 # Project data
 
 group=dev.inmo
-version=0.4.22
-android_code_version=26
+version=0.5.16
+android_code_version=57

gradle/wrapper/gradle-wrapper.properties

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

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

@@ -15,30 +15,21 @@ class UnifiedRequester(
     suspend fun <ResultType> uniget(
         url: String,
         resultDeserializer: DeserializationStrategy<ResultType>
-    ): ResultType = client.get<StandardKtorSerialInputData>(
-        url
-    ).let {
-        serialFormat.decodeDefault(resultDeserializer, it)
-    }
-
+    ): ResultType = client.uniget(url, resultDeserializer, serialFormat)
 
     fun <T> encodeUrlQueryValue(
         serializationStrategy: SerializationStrategy<T>,
         value: T
-    ) = serialFormat.encodeHex(
-        serializationStrategy,
-        value
+    ) = serializationStrategy.encodeUrlQueryValue(
+        value,
+        serialFormat
     )
 
     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)
-    }
+    ) = client.unipost(url, bodyInfo, resultDeserializer, serialFormat)
 
     fun <T> createStandardWebsocketFlow(
         url: String,
@@ -51,14 +42,30 @@ val defaultRequester = UnifiedRequester()
 
 suspend fun <ResultType> HttpClient.uniget(
     url: String,
-    resultDeserializer: DeserializationStrategy<ResultType>
-) = defaultRequester.uniget(url, resultDeserializer)
+    resultDeserializer: DeserializationStrategy<ResultType>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+) = get<StandardKtorSerialInputData>(
+    url
+).let {
+    serialFormat.decodeDefault(resultDeserializer, it)
+}
 
 
-fun <T> SerializationStrategy<T>.encodeUrlQueryValue(value: T) = defaultRequester.encodeUrlQueryValue(this, value)
+fun <T> SerializationStrategy<T>.encodeUrlQueryValue(
+    value: T,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+) = serialFormat.encodeHex(
+    this,
+    value
+)
 
 suspend fun <BodyType, ResultType> HttpClient.unipost(
     url: String,
     bodyInfo: BodyPair<BodyType>,
-    resultDeserializer: DeserializationStrategy<ResultType>
-) = defaultRequester.unipost(url, bodyInfo, resultDeserializer)
+    resultDeserializer: DeserializationStrategy<ResultType>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+) = post<StandardKtorSerialInputData>(url) {
+    body = serialFormat.encodeDefault(bodyInfo.first, bodyInfo.second)
+}.let {
+    serialFormat.decodeDefault(resultDeserializer, it)
+}

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

@@ -10,7 +10,7 @@ import kotlinx.coroutines.flow.collect
 import kotlinx.serialization.SerializationStrategy
 
 private suspend fun DefaultWebSocketSession.checkReceivedAndCloseIfExists() {
-    if (incoming.poll() != null) {
+    if (incoming.tryReceive() != null) {
         close()
         throw CorrectCloseException
     }

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

@@ -8,7 +8,7 @@ import kotlinx.serialization.Contextual
 data class ApplicationCachingHeadersConfigurator(
     private val elements: List<@Contextual Element>
 ) : KtorApplicationConfigurator {
-    interface Element { operator fun CachingHeaders.Configuration.invoke() }
+    fun interface Element { operator fun CachingHeaders.Configuration.invoke() }
 
     override fun Application.configure() {
         install(CachingHeaders) {

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

@@ -10,17 +10,18 @@ import kotlinx.serialization.Serializable
 class ApplicationRoutingConfigurator(
     private val elements: List<@Contextual Element>
 ) : KtorApplicationConfigurator {
-    interface Element { operator fun Route.invoke() }
+    fun interface Element { operator fun Route.invoke() }
+    private val rootInstaller = Element {
+        elements.forEach {
+            it.apply { invoke() }
+        }
+    }
 
     override fun Application.configure() {
-        try {
-            feature(Routing)
-        } catch (e: IllegalStateException) {
-            install(Routing) {
-                elements.forEach {
-                    it.apply { invoke() }
-                }
-            }
+        featureOrNull(Routing) ?.apply {
+            rootInstaller.apply { invoke() }
+        } ?: install(Routing) {
+            rootInstaller.apply { invoke() }
         }
     }
 }

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

@@ -8,7 +8,7 @@ import kotlinx.serialization.Contextual
 class ApplicationSessionsConfigurator(
     private val elements: List<@Contextual Element>
 ) : KtorApplicationConfigurator {
-    interface Element { operator fun Sessions.Configuration.invoke() }
+    fun interface Element { operator fun Sessions.Configuration.invoke() }
 
     override fun Application.configure() {
         install(Sessions) {

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

@@ -8,7 +8,7 @@ import kotlinx.serialization.Contextual
 class StatusPagesConfigurator(
     private val elements: List<@Contextual Element>
 ) : KtorApplicationConfigurator {
-    interface Element { operator fun StatusPages.Configuration.invoke() }
+    fun interface Element { operator fun StatusPages.Configuration.invoke() }
 
     override fun Application.configure() {
         install(StatusPages) {

matrix/build.gradle

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

matrix/src/commonMain/kotlin/dev/inmo/micro_utils/matrix/Matrix.kt

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.matrix
+
+typealias Matrix<T> = List<Row<T>>

matrix/src/commonMain/kotlin/dev/inmo/micro_utils/matrix/MatrixBuilder.kt

@@ -0,0 +1,13 @@
+package dev.inmo.micro_utils.matrix
+
+class MatrixBuilder<T> {
+    private val mutMatrix: MutableList<List<T>> = ArrayList()
+    val matrix: Matrix<T>
+        get() = mutMatrix
+
+    fun row(t: List<T>) = mutMatrix.add(t)
+    operator fun List<T>.unaryPlus() = row(this)
+}
+
+fun <T> MatrixBuilder<T>.row(block: RowBuilder<T>.() -> Unit) = +RowBuilder<T>().also(block).row
+fun <T> MatrixBuilder<T>.row(vararg elements: T) = +elements.toList()

matrix/src/commonMain/kotlin/dev/inmo/micro_utils/matrix/MatrixFactories.kt

@@ -0,0 +1,17 @@
+package dev.inmo.micro_utils.matrix
+
+fun <T> matrix(block: MatrixBuilder<T>.() -> Unit): Matrix<T> {
+    return MatrixBuilder<T>().also(block).matrix
+}
+
+fun <T> flatMatrix(block: RowBuilder<T>.() -> Unit): Matrix<T> {
+    return MatrixBuilder<T>().apply {
+        row(block)
+    }.matrix
+}
+
+fun <T> flatMatrix(vararg elements: T): Matrix<T> {
+    return MatrixBuilder<T>().apply {
+        row { elements.forEach { +it } }
+    }.matrix
+}

matrix/src/commonMain/kotlin/dev/inmo/micro_utils/matrix/Row.kt

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.matrix
+
+typealias Row<T> = List<T>

matrix/src/commonMain/kotlin/dev/inmo/micro_utils/matrix/RowBuilder.kt

@@ -0,0 +1,14 @@
+package dev.inmo.micro_utils.matrix
+
+class RowBuilder<T> {
+    private val mutRow: MutableList<T> = ArrayList()
+    val row: Row<T>
+        get() = mutRow
+
+    fun column(t: T) = mutRow.add(t)
+    operator fun T.unaryPlus() = column(this)
+}
+
+fun <T> row(block: RowBuilder<T>.() -> Unit): List<T> = RowBuilder<T>().also(block).row
+fun <T> RowBuilder<T>.columns(elements: List<T>) = elements.forEach(::column)
+fun <T> RowBuilder<T>.columns(vararg elements: T) = elements.forEach(::column)

matrix/src/commonTest/kotlin/dev/inmo/micro_utils/matrix/SimpleTest.kt

@@ -0,0 +1,45 @@
+package dev.inmo.micro_utils.matrix
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class SimpleTest {
+    @Test
+    fun simpleTest() {
+        val expected = listOf(
+            listOf(1, 2, 3),
+            listOf(4, 5, 6)
+        )
+
+        val fromMatrixWithVarargs = matrix<Int> {
+            row(1, 2, 3)
+            row(4, 5, 6)
+        }
+
+        val fromMatrixWithColumnsVarargs = matrix<Int> {
+            row {
+                columns(1, 2, 3)
+            }
+            row {
+                columns(4, 5, 6)
+            }
+        }
+
+        val fromMatrixWithSimpleAdd = matrix<Int> {
+            row {
+                column(1)
+                column(2)
+                column(3)
+            }
+            row {
+                column(4)
+                column(5)
+                column(6)
+            }
+        }
+
+        assertEquals(expected, fromMatrixWithVarargs)
+        assertEquals(expected, fromMatrixWithColumnsVarargs)
+        assertEquals(expected, fromMatrixWithSimpleAdd)
+    }
+}

matrix/src/main/AndroidManifest.xml

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

mppJavaProject.gradle

@@ -4,7 +4,9 @@ project.group = "$group"
 apply from: "$publishGradlePath"
 
 kotlin {
-    jvm()
+    jvm {
+        compilations.main.kotlinOptions.useIR = true
+    }
 
     sourceSets {
         commonMain {

mppProjectWithSerialization.gradle

@@ -4,7 +4,9 @@ project.group = "$group"
 apply from: "$publishGradlePath"
 
 kotlin {
-    jvm()
+    jvm {
+        compilations.main.kotlinOptions.useIR = true
+    }
     js (BOTH) {
         browser()
         nodejs()

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

@@ -12,6 +12,22 @@ data class PaginationResult<T>(
 
 fun <T> emptyPaginationResult() = PaginationResult<T>(0, 0, emptyList(), 0)
 
+/**
+ * @return New [PaginationResult] with [data] without checking of data sizes equality
+ */
+fun <I, O> PaginationResult<I>.changeResultsUnchecked(
+    data: List<O>
+): PaginationResult<O> = PaginationResult(page, pagesNumber, data, size)
+/**
+ * @return New [PaginationResult] with [data] <b>with</b> checking of data sizes equality
+ */
+fun <I, O> PaginationResult<I>.changeResults(
+    data: List<O>
+): PaginationResult<O> {
+    require(data.size == results.size)
+    return changeResultsUnchecked(data)
+}
+
 fun <T> List<T>.createPaginationResult(
     pagination: Pagination,
     commonObjectsNumber: Long

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

@@ -7,14 +7,17 @@ const val defaultMediumPageSize = 5
 const val defaultLargePageSize = 10
 const val defaultExtraLargePageSize = 15
 
+var defaultPaginationPageSize = defaultMediumPageSize
+
 @Suppress("NOTHING_TO_INLINE", "FunctionName")
-inline fun FirstPagePagination(size: Int = defaultMediumPageSize) =
+inline fun FirstPagePagination(size: Int = defaultPaginationPageSize) =
     SimplePagination(
         page = 0,
         size = size
     )
 
 val emptyPagination = Pagination(0, 0)
+val firstPageWithOneElementPagination = FirstPagePagination(1)
 
 @Suppress("NOTHING_TO_INLINE")
 inline fun Pagination.nextPage() =

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

@@ -21,8 +21,10 @@ inline fun PaginationResult<*>.nextPageIfNotEmpty() = if (results.isNotEmpty())
 }
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun PaginationResult<*>.thisPageIfNotEmpty(): Pagination? = if (results.isNotEmpty()) {
+inline fun <T> PaginationResult<T>.thisPageIfNotEmpty(): PaginationResult<T>? = if (results.isNotEmpty()) {
     this
 } else {
     null
 }
+
+inline fun <T> PaginationResult<T>.currentPageIfNotEmpty() = thisPageIfNotEmpty()

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

@@ -0,0 +1,40 @@
+package dev.inmo.micro_utils.pagination.utils
+
+import dev.inmo.micro_utils.pagination.*
+
+suspend fun <T> doForAll(
+    initialPagination: Pagination = FirstPagePagination(),
+    paginationMapper: (PaginationResult<T>) -> Pagination?,
+    block: suspend (Pagination) -> PaginationResult<T>
+) {
+    doWithPagination(initialPagination) {
+        block(it).let(paginationMapper)
+    }
+}
+
+suspend fun <T> doForAllWithNextPaging(
+    initialPagination: Pagination = FirstPagePagination(),
+    block: suspend (Pagination) -> PaginationResult<T>
+) {
+    doForAll(
+        initialPagination,
+        { it.nextPageIfNotEmpty() },
+        block
+    )
+}
+
+suspend fun <T> doAllWithCurrentPaging(
+    initialPagination: Pagination = FirstPagePagination(),
+    block: suspend (Pagination) -> PaginationResult<T>
+) {
+    doForAll(
+        initialPagination,
+        { it.currentPageIfNotEmpty() },
+        block
+    )
+}
+
+suspend fun <T> doForAllWithCurrentPaging(
+    initialPagination: Pagination = FirstPagePagination(),
+    block: suspend (Pagination) -> PaginationResult<T>
+) = doAllWithCurrentPaging(initialPagination, block)

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

@@ -0,0 +1,35 @@
+package dev.inmo.micro_utils.pagination.utils
+
+import dev.inmo.micro_utils.pagination.*
+
+suspend fun <T> getAll(
+    initialPagination: Pagination = FirstPagePagination(),
+    paginationMapper: (PaginationResult<T>) -> Pagination?,
+    block: suspend (Pagination) -> PaginationResult<T>
+): List<T> {
+    val results = mutableListOf<T>()
+    doForAll(initialPagination, paginationMapper) {
+        block(it).also {
+            results.addAll(it.results)
+        }
+    }
+    return results.toList()
+}
+
+suspend fun <T> getAllWithNextPaging(
+    initialPagination: Pagination = FirstPagePagination(),
+    block: suspend (Pagination) -> PaginationResult<T>
+): List<T> = getAll(
+    initialPagination,
+    { it.nextPageIfNotEmpty() },
+    block
+)
+
+suspend fun <T> getAllWithCurrentPaging(
+    initialPagination: Pagination = FirstPagePagination(),
+    block: suspend (Pagination) -> PaginationResult<T>
+): List<T> = getAll(
+    initialPagination,
+    { it.currentPageIfNotEmpty() },
+    block
+)

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

@@ -36,6 +36,6 @@ class PaginatedIterable<T>(
 @Suppress("NOTHING_TO_INLINE")
 inline fun <T> makeIterable(
     noinline countGetter: () -> Long,
-    pageSize: Int = defaultMediumPageSize,
+    pageSize: Int = defaultPaginationPageSize,
     noinline paginationResultGetter: Pagination.() -> PaginationResult<T>
 ): Iterable<T> = PaginatedIterable(pageSize, countGetter, paginationResultGetter)

pagination/ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/PaginationInUrl.kt

@@ -18,6 +18,6 @@ val Pagination.asUrlQueryArrayParts
 val Map<String, String?>.extractPagination: Pagination
     get() = SimplePagination(
         get(paginationPageKey) ?.toIntOrNull() ?: 0,
-        get(paginationSizeKey) ?.toIntOrNull() ?: defaultMediumPageSize
+        get(paginationSizeKey) ?.toIntOrNull() ?: defaultPaginationPageSize
     )
 

pagination/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/pagination/ServerPaginationHelpers.kt

@@ -5,8 +5,8 @@ import io.ktor.http.Parameters
 
 val Parameters.extractPagination: Pagination
     get() = SimplePagination(
-        get("page") ?.toIntOrNull() ?: 0,
-        get("size") ?.toIntOrNull() ?: defaultMediumPageSize
+        get(paginationPageKey) ?.toIntOrNull() ?: 0,
+        get(paginationSizeKey) ?.toIntOrNull() ?: defaultPaginationPageSize
     )
 
 val ApplicationCall.extractPagination: Pagination

pubconf.kpsb

@@ -1 +0,0 @@
-{"bintrayConfig":{"repo":"MicroUtils","packageName":"${project.name}","packageVcs":"https://github.com/InsanusMokrassar/MicroUtils","autoPublish":true,"overridePublish":true},"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://git.inmo.dev/InsanusMokrassar/MicroUtils_mirror/src/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"","url":"https://git.inmo.dev/InsanusMokrassar/MicroUtils_mirror","vcsUrl":"ssh://git@git.inmo.dev:8322/InsanusMokrassar/MicroUtils_mirror.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"},{"id":"000Sanya","name":"Syrov Aleksandr","eMail":"000sanya.000sanya@gmail.com"}]}}

publish.gradle

@@ -1,37 +1,22 @@
 apply plugin: 'maven-publish'
+apply plugin: 'signing'
 
 task javadocsJar(type: Jar) {
     classifier = 'javadoc'
 }
-task sourceJar (type : Jar) {
-    classifier = 'sources'
-}
-
-afterEvaluate {
-    project.publishing.publications.all {
-        // rename artifacts
-        groupId "${project.group}"
-        if (it.name.contains('kotlinMultiplatform')) {
-            artifactId = "${project.name}"
-            artifact sourceJar
-        } else {
-            artifactId = "${project.name}-$name"
-        }
-    }
-}
 
 publishing {
     publications.all {
         artifact javadocsJar
 
         pom {
-            description = ""
+            description = "It is set of projects with micro tools for avoiding of routines coding"
             name = "${project.name}"
-            url = "https://git.inmo.dev/InsanusMokrassar/MicroUtils_mirror"
+            url = "https://github.com/InsanusMokrassar/MicroUtils/"
 
             scm {
-                developerConnection = "scm:git:[fetch=]ssh://git@git.inmo.dev:8322/InsanusMokrassar/MicroUtils_mirror.git[push=]ssh://git@git.inmo.dev:8322/InsanusMokrassar/MicroUtils_mirror.git"
-                url = "ssh://git@git.inmo.dev:8322/InsanusMokrassar/MicroUtils_mirror.git"
+                developerConnection = "scm:git:[fetch=]https://github.com/InsanusMokrassar/MicroUtils.git[push=]https://github.com/InsanusMokrassar/MicroUtils.git"
+                url = "https://github.com/InsanusMokrassar/MicroUtils.git"
             }
 
             developers {
@@ -55,22 +40,37 @@ publishing {
                 
                     license {
                         name = "Apache Software License 2.0"
-                        url = "https://git.inmo.dev/InsanusMokrassar/MicroUtils_mirror/src/master/LICENSE"
+                        url = "https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"
                     }
                 
             }
         }
-        
         repositories {
-            maven {
-                name = "bintray"
-                url = uri("https://api.bintray.com/maven/${project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')}/MicroUtils/${project.name}/;publish=1;override=1")
-                credentials {
-                    username = project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')
-                    password = project.hasProperty('BINTRAY_KEY') ? project.property('BINTRAY_KEY') : System.getenv('BINTRAY_KEY')
+            if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
+                maven {
+                    name = "GithubPackages"
+                    url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
+                    credentials {
+                        username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
+                        password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
+                    }
+                }
+            }
+            if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+                maven {
+                    name = "sonatype"
+                    url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+                    credentials {
+                        username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+                        password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+                    }
                 }
             }
         }
-        
     }
-}
+}
+
+signing {
+    useGpgCmd()
+    sign publishing.publications
+}

publish.kpsb

@@ -0,0 +1 @@
+{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"It is set of projects with micro tools for avoiding of routines coding","url":"https://github.com/InsanusMokrassar/MicroUtils/","vcsUrl":"https://github.com/InsanusMokrassar/MicroUtils.git","includeGpgSigning":true,"developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"},{"id":"000Sanya","name":"Syrov Aleksandr","eMail":"000sanya.000sanya@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/MicroUtils"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}]}}

repos/cache/build.gradle

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

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

@@ -0,0 +1,34 @@
+package dev.inmo.micro_utils.repos.cache
+
+import dev.inmo.micro_utils.repos.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+
+open class ReadCRUDCacheRepo<ObjectType, IdType>(
+    protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
+    protected val kvCache: KVCache<IdType, ObjectType>,
+    protected val idGetter: (ObjectType) -> IdType
+) : ReadCRUDRepo<ObjectType, IdType> by parentRepo {
+    override suspend fun getById(id: IdType): ObjectType? = kvCache.get(id) ?: (parentRepo.getById(id) ?.also {
+        kvCache.set(id, it)
+    })
+
+    override suspend fun contains(id: IdType): Boolean = kvCache.contains(id) || parentRepo.contains(id)
+}
+
+open class CRUDCacheRepo<ObjectType, IdType, InputValueType>(
+    parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
+    kvCache: KVCache<IdType, ObjectType>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    idGetter: (ObjectType) -> IdType
+) : ReadCRUDCacheRepo<ObjectType, IdType>(
+    parentRepo,
+    kvCache,
+    idGetter
+), CRUDRepo<ObjectType, IdType, InputValueType>, WriteCRUDRepo<ObjectType, IdType, InputValueType> by parentRepo {
+    protected val onNewJob = parentRepo.newObjectsFlow.onEach { kvCache.set(idGetter(it), it) }.launchIn(scope)
+    protected val onUpdatedJob = parentRepo.updatedObjectsFlow.onEach { kvCache.set(idGetter(it), it) }.launchIn(scope)
+    protected val onRemoveJob = parentRepo.deletedObjectsIdsFlow.onEach { kvCache.unset(it) }.launchIn(scope)
+}

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

@@ -0,0 +1,41 @@
+package dev.inmo.micro_utils.repos.cache
+
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+interface KVCache<K, V> : KeyValueRepo<K, V>
+
+open class SimpleKVCache<K, V>(
+    protected val cachedValuesCount: Int,
+    private val kvParent: KeyValueRepo<K, V> = MapKeyValueRepo<K, V>()
+) : KVCache<K, V>, KeyValueRepo<K, V> by kvParent {
+    protected open val cacheStack = ArrayList<K>(cachedValuesCount)
+    protected val syncMutex = Mutex()
+
+    protected suspend fun makeUnset(toUnset: List<K>) {
+        cacheStack.removeAll(toUnset)
+        kvParent.unset(toUnset)
+    }
+
+    override suspend fun set(toSet: Map<K, V>) {
+        syncMutex.withLock {
+            if (toSet.size > cachedValuesCount) {
+                cacheStack.clear()
+
+                kvParent.unset(getAllWithNextPaging { kvParent.keys(it) })
+                val keysToInclude = toSet.keys.drop(toSet.size - cachedValuesCount)
+
+                cacheStack.addAll(keysToInclude)
+                kvParent.set(keysToInclude.associateWith { toSet.getValue(it) })
+            } else {
+                makeUnset(cacheStack.take(toSet.size))
+            }
+        }
+    }
+
+    override suspend fun unset(toUnset: List<K>) {
+        syncMutex.withLock { makeUnset(toUnset) }
+    }
+}

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

@@ -0,0 +1,25 @@
+package dev.inmo.micro_utils.repos.cache
+
+import dev.inmo.micro_utils.repos.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+open class ReadKeyValueCacheRepo<Key,Value>(
+    protected val parentRepo: ReadKeyValueRepo<Key, Value>,
+    protected val kvCache: KVCache<Key, Value>,
+) : ReadKeyValueRepo<Key,Value> by parentRepo {
+    override suspend fun get(k: Key): Value? = kvCache.get(k) ?: parentRepo.get(k) ?.also { kvCache.set(k, it) }
+    override suspend fun contains(key: Key): Boolean = kvCache.contains(key) || parentRepo.contains(key)
+}
+
+open class KeyValueCacheRepo<Key,Value>(
+    parentRepo: KeyValueRepo<Key, Value>,
+    kvCache: KVCache<Key, Value>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) : ReadKeyValueCacheRepo<Key,Value>(parentRepo, kvCache), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo {
+    protected val onNewJob = parentRepo.onNewValue.onEach { kvCache.set(it.first, it.second) }.launchIn(scope)
+    protected val onRemoveJob = parentRepo.onValueRemoved.onEach { kvCache.unset(it) }.launchIn(scope)
+}

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

@@ -0,0 +1,42 @@
+package dev.inmo.micro_utils.repos.cache
+
+import dev.inmo.micro_utils.pagination.Pagination
+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.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+open class ReadKeyValuesCacheRepo<Key,Value>(
+    protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
+    protected val kvCache: KVCache<Key, List<Value>>
+) : ReadKeyValuesRepo<Key,Value> by parentRepo {
+    override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
+        return kvCache.get(k) ?.paginate(
+            pagination.let { if (reversed) it.reverse(count(k)) else it }
+        ) ?.let {
+            if (reversed) it.copy(results = it.results.reversed()) else it
+        } ?: parentRepo.get(k, pagination, reversed)
+    }
+    override suspend fun getAll(k: Key, reversed: Boolean): List<Value> {
+        return kvCache.get(k) ?.let {
+            if (reversed) it.reversed() else it
+        } ?: parentRepo.getAll(k, reversed)
+    }
+    override suspend fun contains(k: Key, v: Value): Boolean = kvCache.get(k) ?.contains(v) ?: parentRepo.contains(k, v)
+    override suspend fun contains(k: Key): Boolean = kvCache.contains(k) || parentRepo.contains(k)
+}
+
+open class KeyValuesCacheRepo<Key,Value>(
+    parentRepo: KeyValuesRepo<Key, Value>,
+    kvCache: KVCache<Key, List<Value>>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) : ReadKeyValuesCacheRepo<Key,Value>(parentRepo, kvCache), KeyValuesRepo<Key,Value>, WriteKeyValuesRepo<Key,Value> by parentRepo {
+    protected val onNewJob = parentRepo.onNewValue.onEach { kvCache.set(it.first, kvCache.get(it.first) ?.plus(it.second) ?: listOf(it.second)) }.launchIn(scope)
+    protected val onRemoveJob = parentRepo.onValueRemoved.onEach { kvCache.set(it.first, kvCache.get(it.first) ?.minus(it.second) ?: return@onEach) }.launchIn(scope)
+    protected val onDataClearedJob = parentRepo.onDataCleared.onEach { kvCache.unset(it) }.launchIn(scope)
+}

repos/cache/src/main/AndroidManifest.xml

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

repos/common/build.gradle

@@ -30,4 +30,6 @@ kotlin {
             }
         }
     }
-}
+}
+
+disableIncludingJvmCodeInAndroidPart()

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

@@ -1,6 +1,8 @@
 package dev.inmo.micro_utils.repos
 
 import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.utils.doForAllWithCurrentPaging
+import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import kotlinx.coroutines.flow.Flow
 
 interface ReadOneToManyKeyValueRepo<Key, Value> : Repo {
@@ -12,14 +14,12 @@ interface ReadOneToManyKeyValueRepo<Key, Value> : Repo {
     suspend fun count(k: Key): Long
     suspend fun count(): Long
 
-    suspend fun getAll(k: Key, reversed: Boolean = false): List<Value> = mutableListOf<Value>().also { list ->
-        doWithPagination {
-            get(k, it).also {
-                list.addAll(it.results)
-            }.nextPageIfNotEmpty()
-        }
-        if (reversed) {
-            list.reverse()
+    suspend fun getAll(k: Key, reversed: Boolean = false): List<Value> {
+        val results = getAllWithNextPaging { get(k, it) }
+        return if (reversed) {
+            results.reversed()
+        } else {
+            results
         }
     }
 
@@ -48,6 +48,7 @@ interface WriteOneToManyKeyValueRepo<Key, Value> : Repo {
     suspend fun remove(toRemove: Map<Key, List<Value>>)
 
     suspend fun clear(k: Key)
+    suspend fun clearWithValue(v: Value)
 
     suspend fun set(toSet: Map<Key, List<Value>>) {
         toSet.keys.forEach { key -> clear(key) }
@@ -88,7 +89,19 @@ suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.set(
     k: Key, vararg v: Value
 ) = set(k, v.toList())
 
-interface OneToManyKeyValueRepo<Key, Value> : ReadOneToManyKeyValueRepo<Key, Value>, WriteOneToManyKeyValueRepo<Key, Value>
+interface OneToManyKeyValueRepo<Key, Value> : ReadOneToManyKeyValueRepo<Key, Value>, WriteOneToManyKeyValueRepo<Key, Value> {
+    override suspend fun clearWithValue(v: Value) {
+        doWithPagination {
+            val keysResult = keys(v, it)
+
+            if (keysResult.results.isNotEmpty()) {
+                remove(keysResult.results.map { it to listOf(v) })
+            }
+
+            keysResult.currentPageIfNotEmpty()
+        }
+    }
+}
 typealias KeyValuesRepo<Key,Value> = OneToManyKeyValueRepo<Key, Value>
 
 suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(

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

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.repos
 
 import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.utils.doAllWithCurrentPaging
 import kotlinx.coroutines.flow.Flow
 
 interface ReadStandardKeyValueRepo<Key, Value> : Repo {
@@ -41,7 +42,7 @@ suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.unsetWithV
 
 interface StandardKeyValueRepo<Key, Value> : ReadStandardKeyValueRepo<Key, Value>, WriteStandardKeyValueRepo<Key, Value> {
     override suspend fun unsetWithValues(toUnset: List<Value>) = toUnset.forEach { v ->
-        doWithPagination {
+        doAllWithCurrentPaging {
             keys(v, it).also {
                 unset(it.results)
             }

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

@@ -114,6 +114,7 @@ open class MapperWriteOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
     }
 
     override suspend fun clear(k: FromKey) = to.clear(k.toOutKey())
+    override suspend fun clearWithValue(v: FromValue) = to.clearWithValue(v.toOutValue())
 }
 
 @Suppress("NOTHING_TO_INLINE")

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

@@ -1,31 +1,13 @@
 package dev.inmo.micro_utils.repos.pagination
 
 import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
+import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
 
-suspend inline fun <T, ID, REPO : ReadStandardCRUDRepo<T, ID>> REPO.doForAll(
-    @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
-    methodCaller: suspend REPO.(Pagination) -> PaginationResult<T>,
-    block: (List<T>) -> Unit
-) {
-    doWithPagination {
-        methodCaller(it).also {
-            block(it.results)
-        }.nextPageIfNotEmpty()
-    }
-}
-
-suspend inline fun <T, ID, REPO : ReadStandardCRUDRepo<T, ID>> REPO.doForAll(
-    block: (List<T>) -> Unit
-) = doForAll({ getByPagination(it) }, block)
-
 suspend inline fun <T, ID, REPO : ReadStandardCRUDRepo<T, ID>> REPO.getAll(
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
-    methodCaller: suspend REPO.(Pagination) -> PaginationResult<T>
-): List<T> {
-    val resultList = mutableListOf<T>()
-    doForAll(methodCaller) {
-        resultList.addAll(it)
-    }
-    return resultList
+    crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<T>
+): List<T> = getAllWithNextPaging {
+    methodCaller(this, it)
 }

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

@@ -1,31 +1,15 @@
 package dev.inmo.micro_utils.repos.pagination
 
 import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
 
-suspend inline fun <Key, Value, REPO : ReadStandardKeyValueRepo<Key, Value>> REPO.doForAll(
-    @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
-    methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>,
-    block: (List<Pair<Key, Value>>) -> Unit
-) {
-    doWithPagination {
-        methodCaller(it).also { keys ->
-            block(keys.results.mapNotNull { key -> get(key) ?.let { value -> key to value } })
-        }.nextPageIfNotEmpty()
-    }
-}
-
-suspend inline fun <Key, Value, REPO : ReadStandardKeyValueRepo<Key, Value>> REPO.doForAll(
-    block: (List<Pair<Key, Value>>) -> Unit
-) = doForAll({ keys(it, false) }, block)
-
 suspend inline fun <Key, Value, REPO : ReadStandardKeyValueRepo<Key, Value>> REPO.getAll(
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
-    methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>
-): List<Pair<Key, Value>> {
-    val resultList = mutableListOf<Pair<Key, Value>>()
-    doForAll(methodCaller) {
-        resultList.addAll(it)
-    }
-    return resultList
+    crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>
+): List<Pair<Key, Value>> = getAllWithNextPaging {
+    val result = methodCaller(it)
+    result.changeResultsUnchecked(
+        result.results.mapNotNull { it to (get(it) ?: return@mapNotNull null) }
+    )
 }

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

@@ -1,41 +1,17 @@
 package dev.inmo.micro_utils.repos.pagination
 
 import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
 
-suspend inline fun <Key, Value, REPO : ReadOneToManyKeyValueRepo<Key, Value>> REPO.doForAll(
-    @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
-    methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>,
-    block: (List<Pair<Key, List<Value>>>) -> Unit
-) {
-    doWithPagination {
-        methodCaller(it).also { keys ->
-            block(
-                keys.results.mapNotNull { key ->
-                    val values = mutableListOf<Value>()
-                    doWithPagination {
-                        get(key, it).also {
-                            values.addAll(it.results)
-                        }.nextPageIfNotEmpty()
-                    }
-                    key to values
-                }
-            )
-        }.nextPageIfNotEmpty()
-    }
-}
-
-suspend inline fun <Key, Value, REPO : ReadOneToManyKeyValueRepo<Key, Value>> REPO.doForAll(
-    block: (List<Pair<Key, List<Value>>>) -> Unit
-) = doForAll({ keys(it, false) }, block)
-
 suspend inline fun <Key, Value, REPO : ReadOneToManyKeyValueRepo<Key, Value>> REPO.getAll(
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
-    methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>
-): List<Pair<Key, List<Value>>> {
-    val resultList = mutableListOf<Pair<Key, List<Value>>>()
-    doForAll(methodCaller) {
-        resultList.addAll(it)
-    }
-    return resultList
+    crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>
+): List<Pair<Key, List<Value>>> = getAllWithNextPaging {
+    val keysResult = methodCaller(it)
+    keysResult.changeResultsUnchecked(
+        keysResult.results.map { k ->
+            k to getAll(k)
+        }
+    )
 }

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

@@ -18,19 +18,16 @@ class StandardVersionsRepo<T>(
         onCreate: suspend T.() -> Unit,
         onUpdate: suspend T.(from: Int, to: Int) -> Unit
     ) {
-        var savedVersion = proxy.getTableVersion(tableName)
-        if (savedVersion == null) {
+        var currentVersion = proxy.getTableVersion(tableName)
+        if (currentVersion == null) {
             proxy.database.onCreate()
-            proxy.updateTableVersion(tableName, version)
-        } else {
-            while (savedVersion != null && savedVersion < version) {
-                val newVersion = savedVersion + 1
+        }
+        while (currentVersion == null || currentVersion < version) {
+            val oldVersion = currentVersion ?: 0
+            currentVersion = oldVersion + 1
+            proxy.database.onUpdate(oldVersion, currentVersion)
 
-                proxy.database.onUpdate(savedVersion, newVersion)
-
-                proxy.updateTableVersion(tableName, newVersion)
-                savedVersion = newVersion
-            }
+            proxy.updateTableVersion(tableName, currentVersion)
         }
     }
 }

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

@@ -26,20 +26,39 @@ fun SQLiteDatabase.createTable(
     }
 }
 
-fun Cursor.getString(columnName: String) = getString(
-    getColumnIndex(columnName)
+/**
+ * @throws IllegalArgumentException
+ */
+fun Cursor.getString(columnName: String): String = getString(
+    getColumnIndexOrThrow(columnName)
 )
 
-fun Cursor.getLong(columnName: String) = getLong(
-    getColumnIndex(columnName)
+/**
+ * @throws IllegalArgumentException
+ */
+fun Cursor.getShort(columnName: String): Short = getShort(
+    getColumnIndexOrThrow(columnName)
 )
 
-fun Cursor.getInt(columnName: String) = getInt(
-    getColumnIndex(columnName)
+/**
+ * @throws IllegalArgumentException
+ */
+fun Cursor.getLong(columnName: String): Long = getLong(
+    getColumnIndexOrThrow(columnName)
 )
 
-fun Cursor.getDouble(columnName: String) = getDouble(
-    getColumnIndex(columnName)
+/**
+ * @throws IllegalArgumentException
+ */
+fun Cursor.getInt(columnName: String): Int = getInt(
+    getColumnIndexOrThrow(columnName)
+)
+
+/**
+ * @throws IllegalArgumentException
+ */
+fun Cursor.getDouble(columnName: String): Double = getDouble(
+    getColumnIndexOrThrow(columnName)
 )
 
 fun SQLiteDatabase.select(
@@ -55,6 +74,19 @@ fun SQLiteDatabase.select(
     table, columns, selection, selectionArgs, groupBy, having, orderBy, limit
 )
 
+fun SQLiteDatabase.selectDistinct(
+    table: String,
+    columns: Array<String>? = null,
+    selection: String? = null,
+    selectionArgs: Array<String>? = null,
+    groupBy: String? = null,
+    having: String? = null,
+    orderBy: String? = null,
+    limit: String? = null
+) = query(
+    true, table, columns, selection, selectionArgs, groupBy, having, orderBy, limit
+)
+
 fun makePlaceholders(count: Int): String {
     return (0 until count).joinToString { "?" }
 }

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

@@ -32,7 +32,9 @@ private object ContextsPool {
 
     suspend fun <T> use(block: suspend (CoroutineContext) -> T): T = acquireContext().let {
         try {
-            block(it)
+            safely {
+                block(it)
+            }
         } finally {
             freeContext(it)
         }
@@ -48,11 +50,12 @@ class TransactionContext(
 }
 
 suspend fun <T> SQLiteDatabase.transaction(block: suspend SQLiteDatabase.() -> T): T {
-    return coroutineContext[TransactionContext] ?.let {
-        withContext(it.databaseContext) {
+    coroutineContext[TransactionContext] ?.let {
+        return withContext(it.databaseContext) {
             block()
         }
-    } ?: ContextsPool.use { context ->
+    }
+    return ContextsPool.use { context ->
         withContext(TransactionContext(context) + context) {
             beginTransaction()
             safely(
@@ -70,18 +73,18 @@ suspend fun <T> SQLiteDatabase.transaction(block: suspend SQLiteDatabase.() -> T
     }
 }
 
-inline fun <T> SQLiteDatabase.inlineTransaction(block: SQLiteDatabase.() -> T): T {
+inline fun <T> SQLiteDatabase.inlineTransaction(crossinline block: SQLiteDatabase.() -> T): T {
     return when {
         inTransaction() -> block()
         else -> {
             beginTransaction()
             try {
-                block().also {
-                    setTransactionSuccessful()
-                }
+                block().also { setTransactionSuccessful() }
             } finally {
                 endTransaction()
             }
         }
     }
 }
+
+fun <T> SQLiteDatabase.blockingTransaction(block: SQLiteDatabase.() -> T): T = inlineTransaction(block)

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

@@ -5,6 +5,7 @@ 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.keyvalue.keyValueStore
 import dev.inmo.micro_utils.repos.versions.*
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
@@ -15,7 +16,8 @@ class StandardSQLHelper(
     name: String,
     factory: SQLiteDatabase.CursorFactory? = null,
     version: Int = 1,
-    errorHandler: DatabaseErrorHandler? = null
+    errorHandler: DatabaseErrorHandler? = null,
+    useSharedPreferencesForVersions: Boolean = false
 ) {
     val sqlOpenHelper = object : SQLiteOpenHelper(context, name, factory, version, errorHandler) {
         override fun onCreate(db: SQLiteDatabase?) {}
@@ -23,7 +25,16 @@ class StandardSQLHelper(
         override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {}
     }
     val versionsRepo: VersionsRepo<SQLiteOpenHelper> by lazy {
-        StandardVersionsRepo(AndroidSQLStandardVersionsRepoProxy(sqlOpenHelper))
+        StandardVersionsRepo(
+            if (useSharedPreferencesForVersions) {
+                KeyValueBasedVersionsRepoProxy(
+                    context.keyValueStore("AndroidSPStandardVersionsRepo"),
+                    sqlOpenHelper
+                )
+            } else {
+                AndroidSQLStandardVersionsRepoProxy(sqlOpenHelper)
+            }
+        )
     }
 
     suspend fun <T> writableTransaction(block: suspend SQLiteDatabase.() -> T): T = sqlOpenHelper.writableTransaction(block)
@@ -31,6 +42,20 @@ class StandardSQLHelper(
     suspend fun <T> readableTransaction(block: suspend SQLiteDatabase.() -> T): T = sqlOpenHelper.readableTransaction(block)
 }
 
+fun <T> SQLiteOpenHelper.blockingWritableTransaction(block: SQLiteDatabase.() -> T): T {
+    return writableDatabase.blockingTransaction(block)
+}
+fun <T> SQLiteOpenHelper.blockingReadableTransaction(block: SQLiteDatabase.() -> T): T {
+    return readableDatabase.blockingTransaction(block)
+}
+
+fun <T> StandardSQLHelper.blockingWritableTransaction(block: SQLiteDatabase.() -> T): T {
+    return sqlOpenHelper.blockingWritableTransaction(block)
+}
+fun <T> StandardSQLHelper.blockingReadableTransaction(block: SQLiteDatabase.() -> T): T {
+    return sqlOpenHelper.blockingReadableTransaction(block)
+}
+
 suspend fun <T> SQLiteOpenHelper.writableTransaction(block: suspend SQLiteDatabase.() -> T): T {
     return writableDatabase.transaction(block)
 }

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

@@ -20,7 +20,7 @@ abstract class AbstractAndroidCRUDRepo<ObjectType, IdType>(
         it.count
     }.toLong()
 
-    override suspend fun contains(id: IdType): Boolean = helper.readableTransaction {
+    override suspend fun contains(id: IdType): Boolean = helper.blockingReadableTransaction {
         select(
             tableName,
             null,