fixes in tempupload

0.11.0

.github/workflows/dokka_push.yml

@@ -0,0 +1,24 @@
+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: 11
+      - name: Fix android 32.0.0 dx
+        continue-on-error: true
+        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
+      - name: Build
+        run: ./gradlew 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,28 @@
+
+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: 11
+      - name: Fix android 32.0.0 dx
+        continue-on-error: true
+        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
+      - name: Rewrite version
+        run: |
+          branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
+          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
+        continue-on-error: true
+        run: ./gradlew --no-parallel publishAllPublicationsToGithubPackagesRepository
+        env:
+          GITHUBPACKAGES_USER: ${{ github.actor }}
+          GITHUBPACKAGES_PASSWORD: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -10,5 +10,7 @@ build/
 out/
 
 secret.gradle
+local.properties
+kotlin-js-store
 
 publishing.sh

.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,13 +0,0 @@
-language: java
-install: true
-
-os: linux
-dist: trusty
-jdk: oraclejdk8
-
-jobs:
-  include:
-    - stage: build
-      script: ./gradlew build -s -x jvmTest -x jsIrTest -x jsIrBrowserTest -x jsIrNodeTest -x jsLegacyTest -x jsLegacyBrowserTest -x jsLegacyNodeTest
-    - state: test
-      script: ./gradlew allTests

README.md

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

_config.yml

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

android/alerts/common/build.gradle

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

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

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

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

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

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

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

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

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

android/alerts/recyclerview/build.gradle

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

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

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

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

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

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

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

android/recyclerview/build.gradle

@@ -0,0 +1,23 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppAndroidProjectPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api libs.kt.coroutines
+                api project(":micro_utils.common")
+            }
+        }
+        androidMain {
+            dependencies {
+                api libs.android.recyclerView
+            }
+        }
+    }
+}

android/recyclerview/src/main/AndroidManifest.xml

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

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

@@ -0,0 +1,22 @@
+package dev.inmo.micro_utils.android.recyclerview
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+
+abstract class AbstractStandardViewHolder<T>(
+    inflater: LayoutInflater,
+    container: ViewGroup?,
+    viewId: Int,
+    onViewInflated: ((View) -> Unit)? = null
+) : AbstractViewHolder<T>(
+    inflater.inflate(viewId, container, false).also {
+        onViewInflated ?.invoke(it)
+    }
+) {
+    constructor(
+        container: ViewGroup,
+        viewId: Int,
+        onViewInflated: ((View) -> Unit)? = null
+    ) : this(LayoutInflater.from(container.context), container, viewId, onViewInflated)
+}

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

@@ -0,0 +1,10 @@
+package dev.inmo.micro_utils.android.recyclerview
+
+import android.view.View
+import androidx.recyclerview.widget.RecyclerView
+
+abstract class AbstractViewHolder<in T>(
+    view: View
+) : RecyclerView.ViewHolder(view) {
+    abstract fun onBind(item: T)
+}

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

@@ -0,0 +1,9 @@
+package dev.inmo.micro_utils.android.recyclerview
+
+import android.content.Context
+import android.widget.LinearLayout
+import androidx.recyclerview.widget.DividerItemDecoration
+
+val Context.recyclerViewItemsDecoration
+    get() = DividerItemDecoration(this, LinearLayout.VERTICAL)
+

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

@@ -0,0 +1,53 @@
+package dev.inmo.micro_utils.android.recyclerview
+
+import androidx.recyclerview.widget.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.*
+
+@Suppress("NOTHING_TO_INLINE")
+private inline fun RecyclerView.LayoutManager.findLastVisibleItemPositionGetter(): (() -> Int)? = when (this) {
+    is LinearLayoutManager -> ::findLastVisibleItemPosition
+    is GridLayoutManager -> ::findLastVisibleItemPosition
+    else -> null
+}
+
+fun RecyclerView.lastVisibleItemFlow(
+    completingScope: CoroutineScope
+): Flow<Int> {
+    val lastVisibleElementFun: () -> Int = layoutManager ?.findLastVisibleItemPositionGetter() ?: error("Currently supported only linear and grid layout manager")
+    val lastVisibleFlow = MutableStateFlow(lastVisibleElementFun())
+    addOnScrollListener(
+        object : RecyclerView.OnScrollListener() {
+            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+                super.onScrolled(recyclerView, dx, dy)
+                lastVisibleFlow.value = lastVisibleElementFun()
+            }
+        }.also { scrollListener ->
+            lastVisibleFlow.onCompletion {
+                removeOnScrollListener(scrollListener)
+            }.launchIn(completingScope)
+        }
+    )
+    return lastVisibleFlow.asStateFlow()
+}
+
+inline fun Flow<Int>.mapLeftItems(
+    crossinline countGetter: () -> Int
+): Flow<Int> = map { countGetter() - it }
+
+inline fun Flow<Int>.mapRequireFilling(
+    minimalLeftItems: Int,
+    crossinline countGetter: () -> Int
+): Flow<Int> = mapLeftItems(countGetter).mapNotNull {
+    if (it < minimalLeftItems) {
+        it
+    } else {
+        null
+    }
+}
+
+inline fun RecyclerView.mapRequireFilling(
+    minimalLeftItems: Int,
+    completingScope: CoroutineScope,
+    crossinline countGetter: () -> Int
+): Flow<Int> = lastVisibleItemFlow(completingScope).mapRequireFilling(minimalLeftItems, countGetter)

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

@@ -0,0 +1,91 @@
+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>: 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
+            checkEmpty()
+        }
+
+    init {
+        registerAdapterDataObserver(
+            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()
+                }
+            }
+        )
+        checkEmpty()
+    }
+
+    override fun getItemCount(): Int = data.size
+
+    override fun onBindViewHolder(holder: AbstractViewHolder<T>, position: Int) {
+        holder.onBind(data[position])
+    }
+
+    private fun checkEmpty() {
+        emptyView ?. let {
+            if (dataCountState.value == 0) {
+                it.visibility = View.VISIBLE
+            } else {
+                it.visibility = View.GONE
+            }
+        }
+    }
+}
+
+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

@@ -1,25 +1,36 @@
 buildscript {
     repositories {
-        mavenLocal()
-        jcenter()
+        google()
         mavenCentral()
+        mavenLocal()
         maven { url "https://plugins.gradle.org/m2/" }
     }
 
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
-        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:$gradle_bintray_plugin_version"
-        classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
+        classpath libs.buildscript.kt.gradle
+        classpath libs.buildscript.kt.serialization
+        classpath libs.buildscript.jb.dokka
+        classpath libs.buildscript.gh.release
+        classpath libs.buildscript.android.gradle
+        classpath libs.buildscript.android.dexcount
     }
 }
 
 allprojects {
     repositories {
         mavenLocal()
-        jcenter()
         mavenCentral()
-        maven { url "https://kotlin.bintray.com/kotlinx" }
+        google()
+        maven { url "https://maven.pkg.jetbrains.space/public/p/compose/dev" }
+    }
+
+    // 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
+            }
+        }
     }
 }
 

build_and_publish.sh

@@ -12,4 +12,7 @@ function assert_success() {
 export RELEASE_MODE=true
 project="$1"
 
-assert_success ./gradlew clean "$project:clean" "$project:build" "$project:publishToMavenLocal" "$project:bintrayUpload"
+assert_success ./gradlew clean
+assert_success ./gradlew "$project:build"
+assert_success ./gradlew "$project:publishToMavenLocal"
+assert_success ./gradlew "$project:bintrayUpload"

common/build.gradle

@@ -1,6 +1,22 @@
 plugins {
     id "org.jetbrains.kotlin.multiplatform"
     id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
 }
 
 apply from: "$mppProjectWithSerializationPresetPath"
+
+kotlin {
+    sourceSets {
+        jvmMain {
+            dependencies {
+                api project(":micro_utils.coroutines")
+            }
+        }
+        androidMain {
+            dependencies {
+                api project(":micro_utils.coroutines")
+            }
+        }
+    }
+}

common/compose/build.gradle

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

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

@@ -0,0 +1,16 @@
+package dev.inmo.micro_utils.common.compose
+
+import androidx.compose.runtime.DisposableEffectResult
+
+class DefaultDisposableEffectResult(
+    private val onDispose: () -> Unit
+) : DisposableEffectResult {
+    override fun dispose() {
+        onDispose()
+    }
+
+    companion object {
+        val DoNothing = DefaultDisposableEffectResult {}
+    }
+}
+

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

@@ -0,0 +1,9 @@
+package dev.inmo.micro_utils.common.compose
+
+import androidx.compose.runtime.Composition
+import dev.inmo.micro_utils.common.onRemoved
+import org.w3c.dom.Element
+
+fun Composition.linkWithElement(element: Element) {
+    element.onRemoved { dispose() }
+}

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

@@ -0,0 +1,10 @@
+package dev.inmo.micro_utils.common.compose
+
+import org.jetbrains.compose.web.attributes.ATarget
+
+fun openLink(link: String, mode: ATarget = ATarget.Blank, features: String = "") = dev.inmo.micro_utils.common.openLink(
+    link,
+    mode.targetStr,
+    features
+)
+

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

@@ -0,0 +1,13 @@
+package dev.inmo.micro_utils.common.compose
+
+import androidx.compose.runtime.*
+import org.jetbrains.compose.web.dom.DOMScope
+import org.w3c.dom.Element
+
+fun <TElement : Element> renderComposableAndLinkToRoot(
+    root: TElement,
+    monotonicFrameClock: MonotonicFrameClock = DefaultMonotonicFrameClock,
+    content: @Composable DOMScope<TElement>.() -> Unit
+): Composition = org.jetbrains.compose.web.renderComposable(root, monotonicFrameClock, content).apply {
+    linkWithElement(root)
+}

common/compose/src/main/AndroidManifest.xml

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

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

@@ -0,0 +1,35 @@
+@file:Suppress("OPT_IN_IS_NOT_ENABLED")
+
+package dev.inmo.micro_utils.common
+
+@RequiresOptIn(
+    "It is possible, that behaviour of this thing will be changed or removed in future releases",
+    RequiresOptIn.Level.WARNING
+)
+@Target(
+    AnnotationTarget.CLASS,
+    AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.PROPERTY_GETTER,
+    AnnotationTarget.PROPERTY_SETTER,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.TYPEALIAS
+)
+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",
+    RequiresOptIn.Level.WARNING
+)
+@Target(
+    AnnotationTarget.CLASS,
+    AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.PROPERTY_GETTER,
+    AnnotationTarget.PROPERTY_SETTER,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.TYPEALIAS
+)
+annotation class Warning(val message: String)

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

@@ -27,8 +27,8 @@ data class Diff<T> internal constructor(
 
 private inline fun <T> performChanges(
     potentialChanges: MutableList<Pair<IndexedValue<T>?, IndexedValue<T>?>>,
-    additionalsInOld: MutableList<T>,
-    additionalsInNew: MutableList<T>,
+    additionsInOld: MutableList<T>,
+    additionsInNew: MutableList<T>,
     changedList: MutableList<Pair<IndexedValue<T>, IndexedValue<T>>>,
     removedList: MutableList<IndexedValue<T>>,
     addedList: MutableList<IndexedValue<T>>,
@@ -43,6 +43,7 @@ private inline fun <T> performChanges(
         if (oldOneEqualToNewObject || newOneEqualToOldObject) {
             changedList.addAll(
                 potentialChanges.take(i).mapNotNull {
+                    @Suppress("UNCHECKED_CAST")
                     if (it.first != null && it.second != null) it as Pair<IndexedValue<T>, IndexedValue<T>> else null
                 }
             )
@@ -52,20 +53,20 @@ private inline fun <T> performChanges(
                     newPotentials.first().second ?.let { addedList.add(it) }
                     newPotentials.drop(1).take(newPotentials.size - 2).forEach { (oldOne, newOne) ->
                         addedList.add(newOne!!)
-                        oldOne ?.let { additionalsInOld.add(oldOne.value) }
+                        oldOne ?.let { additionsInOld.add(oldOne.value) }
                     }
                     if (newPotentials.size > 1) {
-                        newPotentials.last().first ?.value ?.let { additionalsInOld.add(it) }
+                        newPotentials.last().first ?.value ?.let { additionsInOld.add(it) }
                     }
                 }
                 newOneEqualToOldObject -> {
                     newPotentials.first().first ?.let { removedList.add(it) }
                     newPotentials.drop(1).take(newPotentials.size - 2).forEach { (oldOne, newOne) ->
                         removedList.add(oldOne!!)
-                        newOne ?.let { additionalsInNew.add(newOne.value) }
+                        newOne ?.let { additionsInNew.add(newOne.value) }
                     }
                     if (newPotentials.size > 1) {
-                        newPotentials.last().second ?.value ?.let { additionalsInNew.add(it) }
+                        newPotentials.last().second ?.value ?.let { additionsInNew.add(it) }
                     }
                 }
             }
@@ -121,7 +122,10 @@ fun <T> Iterable<T>.calculateDiff(
 
         when {
             oldObject === newObject || (oldObject == newObject && !strictComparison) -> {
-                changedObjects.addAll(potentiallyChangedObjects.map { it as Pair<IndexedValue<T>, IndexedValue<T>> })
+                changedObjects.addAll(potentiallyChangedObjects.map {
+                    @Suppress("UNCHECKED_CAST")
+                    it as Pair<IndexedValue<T>, IndexedValue<T>>
+                })
                 potentiallyChangedObjects.clear()
             }
             else -> {
@@ -139,6 +143,10 @@ fun <T> Iterable<T>.calculateDiff(
 
     return Diff(removedObjects.toList(), changedObjects.toList(), addedObjects.toList())
 }
+inline fun <T> Iterable<T>.diff(
+    other: Iterable<T>,
+    strictComparison: Boolean = false
+): Diff<T> = calculateDiff(other, strictComparison)
 
 inline fun <T> Diff(old: Iterable<T>, new: Iterable<T>) = old.calculateDiff(new)
 inline fun <T> StrictDiff(old: Iterable<T>, new: Iterable<T>) = old.calculateDiff(new, true)
@@ -151,16 +159,20 @@ inline fun <T> Iterable<T>.calculateStrictDiff(
 ) = calculateDiff(other, strictComparison = true)
 
 /**
- * Compare one-to-one
+ * This method call [calculateDiff] with strict mode [strictComparison] and then apply differences to [this]
+ * mutable list
  */
-@Deprecated("Will be removed or replaced with some new function. Use calculateDiff instead")
-inline fun <T> Iterable<T>.syncWith(
-    other: Iterable<T>,
-    noinline removed: (List<T>) -> Unit = {},
-    noinline added: (List<T>) -> Unit = {}
-) {
-    calculateDiff(other).also {
-        removed(it.removed.map { it.value })
-        added(it.added.map { it.value })
+fun <T> MutableList<T>.applyDiff(
+    source: Iterable<T>,
+    strictComparison: Boolean = false
+) = calculateDiff(source, strictComparison).let {
+    for (i in it.removed.indices.sortedDescending()) {
+        removeAt(it.removed[i].index)
+    }
+    it.added.forEach { (i, t) ->
+        add(i, t)
+    }
+    it.replaced.forEach { (_, new) ->
+        set(new.index, new.value)
     }
 }

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

@@ -0,0 +1,159 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.serialization.*
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.encoding.*
+
+/**
+ * Realization of this interface will contains at least one not null - [optionalT1] or [optionalT2]
+ *
+ * @see EitherFirst
+ * @see EitherSecond
+ * @see Either.Companion.first
+ * @see Either.Companion.second
+ * @see Either.onFirst
+ * @see Either.onSecond
+ * @see Either.mapOnFirst
+ * @see Either.mapOnSecond
+ */
+@Serializable(EitherSerializer::class)
+sealed interface Either<T1, T2> {
+    val optionalT1: Optional<T1>
+    val optionalT2: Optional<T2>
+    @Deprecated("Use optionalT1 instead", ReplaceWith("optionalT1"))
+    val t1: T1?
+        get() = optionalT1.dataOrNull()
+    @Deprecated("Use optionalT2 instead", ReplaceWith("optionalT2"))
+    val t2: T2?
+        get() = optionalT2.dataOrNull()
+}
+
+class EitherSerializer<T1, T2>(
+    t1Serializer: KSerializer<T1>,
+    t2Serializer: KSerializer<T2>,
+) : KSerializer<Either<T1, T2>> {
+    @OptIn(InternalSerializationApi::class)
+    override val descriptor: SerialDescriptor = buildSerialDescriptor(
+        "TypedSerializer",
+        SerialKind.CONTEXTUAL
+    ) {
+        element("type", String.serializer().descriptor)
+        element("value", ContextualSerializer(Either::class).descriptor)
+    }
+    private val t1EitherSerializer = EitherFirst.serializer(t1Serializer, t2Serializer)
+    private val t2EitherSerializer = EitherSecond.serializer(t1Serializer, t2Serializer)
+
+    override fun deserialize(decoder: Decoder): Either<T1, T2> {
+        return decoder.decodeStructure(descriptor) {
+            var type: String? = null
+            lateinit var result: Either<T1, T2>
+            while (true) {
+                when (val index = decodeElementIndex(descriptor)) {
+                    0 -> type = decodeStringElement(descriptor, 0)
+                    1 -> {
+                        result = when (type) {
+                            "t1" -> decodeSerializableElement(
+                                descriptor,
+                                1,
+                                t1EitherSerializer
+                            )
+                            "t2" -> decodeSerializableElement(
+                                descriptor,
+                                1,
+                                t2EitherSerializer
+                            )
+                            else -> error("Unknown type of either: $type")
+                        }
+                    }
+                    CompositeDecoder.DECODE_DONE -> break
+                    else -> error("Unexpected index: $index")
+                }
+            }
+            result
+        }
+    }
+
+
+    override fun serialize(encoder: Encoder, value: Either<T1, T2>) {
+        encoder.encodeStructure(descriptor) {
+            when (value) {
+                is EitherFirst -> {
+                    encodeStringElement(descriptor, 0, "t1")
+                    encodeSerializableElement(descriptor, 1, t1EitherSerializer, value)
+                }
+                is EitherSecond -> {
+                    encodeStringElement(descriptor, 0, "t2")
+                    encodeSerializableElement(descriptor, 1, t2EitherSerializer, value)
+                }
+            }
+        }
+    }
+}
+
+/**
+ * This type [Either] will always have not nullable [optionalT1]
+ */
+@Serializable
+data class EitherFirst<T1, T2>(
+    override val t1: T1
+) : Either<T1, T2> {
+    override val optionalT1: Optional<T1> = t1.optional
+    override val optionalT2: Optional<T2> = Optional.absent()
+}
+
+/**
+ * This type [Either] will always have not nullable [optionalT2]
+ */
+@Serializable
+data class EitherSecond<T1, T2>(
+    override val t2: T2
+) : Either<T1, T2> {
+    override val optionalT1: Optional<T1> = Optional.absent()
+    override val optionalT2: Optional<T2> = t2.optional
+}
+
+/**
+ * @return New instance of [EitherFirst]
+ */
+inline fun <T1, T2> Either.Companion.first(t1: T1): Either<T1, T2> = EitherFirst(t1)
+/**
+ * @return New instance of [EitherSecond]
+ */
+inline fun <T1, T2> Either.Companion.second(t2: T2): Either<T1, T2> = EitherSecond(t2)
+
+/**
+ * Will call [block] in case when [this] is [EitherFirst]
+ */
+inline fun <T1, T2, E : Either<T1, T2>> E.onFirst(block: (T1) -> Unit): E {
+    optionalT1.onPresented(block)
+    return this
+}
+
+/**
+ * Will call [block] in case when [this] is [EitherSecond]
+ */
+inline fun <T1, T2, E : Either<T1, T2>> E.onSecond(block: (T2) -> Unit): E {
+    optionalT2.onPresented(block)
+    return this
+}
+
+/**
+ * @return Result of [block] if [this] is [EitherFirst]
+ */
+inline fun <T1, R> Either<T1, *>.mapOnFirst(block: (T1) -> R): R? {
+    return optionalT1.mapOnPresented(block)
+}
+
+/**
+ * @return Result of [block] if [this] is [EitherSecond]
+ */
+inline fun <T2, R> Either<*, T2>.mapOnSecond(block: (T2) -> R): R? {
+    return optionalT2.mapOnPresented(block)
+}
+
+inline fun <reified T1, reified T2> Any.either() = when (this) {
+    is T1 -> Either.first<T1, T2>(this)
+    is T2 -> Either.second<T1, T2>(this)
+    else -> error("Incorrect type of either argument $this")
+}

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/JoinTo.kt

@@ -0,0 +1,59 @@
+package dev.inmo.micro_utils.common
+
+inline fun <I, R> Iterable<I>.joinTo(
+    separatorFun: (I) -> R?,
+    prefix: R? = null,
+    postfix: R? = null,
+    transform: (I) -> R?
+): List<R> {
+    val result = mutableListOf<R>()
+    val iterator = iterator()
+
+    prefix ?.let(result::add)
+
+    while (iterator.hasNext()) {
+        val element = iterator.next()
+        result.add(transform(element) ?: continue)
+
+        if (iterator.hasNext()) {
+            result.add(separatorFun(element) ?: continue)
+        }
+    }
+
+    postfix ?.let(result::add)
+
+    return result
+}
+
+inline fun <I, R> Iterable<I>.joinTo(
+    separator: R? = null,
+    prefix: R? = null,
+    postfix: R? = null,
+    transform: (I) -> R?
+): List<R> = joinTo({ separator }, prefix, postfix, transform)
+
+inline fun <I> Iterable<I>.joinTo(
+    separatorFun: (I) -> I?,
+    prefix: I? = null,
+    postfix: I? = null
+): List<I> = joinTo<I, I>(separatorFun, prefix, postfix) { it }
+
+inline fun <I> Iterable<I>.joinTo(
+    separator: I? = null,
+    prefix: I? = null,
+    postfix: I? = null
+): List<I> = joinTo<I>({ separator }, prefix, postfix)
+
+inline fun <I, reified R> Array<I>.joinTo(
+    separatorFun: (I) -> R?,
+    prefix: R? = null,
+    postfix: R? = null,
+    transform: (I) -> R?
+): Array<R> = asIterable().joinTo(separatorFun, prefix, postfix, transform).toTypedArray()
+
+inline fun <I, reified R> Array<I>.joinTo(
+    separator: R? = null,
+    prefix: R? = null,
+    postfix: R? = null,
+    transform: (I) -> R?
+): Array<R> = asIterable().joinTo(separator, prefix, postfix, transform).toTypedArray()

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

@@ -0,0 +1,34 @@
+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() = withoutSlashAtTheEnd.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
+        }
+    val withoutSlashAtTheEnd: String
+        get() = string.dropLastWhile { it == '/' }
+    override fun toString(): String = string
+}
+
+
+expect class MPPFile
+
+expect val MPPFile.filename: FileName
+expect val MPPFile.filesize: Long
+expect val MPPFile.bytesAllocatorSync: ByteArrayAllocator
+expect val MPPFile.bytesAllocator: SuspendByteArrayAllocator
+fun MPPFile.bytesSync() = bytesAllocatorSync()
+suspend fun MPPFile.bytes() = bytesAllocator()
+

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

@@ -0,0 +1,92 @@
+@file:Suppress("unused")
+
+package dev.inmo.micro_utils.common
+
+import kotlinx.serialization.Serializable
+
+/**
+ * This type represents [T] as not only potentially nullable data, but also as a data which can not be presented. This
+ * type will be useful in cases when [T] is nullable and null as valuable data too in time of data absence should be
+ * presented by some third type.
+ *
+ * Let's imagine, you have nullable name in some database. In case when name is not nullable everything is clear - null
+ * will represent absence of row in the database. In case when name is nullable null will be a little bit dual-meaning,
+ * cause this null will say nothing about availability of the row (of course, it is exaggerated example)
+ *
+ * @see Optional.presented
+ * @see Optional.absent
+ * @see Optional.optional
+ * @see Optional.onPresented
+ * @see Optional.onAbsent
+ */
+@Serializable
+data class Optional<T> internal constructor(
+    @Warning("It is unsafe to use this data directly")
+    val data: T?,
+    @Warning("It is unsafe to use this data directly")
+    val dataPresented: Boolean
+) {
+    companion object {
+        /**
+         * Will create [Optional] with presented data
+         */
+        fun <T> presented(data: T) = Optional(data, true)
+        /**
+         * Will create [Optional] without data
+         */
+        fun <T> absent() = Optional<T>(null, false)
+    }
+}
+
+inline val <T> T.optional
+    get() = Optional.presented(this)
+
+/**
+ * Will call [block] when data presented ([Optional.dataPresented] == true)
+ */
+inline fun <T> Optional<T>.onPresented(block: (T) -> Unit): Optional<T> = apply {
+    if (dataPresented) { @Suppress("UNCHECKED_CAST") block(data as T) }
+}
+
+/**
+ * Will call [block] when data presented ([Optional.dataPresented] == true)
+ */
+inline fun <T, R> Optional<T>.mapOnPresented(block: (T) -> R): R? = run {
+    if (dataPresented) { @Suppress("UNCHECKED_CAST") block(data as T) } else null
+}
+
+/**
+ * Will call [block] when data absent ([Optional.dataPresented] == false)
+ */
+inline fun <T> Optional<T>.onAbsent(block: () -> Unit): Optional<T> = apply {
+    if (!dataPresented) { block() }
+}
+
+/**
+ * Will call [block] when data presented ([Optional.dataPresented] == true)
+ */
+inline fun <T, R> Optional<T>.mapOnAbsent(block: () -> R): R? = run {
+    if (!dataPresented) { @Suppress("UNCHECKED_CAST") block() } else null
+}
+
+/**
+ * Returns [Optional.data] if [Optional.dataPresented] of [this] is true, or null otherwise
+ */
+fun <T> Optional<T>.dataOrNull() = if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else null
+
+/**
+ * Returns [Optional.data] if [Optional.dataPresented] of [this] is true, or throw [throwable] otherwise
+ */
+fun <T> Optional<T>.dataOrThrow(throwable: Throwable) = if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else throw throwable
+
+
+/**
+ * Returns [Optional.data] if [Optional.dataPresented] of [this] is true, or call [block] and returns the result of it
+ */
+inline fun <T> Optional<T>.dataOrElse(block: () -> T) = if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else block()
+
+/**
+ * Returns [Optional.data] if [Optional.dataPresented] of [this] is true, or call [block] and returns the result of it
+ */
+@Deprecated("dataOrElse now is inline", ReplaceWith("dataOrElse", "dev.inmo.micro_utils.common.dataOrElse"))
+suspend fun <T> Optional<T>.dataOrElseSuspendable(block: suspend () -> T) = if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else block()

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

@@ -0,0 +1,19 @@
+package dev.inmo.micro_utils.common
+
+fun <T : Comparable<T>> ClosedRange<T>.intersect(other: ClosedRange<T>): Pair<T, T>? = when {
+    start == other.start && endInclusive == other.endInclusive -> start to endInclusive
+    start > other.endInclusive || other.start > endInclusive -> null
+    else -> maxOf(start, other.start) to minOf(endInclusive, other.endInclusive)
+}
+
+fun IntRange.intersect(
+    other: IntRange
+): IntRange? = (this as ClosedRange<Int>).intersect(other as ClosedRange<Int>) ?.let {
+    it.first .. it.second
+}
+
+fun LongRange.intersect(
+    other: LongRange
+): LongRange? = (this as ClosedRange<Long>).intersect(other as ClosedRange<Long>) ?.let {
+    it.first .. it.second
+}

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

@@ -0,0 +1,21 @@
+package dev.inmo.micro_utils.common
+
+/**
+ * Executes the given [action] until getting of successful result specified number of [times].
+ *
+ * A zero-based index of current iteration is passed as a parameter to [action].
+ */
+inline fun <R> repeatOnFailure(
+    times: Int,
+    onEachFailure: (Throwable) -> Unit = {},
+    action: (Int) -> R
+): Optional<R> {
+    repeat(times) {
+        runCatching {
+            action(it)
+        }.onFailure(onEachFailure).onSuccess {
+            return Optional.presented(it)
+        }
+    }
+    return Optional.absent()
+}

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

@@ -11,7 +11,7 @@ class DiffUtilsTests {
         val withIndex = oldList.withIndex()
 
         for (count in 1 .. (floor(oldList.size.toFloat() / 2).toInt())) {
-            for ((i, v) in withIndex) {
+            for ((i, _) in withIndex) {
                 if (i + count > oldList.lastIndex) {
                     continue
                 }
@@ -32,7 +32,7 @@ class DiffUtilsTests {
         val withIndex = oldList.withIndex()
 
         for (count in 1 .. (floor(oldList.size.toFloat() / 2).toInt())) {
-            for ((i, v) in withIndex) {
+            for ((i, _) in withIndex) {
                 if (i + count > oldList.lastIndex) {
                     continue
                 }
@@ -54,8 +54,8 @@ class DiffUtilsTests {
         val oldList = (0 until 10).map { it.toString() }
         val withIndex = oldList.withIndex()
 
-        for (step in 0 until oldList.size) {
-            for ((i, v) in withIndex) {
+        for (step in oldList.indices) {
+            for ((i, _) in withIndex) {
                 val mutable = oldList.toMutableList()
                 val changes = (
                     if (step == 0) i until oldList.size else (i until oldList.size step step)
@@ -73,4 +73,83 @@ class DiffUtilsTests {
             }
         }
     }
+
+    @Test
+    fun testThatSimpleRemoveApplyWorks() {
+        val oldList = (0 until 10).toList()
+        val withIndex = oldList.withIndex()
+
+        for (count in 1 .. (floor(oldList.size.toFloat() / 2).toInt())) {
+            for ((i, _) in withIndex) {
+                if (i + count > oldList.lastIndex) {
+                    continue
+                }
+                val removedSublist = oldList.subList(i, i + count)
+                val mutableOldList = oldList.toMutableList()
+                val targetList = oldList - removedSublist
+
+                mutableOldList.applyDiff(targetList)
+
+                assertEquals(
+                    targetList,
+                    mutableOldList
+                )
+            }
+        }
+    }
+
+    @Test
+    fun testThatSimpleAddApplyWorks() {
+        val oldList = (0 until 10).map { it.toString() }
+        val withIndex = oldList.withIndex()
+
+        for (count in 1 .. (floor(oldList.size.toFloat() / 2).toInt())) {
+            for ((i, _) in withIndex) {
+                if (i + count > oldList.lastIndex) {
+                    continue
+                }
+                val addedSublist = oldList.subList(i, i + count).map { "added$it" }
+                val mutable = oldList.toMutableList()
+                mutable.addAll(i, addedSublist)
+                val mutableOldList = oldList.toMutableList()
+
+                mutableOldList.applyDiff(mutable)
+
+                assertEquals(
+                    mutable,
+                    mutableOldList
+                )
+            }
+        }
+    }
+
+    @Test
+    fun testThatSimpleChangesApplyWorks() {
+        val oldList = (0 until 10).map { it.toString() }
+        val withIndex = oldList.withIndex()
+
+        for (step in oldList.indices) {
+            for ((i, _) in withIndex) {
+                val mutable = oldList.toMutableList()
+
+                val newList = if (step == 0) {
+                    i until oldList.size
+                } else {
+                    i until oldList.size step step
+                }
+                newList.forEach { index ->
+                    IndexedValue(index, mutable[index]) to IndexedValue(index, "changed$index").also {
+                        mutable[index] = it.value
+                    }
+                }
+
+                val mutableOldList = oldList.toMutableList()
+                mutableOldList.applyDiff(mutable)
+                assertEquals(
+                    mutable,
+                    mutableOldList
+                )
+            }
+        }
+    }
 }

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

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.common
+
+import org.khronos.webgl.*
+
+fun DataView.toByteArray() = ByteArray(this.byteLength) {
+    getInt8(it)
+}
+
+fun ArrayBuffer.toByteArray() = Int8Array(this) as ByteArray
+
+fun ByteArray.toDataView() = DataView(ArrayBuffer(size)).also {
+    forEachIndexed { i, byte -> it.setInt8(i, byte) }
+}
+
+fun ByteArray.toArrayBuffer() = toDataView().buffer

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

@@ -0,0 +1,61 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.browser.document
+import org.w3c.dom.*
+
+fun Node.onRemoved(block: () -> Unit): MutationObserver {
+    lateinit var observer: MutationObserver
+
+    observer = MutationObserver { _, _ ->
+        fun checkIfRemoved(node: Node): Boolean {
+            return node.parentNode != document && (node.parentNode ?.let { checkIfRemoved(it) } ?: true)
+        }
+
+        if (checkIfRemoved(this)) {
+            observer.disconnect()
+            block()
+        }
+    }
+
+    observer.observe(document, MutationObserverInit(childList = true, subtree = true))
+    return observer
+}
+
+fun Element.onVisibilityChanged(block: IntersectionObserverEntry.(Float, IntersectionObserver) -> Unit): IntersectionObserver {
+    var previousIntersectionRatio = -1f
+    val observer = IntersectionObserver { entries, observer ->
+        entries.forEach {
+            if (previousIntersectionRatio != it.intersectionRatio) {
+                previousIntersectionRatio = it.intersectionRatio.toFloat()
+                it.block(previousIntersectionRatio, observer)
+            }
+        }
+    }
+
+    observer.observe(this)
+    return observer
+}
+
+fun Element.onVisible(block: Element.(IntersectionObserver) -> Unit) {
+    var previous = -1f
+    onVisibilityChanged { intersectionRatio, observer ->
+        if (previous != intersectionRatio) {
+            if (intersectionRatio > 0 && previous == 0f) {
+                block(observer)
+            }
+            previous = intersectionRatio
+        }
+    }
+}
+
+fun Element.onInvisible(block: Element.(IntersectionObserver) -> Unit): IntersectionObserver {
+    var previous = -1f
+    return onVisibilityChanged { intersectionRatio, observer ->
+        if (previous != intersectionRatio) {
+            if (intersectionRatio == 0f && previous != 0f) {
+                block(observer)
+            }
+            previous = intersectionRatio
+        }
+    }
+}

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

@@ -0,0 +1,124 @@
+package dev.inmo.micro_utils.common
+
+import org.w3c.dom.DOMRectReadOnly
+import org.w3c.dom.Element
+
+external interface IntersectionObserverOptions {
+    /**
+     * An Element or Document object which is an ancestor of the intended target, whose bounding rectangle will be
+     * considered the viewport. Any part of the target not visible in the visible area of the root is not considered
+     * visible.
+     */
+    var root: Element?
+
+    /**
+     * A string which specifies a set of offsets to add to the root's bounding_box when calculating intersections,
+     * effectively shrinking or growing the root for calculation purposes. The syntax is approximately the same as that
+     * for the CSS margin property; see The root element and root margin in Intersection Observer API for more
+     * information on how the margin works and the syntax. The default is "0px 0px 0px 0px".
+     */
+    var rootMargin: String?
+
+    /**
+     * Either a single number or an array of numbers between 0.0 and 1.0, specifying a ratio of intersection area to
+     * total bounding box area for the observed target. A value of 0.0 means that even a single visible pixel counts as
+     * the target being visible. 1.0 means that the entire target element is visible. See Thresholds in Intersection
+     * Observer API for a more in-depth description of how thresholds are used. The default is a threshold of 0.0.
+     */
+    var threshold: Array<Number>?
+}
+fun IntersectionObserverOptions(
+    block: IntersectionObserverOptions.() -> Unit = {}
+): IntersectionObserverOptions = js("{}").unsafeCast<IntersectionObserverOptions>().apply(block)
+
+external interface IntersectionObserverEntry {
+    /**
+     * Returns the bounds rectangle of the target element as a DOMRectReadOnly. The bounds are computed as described in
+     * the documentation for Element.getBoundingClientRect().
+     */
+    val boundingClientRect: DOMRectReadOnly
+
+    /**
+     * Returns the ratio of the intersectionRect to the boundingClientRect.
+     */
+    val intersectionRatio: Number
+
+    /**
+     * Returns a DOMRectReadOnly representing the target's visible area.
+     */
+    val intersectionRect: DOMRectReadOnly
+
+    /**
+     * A Boolean value which is true if the target element intersects with the intersection observer's root. If this is
+     * true, then, the IntersectionObserverEntry describes a transition into a state of intersection; if it's false,
+     * then you know the transition is from intersecting to not-intersecting.
+     */
+    val isIntersecting: Boolean
+
+    /**
+     * Returns a DOMRectReadOnly for the intersection observer's root.
+     */
+    val rootBounds: DOMRectReadOnly
+
+    /**
+     * The Element whose intersection with the root changed.
+     */
+    val target: Element
+
+    /**
+     * A DOMHighResTimeStamp indicating the time at which the intersection was recorded, relative to the
+     * IntersectionObserver's time origin.
+     */
+    val time: Double
+}
+
+typealias IntersectionObserverCallback = (entries: Array<IntersectionObserverEntry>, observer: IntersectionObserver) -> Unit
+
+/**
+ * This is just an implementation from [this commentary](https://youtrack.jetbrains.com/issue/KT-43157#focus=Comments-27-4498582.0-0)
+ * of Kotlin JS issue related to the absence of [Intersection Observer API](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver)
+ */
+external class IntersectionObserver(callback: IntersectionObserverCallback) {
+    constructor(callback: IntersectionObserverCallback, options: IntersectionObserverOptions)
+
+    /**
+     * The Element or Document whose bounds are used as the bounding box when testing for intersection. If no root value
+     * was passed to the constructor or its value is null, the top-level document's viewport is used.
+     */
+    val root: Element
+
+    /**
+     * An offset rectangle applied to the root's bounding box when calculating intersections, effectively shrinking or
+     * growing the root for calculation purposes. The value returned by this property may not be the same as the one
+     * specified when calling the constructor as it may be changed to match internal requirements. Each offset can be
+     * expressed in pixels (px) or as a percentage (%). The default is "0px 0px 0px 0px".
+     */
+    val rootMargin: String
+
+    /**
+     * A list of thresholds, sorted in increasing numeric order, where each threshold is a ratio of intersection area to
+     * bounding box area of an observed target. Notifications for a target are generated when any of the thresholds are
+     * crossed for that target. If no value was passed to the constructor, 0 is used.
+     */
+    val thresholds: Array<Number>
+
+    /**
+     * Stops the IntersectionObserver object from observing any target.
+     */
+    fun disconnect()
+
+    /**
+     * Tells the IntersectionObserver a target element to observe.
+     */
+    fun observe(targetElement: Element)
+
+    /**
+     * Returns an array of IntersectionObserverEntry objects for all observed targets.
+     */
+    fun takeRecords(): Array<IntersectionObserverEntry>
+
+    /**
+     * Tells the IntersectionObserver to stop observing a particular target element.
+     */
+    fun unobserve(targetElement: Element)
+}

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

@@ -0,0 +1,12 @@
+package dev.inmo.micro_utils.common
+
+import org.w3c.dom.Element
+
+inline val Element.isOverflowWidth
+    get() = scrollWidth > clientWidth
+
+inline val Element.isOverflowHeight
+    get() = scrollHeight > clientHeight
+
+inline val Element.isOverflow
+    get() = isOverflowHeight || isOverflowWidth

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

@@ -0,0 +1,54 @@
+package dev.inmo.micro_utils.common
+
+import org.khronos.webgl.ArrayBuffer
+import org.w3c.dom.ErrorEvent
+import org.w3c.files.*
+import kotlin.js.Promise
+
+/**
+ * @suppress
+ */
+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)
+}
+
+fun MPPFile.readBytes(): ByteArray {
+    val reader = FileReaderSync()
+    return reader.readAsArrayBuffer(this).toByteArray()
+}
+
+private suspend fun MPPFile.dirtyReadBytes(): ByteArray = readBytesPromise().await()
+
+/**
+ * @suppress
+ */
+actual val MPPFile.filename: FileName
+    get() = FileName(name)
+/**
+ * @suppress
+ */
+actual val MPPFile.filesize: Long
+    get() = size.toLong()
+/**
+ * @suppress
+ */
+@Warning("That is not optimized version of bytes allocator. Use asyncBytesAllocator everywhere you can")
+actual val MPPFile.bytesAllocatorSync: ByteArrayAllocator
+    get() = ::readBytes
+/**
+ * @suppress
+ */
+@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/OnClickOutside.kt

@@ -0,0 +1,38 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.browser.document
+import org.w3c.dom.*
+import org.w3c.dom.events.Event
+import org.w3c.dom.events.EventListener
+
+fun Element.onActionOutside(type: String, options: dynamic = null, callback: (Event) -> Unit): EventListener {
+    lateinit var observer: MutationObserver
+    val listener = EventListener {
+        val elementsToCheck = mutableListOf<Element>(this@onActionOutside)
+        while (it.target != this@onActionOutside && elementsToCheck.isNotEmpty()) {
+            val childrenGettingElement = elementsToCheck.removeFirst()
+            for (i in 0 until childrenGettingElement.childElementCount) {
+                elementsToCheck.add(childrenGettingElement.children[i] ?: continue)
+            }
+        }
+        if (elementsToCheck.isEmpty()) {
+            callback(it)
+        }
+    }
+    if (options == null) {
+        document.addEventListener(type, listener)
+    } else {
+        document.addEventListener(type, listener, options)
+    }
+    observer = onRemoved {
+        if (options == null) {
+            document.removeEventListener(type, listener)
+        } else {
+            document.removeEventListener(type, listener, options)
+        }
+        observer.disconnect()
+    }
+    return listener
+}
+
+fun Element.onClickOutside(options: dynamic = null, callback: (Event) -> Unit) = onActionOutside("click", options, callback)

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

@@ -0,0 +1,8 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.browser.window
+
+fun openLink(link: String, target: String = "_blank", features: String = "") {
+    window.open(link, target, features) ?.focus()
+}
+

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/jsMain/kotlin/dev/inmo/micro_utils/common/ResizeObserver.kt

@@ -0,0 +1,58 @@
+package dev.inmo.micro_utils.common
+
+import org.w3c.dom.*
+import kotlin.js.Json
+import kotlin.js.json
+
+external class ResizeObserver(
+    callback: (Array<ResizeObserverEntry>, ResizeObserver) -> Unit
+) {
+    fun observe(target: Element, options: Json = definedExternally)
+
+    fun unobserve(target: Element)
+
+    fun disconnect()
+}
+
+external interface ResizeObserverSize {
+    val blockSize: Float
+    val inlineSize: Float
+}
+
+external interface ResizeObserverEntry {
+    val borderBoxSize: Array<ResizeObserverSize>
+    val contentBoxSize: Array<ResizeObserverSize>
+    val devicePixelContentBoxSize: Array<ResizeObserverSize>
+    val contentRect: DOMRectReadOnly
+    val target: Element
+}
+
+fun ResizeObserver.observe(target: Element, options: ResizeObserverObserveOptions) = observe(
+    target,
+    json(
+        "box" to options.box ?.name
+    )
+)
+
+class ResizeObserverObserveOptions(
+    val box: Box? = null
+) {
+    sealed interface Box {
+        val name: String
+
+        object Content : Box {
+            override val name: String
+                get() = "content-box"
+        }
+
+        object Border : Box {
+            override val name: String
+                get() = "border-box"
+        }
+
+        object DevicePixelContent : Box {
+            override val name: String
+                get() = "device-pixel-content-box"
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.browser.document
+import kotlinx.dom.createElement
+import org.w3c.dom.HTMLElement
+import org.w3c.dom.HTMLInputElement
+import org.w3c.files.get
+
+fun selectFile(
+    inputSetup: (HTMLInputElement) -> Unit = {},
+    onFailure: (Throwable) -> Unit = {},
+    onFile: (MPPFile) -> Unit
+) {
+    (document.createElement("input") {
+        (this as HTMLInputElement).apply {
+            type = "file"
+            onchange = {
+                runCatching {
+                    files ?.get(0) ?: error("File must not be null")
+                }.onSuccess {
+                    onFile(it)
+                }.onFailure {
+                    onFailure(it)
+                }
+            }
+            inputSetup(this)
+        }
+    } as HTMLElement).click()
+}
+

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

@@ -0,0 +1,14 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.browser.document
+import org.w3c.dom.HTMLAnchorElement
+
+fun triggerDownloadFile(filename: String, fileLink: String) {
+    val hiddenElement = document.createElement("a") as HTMLAnchorElement
+
+    hiddenElement.href = fileLink
+    hiddenElement.target = "_blank"
+    hiddenElement.download = filename
+    hiddenElement.click()
+}
+

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

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

common/src/main/AndroidManifest.xml

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+package dev.inmo.micro_utils.common
+
+@Suppress("UNCHECKED_CAST", "SimplifiableCall")
+inline fun <T, R> Iterable<T>.mapNotNullA(transform: (T) -> R?): List<R> = map(transform).filter { it != null } as List<R>
+
+@Suppress("UNCHECKED_CAST", "SimplifiableCall")
+inline fun <T, R> Array<T>.mapNotNullA(mapper: (T) -> R?): List<R> = map(mapper).filter { it != null } as List<R>

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

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

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

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

coroutines/build.gradle

@@ -1,6 +1,7 @@
 plugins {
     id "org.jetbrains.kotlin.multiplatform"
     id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
 }
 
 apply from: "$mppProjectWithSerializationPresetPath"
@@ -9,7 +10,17 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
+                api libs.kt.coroutines
+            }
+        }
+        jsMain {
+            dependencies {
+                api project(":micro_utils.common")
+            }
+        }
+        androidMain {
+            dependencies {
+                api libs.kt.coroutines.android
             }
         }
     }

coroutines/compose/build.gradle

@@ -0,0 +1,20 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+    alias(libs.plugins.jb.compose)
+}
+
+apply from: "$mppProjectWithSerializationAndComposePresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api libs.kt.coroutines
+                api project(":micro_utils.coroutines")
+                api project(":micro_utils.common.compose")
+            }
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+package dev.inmo.micro_utils.coroutines.compose
+
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+
+fun <T> Flow<T>.toMutableState(
+    initial: T,
+    scope: CoroutineScope
+): MutableState<T> {
+    val state = mutableStateOf(initial)
+    subscribeSafelyWithoutExceptions(scope) { state.value = it }
+    return state
+}
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun <T> StateFlow<T>.toMutableState(
+    scope: CoroutineScope
+): MutableState<T> = toMutableState(value, scope)
+

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

@@ -0,0 +1,14 @@
+package dev.inmo.micro_utils.coroutines.compose
+
+import androidx.compose.runtime.*
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.job
+import kotlin.coroutines.CoroutineContext
+
+fun Composition.linkWithJob(job: Job) {
+    job.invokeOnCompletion {
+        this@linkWithJob.dispose()
+    }
+}
+
+fun Composition.linkWithContext(coroutineContext: CoroutineContext) = linkWithJob(coroutineContext.job)

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

@@ -0,0 +1,26 @@
+package dev.inmo.micro_utils.coroutines.compose
+
+import androidx.compose.runtime.*
+import dev.inmo.micro_utils.common.compose.linkWithElement
+import kotlinx.coroutines.*
+import org.jetbrains.compose.web.dom.DOMScope
+import org.w3c.dom.Element
+
+suspend fun <TElement : Element> renderComposableAndLinkToContext(
+    root: TElement,
+    monotonicFrameClock: MonotonicFrameClock = DefaultMonotonicFrameClock,
+    content: @Composable DOMScope<TElement>.() -> Unit
+): Composition = org.jetbrains.compose.web.renderComposable(root, monotonicFrameClock, content).apply {
+    linkWithContext(
+        currentCoroutineContext()
+    )
+}
+
+suspend fun <TElement : Element> renderComposableAndLinkToContextAndRoot(
+    root: TElement,
+    monotonicFrameClock: MonotonicFrameClock = DefaultMonotonicFrameClock,
+    content: @Composable DOMScope<TElement>.() -> Unit
+): Composition = org.jetbrains.compose.web.renderComposable(root, monotonicFrameClock, content).apply {
+    linkWithContext(currentCoroutineContext())
+    linkWithElement(root)
+}

coroutines/compose/src/main/AndroidManifest.xml

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

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

@@ -0,0 +1,100 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlin.coroutines.cancellation.CancellationException
+
+private sealed interface AccumulatorFlowStep<T>
+private data class DataRetrievedAccumulatorFlowStep<T>(val data: T) : AccumulatorFlowStep<T>
+private data class SubscribeAccumulatorFlowStep<T>(val channel: Channel<T>) : AccumulatorFlowStep<T>
+private data class UnsubscribeAccumulatorFlowStep<T>(val channel: Channel<T>) : AccumulatorFlowStep<T>
+
+/**
+ * This [Flow] will have behaviour very similar to [SharedFlow], but there are several differences:
+ *
+ * * All unhandled by [FlowCollector] data will not be removed from [AccumulatorFlow] and will be sent to new
+ * [FlowCollector]s until anybody will handle it
+ * * Here there are an [activeData] where data [T] will be stored until somebody will handle it
+ */
+class AccumulatorFlow<T>(
+    sourceDataFlow: Flow<T>,
+    scope: CoroutineScope
+) : AbstractFlow<T>() {
+    private val subscope = scope.LinkedSupervisorScope()
+    private val activeData = ArrayDeque<T>()
+    private val dataMutex = Mutex()
+    private val channelsForBroadcast = mutableListOf<Channel<T>>()
+    private val channelsMutex = Mutex()
+    private val steps = subscope.actor<AccumulatorFlowStep<T>> { step ->
+        when (step) {
+            is DataRetrievedAccumulatorFlowStep -> {
+                if (activeData.firstOrNull() === step.data) {
+                    dataMutex.withLock {
+                        activeData.removeFirst()
+                    }
+                }
+            }
+            is SubscribeAccumulatorFlowStep -> channelsMutex.withLock {
+                channelsForBroadcast.add(step.channel)
+                dataMutex.withLock {
+                    val dataToSend = activeData.toList()
+                    safelyWithoutExceptions {
+                        dataToSend.forEach { step.channel.send(it) }
+                    }
+                }
+            }
+            is UnsubscribeAccumulatorFlowStep -> channelsMutex.withLock {
+                channelsForBroadcast.remove(step.channel)
+            }
+        }
+    }
+    private val subscriptionJob = sourceDataFlow.subscribeSafelyWithoutExceptions(subscope) {
+        dataMutex.withLock {
+            activeData.addLast(it)
+        }
+        channelsMutex.withLock {
+            channelsForBroadcast.forEach { channel ->
+                safelyWithResult {
+                    channel.send(it)
+                }
+            }
+        }
+    }
+
+    override suspend fun collectSafely(collector: FlowCollector<T>) {
+        val channel = Channel<T>(Channel.UNLIMITED, BufferOverflow.SUSPEND)
+        steps.send(SubscribeAccumulatorFlowStep(channel))
+        val result = runCatchingSafely {
+            for (data in channel) {
+                val emitResult = runCatchingSafely {
+                    collector.emit(data)
+                }
+                if (emitResult.isSuccess || emitResult.exceptionOrNull() is CancellationException) {
+                    steps.send(DataRetrievedAccumulatorFlowStep(data))
+                }
+                emitResult.getOrThrow()
+            }
+        }
+        channel.cancel()
+        steps.send(UnsubscribeAccumulatorFlowStep(channel))
+        result.getOrThrow()
+    }
+}
+
+/**
+ * Creates [AccumulatorFlow] using [this] as base [Flow]
+ */
+fun <T> Flow<T>.accumulatorFlow(scope: CoroutineScope): Flow<T> {
+    return AccumulatorFlow(this, scope)
+}
+
+/**
+ * Creates [AccumulatorFlow] using [this] with [receiveAsFlow] to get
+ */
+fun <T> Channel<T>.accumulatorFlow(scope: CoroutineScope): Flow<T> {
+    return receiveAsFlow().accumulatorFlow(scope)
+}

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/Actor.kt

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

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

@@ -0,0 +1,37 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import kotlin.coroutines.*
+
+suspend fun <T> Iterable<Deferred<T>>.awaitFirstWithDeferred(
+    scope: CoroutineScope,
+    cancelOnResult: Boolean = true
+): Pair<Deferred<T>, T> = suspendCoroutine<Pair<Deferred<T>, T>> { continuation ->
+    scope.launch(SupervisorJob()) {
+        val scope = this
+        forEach {
+            scope.launch {
+                continuation.resume(it to it.await())
+                scope.cancel()
+            }
+        }
+    }
+}.also {
+    if (cancelOnResult) {
+        forEach {
+            try {
+                it.cancel()
+            } catch (e: IllegalStateException) {
+                e.printStackTrace()
+            }
+        }
+    }
+}
+
+suspend fun <T> Iterable<Deferred<T>>.awaitFirst(
+    scope: CoroutineScope,
+    cancelOnResult: Boolean = true
+): T = awaitFirstWithDeferred(scope, cancelOnResult).second
+suspend fun <T> Iterable<Deferred<T>>.awaitFirst(
+    cancelOthers: Boolean = true
+): T = awaitFirst(CoroutineScope(coroutineContext), cancelOthers)

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

@@ -1,24 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.channels.*
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.asFlow
-
-@Suppress("FunctionName")
-@Deprecated("Deprecated due to stabilization of SharedFlow and StateFlow")
-fun <T> BroadcastFlow(
-    internalChannelSize: Int = Channel.BUFFERED
-): BroadcastFlow<T> {
-    val channel = BroadcastChannel<T>(internalChannelSize)
-
-    return BroadcastFlow(
-        channel,
-        channel.asFlow()
-    )
-}
-
-@Deprecated("Deprecated due to stabilization of SharedFlow and StateFlow")
-class BroadcastFlow<T> internal constructor(
-    private val channel: BroadcastChannel<T>,
-    private val flow: Flow<T>
-): Flow<T> by flow, SendChannel<T> by channel

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

@@ -1,68 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.channels.BroadcastChannel
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.*
-
-const val defaultBroadcastStateFlowReplayCacheSize = 1
-
-@Deprecated("Deprecated due to stabilization of SharedFlow and StateFlow")
-class BroadcastStateFlow<T> internal constructor(
-    parentFlow: Flow<T>,
-    initial: T,
-    replayCacheSize: Int = defaultBroadcastStateFlowReplayCacheSize,
-    replayScope: CoroutineScope
-) : StateFlow<T>, Flow<T> by parentFlow {
-    private val deque = ArrayDeque<T>(1).also {
-        it.add(initial)
-    }
-    override val replayCache: List<T>
-        get() = deque.toList()
-    override val value: T
-        get() = deque.last()
-
-    init {
-        if (replayCacheSize < 1) {
-            error("Replay cache size can't be less than 1, but was $replayCacheSize")
-        }
-        parentFlow.onEach {
-            deque.addLast(it)
-            if (deque.size > replayCacheSize) {
-                deque.removeFirst()
-            }
-        }.launchIn(replayScope)
-    }
-}
-
-@Deprecated("Deprecated due to stabilization of SharedFlow and StateFlow")
-fun <T> BroadcastChannel<T>.asStateFlow(
-    value: T,
-    scope: CoroutineScope,
-    replayCacheSize: Int = defaultBroadcastStateFlowReplayCacheSize
-): StateFlow<T> = BroadcastStateFlow(asFlow(), value, replayCacheSize, scope)
-
-@Deprecated("Deprecated due to stabilization of SharedFlow and StateFlow")
-fun <T> BroadcastChannel<T?>.asStateFlow(
-    scope: CoroutineScope,
-    replayCacheSize: Int = defaultBroadcastStateFlowReplayCacheSize
-): StateFlow<T?> = asStateFlow(null, scope, replayCacheSize)
-
-@Deprecated("Deprecated due to stabilization of SharedFlow and StateFlow")
-fun <T> broadcastStateFlow(
-    initial: T, scope: CoroutineScope,
-    channelSize: Int = Channel.BUFFERED,
-    replayCacheSize: Int = defaultBroadcastStateFlowReplayCacheSize
-) = BroadcastChannel<T>(
-    channelSize
-).let {
-    it to it.asStateFlow(initial, scope, replayCacheSize)
-}
-
-@Deprecated("Deprecated due to stabilization of SharedFlow and StateFlow")
-fun <T> broadcastStateFlow(
-    scope: CoroutineScope,
-    channelSize: Int = Channel.BUFFERED,
-    replayCacheSize: Int = defaultBroadcastStateFlowReplayCacheSize
-) = broadcastStateFlow<T?>(null, scope, channelSize, replayCacheSize)
-

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

@@ -0,0 +1,85 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+
+class DeferredAction<T, O>(
+    val deferred: Deferred<T>,
+    val callback: suspend (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(
+    scope: CoroutineScope,
+    cancelOnResult: Boolean = true
+): O {
+    return map { it.deferred }.awaitFirstWithDeferred(scope, cancelOnResult).let { result ->
+        first { it.deferred == result.first }.invoke()
+    }
+}
+
+suspend fun <O> invokeFirstOf(
+    scope: CoroutineScope,
+    vararg variants: DeferredAction<*, O>,
+    cancelOnResult: Boolean = true
+): O = variants.toList().invokeFirstOf(scope, cancelOnResult)
+
+suspend fun <T, O> Iterable<Deferred<T>>.invokeOnFirst(
+    scope: CoroutineScope,
+    cancelOnResult: Boolean = true,
+    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/FlowCollectorInvoking.kt

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

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/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]
@@ -16,7 +18,7 @@ inline fun <T> Flow<T>.subscribe(scope: CoroutineScope, noinline block: suspend
  */
 inline fun <T> Flow<T>.subscribeSafely(
     scope: CoroutineScope,
-    noinline onException: ExceptionHandler<Unit> = { throw it },
+    noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
     noinline block: suspend (T) -> Unit
 ) = subscribe(scope) {
     safely(onException) {
@@ -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/FlowsSum.kt

@@ -0,0 +1,8 @@
+@file:Suppress("NOTHING_TO_INLINE")
+
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.merge
+
+inline operator fun <T> Flow<T>.plus(other: Flow<T>) = merge(this, other)

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

@@ -1,30 +1,156 @@
 package dev.inmo.micro_utils.coroutines
 
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.supervisorScope
-
+import kotlinx.coroutines.*
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.coroutineContext
 
 typealias ExceptionHandler<T> = suspend (Throwable) -> T
+
+/**
+ * This instance will be used in all calls of [safely] where exception handler has not been passed
+ */
+var defaultSafelyExceptionHandler: ExceptionHandler<Nothing> = { throw it }
+
+/**
+ * This instance will be used in all calls of [safelyWithoutExceptions] as an exception handler for [safely] call
+ */
+var defaultSafelyWithoutExceptionHandler: ExceptionHandler<Unit> = {
+    try {
+        defaultSafelyExceptionHandler(it)
+    } catch (e: Throwable) {
+         // do nothing
+    }
+}
+
+/**
+ * This key can (and will) be used to get [ContextSafelyExceptionHandler] from [coroutineContext] of suspend functions
+ * and in [ContextSafelyExceptionHandler] for defining of its [CoroutineContext.Element.key]
+ *
+ * @see safelyWithContextExceptionHandler
+ * @see ContextSafelyExceptionHandler
+ */
+object ContextSafelyExceptionHandlerKey : CoroutineContext.Key<ContextSafelyExceptionHandler>
+
+/**
+ * [ExceptionHandler] wrapper which was created to make possible to use [handler] across all coroutines calls
+ *
+ * @see safelyWithContextExceptionHandler
+ * @see ContextSafelyExceptionHandlerKey
+ */
+class ContextSafelyExceptionHandler(
+    val handler: ExceptionHandler<Unit>
+) : CoroutineContext.Element {
+    override val key: CoroutineContext.Key<*>
+        get() = ContextSafelyExceptionHandlerKey
+}
+
+/**
+ * @return [ContextSafelyExceptionHandler] from [coroutineContext] by key [ContextSafelyExceptionHandlerKey] if
+ * exists
+ *
+ * @see ContextSafelyExceptionHandler
+ * @see ContextSafelyExceptionHandlerKey
+ */
+suspend inline fun contextSafelyExceptionHandler() = coroutineContext[ContextSafelyExceptionHandlerKey]
+
+/**
+ * This method will set new [coroutineContext] with [ContextSafelyExceptionHandler]. In case if [coroutineContext]
+ * already contains [ContextSafelyExceptionHandler], [ContextSafelyExceptionHandler.handler] will be used BEFORE
+ * [contextExceptionHandler] in case of exception.
+ *
+ * After all, will be called [withContext] method with created [ContextSafelyExceptionHandler] and block which will call
+ * [safely] method with [safelyExceptionHandler] as onException parameter and [block] as execution block
+ */
+suspend fun <T> safelyWithContextExceptionHandler(
+    contextExceptionHandler: ExceptionHandler<Unit>,
+    safelyExceptionHandler: ExceptionHandler<T> = defaultSafelyExceptionHandler,
+    block: suspend CoroutineScope.() -> T
+): T {
+    val contextSafelyExceptionHandler = contextSafelyExceptionHandler() ?.handler ?.let { oldHandler ->
+        ContextSafelyExceptionHandler {
+            oldHandler(it)
+            contextExceptionHandler(it)
+        }
+    } ?: ContextSafelyExceptionHandler(contextExceptionHandler)
+    return withContext(contextSafelyExceptionHandler) {
+        safely(safelyExceptionHandler, block)
+    }
+}
+
 /**
  * It will run [block] inside of [supervisorScope] to avoid problems with catching of exceptions
  *
+ * Priorities of [ExceptionHandler]s:
+ *
+ * * [onException] In case if custom (will be used anyway if not [defaultSafelyExceptionHandler])
+ * * [CoroutineContext.get] with [SafelyExceptionHandlerKey] as key
+ * * [defaultSafelyExceptionHandler]
+ *
+ * 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
+ *
+ * @see defaultSafelyExceptionHandler
+ * @see safelyWithoutExceptions
+ * @see safelyWithContextExceptionHandler
  */
 suspend inline fun <T> safely(
-    noinline onException: ExceptionHandler<T> = { throw it },
+    noinline onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
     noinline block: suspend CoroutineScope.() -> T
 ): T {
     return try {
         supervisorScope(block)
     } catch (e: Throwable) {
+        coroutineContext[ContextSafelyExceptionHandlerKey] ?.handler ?.invoke(e)
         onException(e)
     }
 }
 
+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)
+
 /**
- * Shortcut for [safely] without exception handler (instead of this you will receive null as a result)
+ * 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, by default always returns null)
  */
 suspend inline fun <T> safelyWithoutExceptions(
+    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
     noinline block: suspend CoroutineScope.() -> T
-): T? = safely({ null }, block)
+): T? = safely(onException, block)
+
+suspend inline fun <T> runCatchingSafelyWithoutExceptions(
+    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
+    noinline block: suspend CoroutineScope.() -> T
+): Result<T?> = runCatching {
+    safelyWithoutExceptions(onException, block)
+}
+
+inline fun CoroutineScope(
+    context: CoroutineContext,
+    noinline defaultExceptionsHandler: ExceptionHandler<Unit>
+) = CoroutineScope(
+    context + ContextSafelyExceptionHandler(defaultExceptionsHandler)
+)

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/jsMain/kotlin/dev.inmo.micro_utils.coroutines/ByteArrayBlob.kt

@@ -0,0 +1,10 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.await
+import org.khronos.webgl.Int8Array
+import org.w3c.fetch.Response
+import org.w3c.files.Blob
+
+suspend fun Blob.toByteArray() = Int8Array(
+    Response(this).arrayBuffer().await()
+) as ByteArray

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

@@ -0,0 +1,28 @@
+package dev.inmo.micro_utils.coroutines
+
+import dev.inmo.micro_utils.common.onRemoved
+import dev.inmo.micro_utils.common.onVisibilityChanged
+import kotlinx.coroutines.flow.*
+import org.w3c.dom.Element
+
+fun Element.visibilityFlow(): Flow<Boolean> = channelFlow {
+    var previousData: Boolean? = null
+
+    val observer = onVisibilityChanged { intersectionRatio, _ ->
+        val currentData = intersectionRatio > 0
+        if (currentData != previousData) {
+            trySend(currentData)
+        }
+        previousData = currentData
+    }
+
+    val removeObserver = onRemoved {
+        observer.disconnect()
+        close()
+    }
+
+    invokeOnClose {
+        observer.disconnect()
+        removeObserver.disconnect()
+    }
+}

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

@@ -0,0 +1,42 @@
+package dev.inmo.micro_utils.coroutines
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.selectFile
+import kotlinx.coroutines.CompletableDeferred
+import org.w3c.dom.HTMLInputElement
+
+suspend fun selectFileOrThrow(
+    inputSetup: (HTMLInputElement) -> Unit = {}
+): MPPFile {
+    val result = CompletableDeferred<MPPFile>()
+
+    selectFile(
+        inputSetup,
+        {
+            result.completeExceptionally(it)
+        }
+    ) {
+        result.complete(it)
+    }
+
+    return result.await()
+}
+
+suspend fun selectFileOrNull(
+    inputSetup: (HTMLInputElement) -> Unit = {},
+    onFailure: (Throwable) -> Unit = {}
+): MPPFile? {
+    val result = CompletableDeferred<MPPFile?>()
+
+    selectFile(
+        inputSetup,
+        {
+            result.complete(null)
+            onFailure(it)
+        }
+    ) {
+        result.complete(it)
+    }
+
+    return result.await()
+}

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

@@ -0,0 +1,26 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+
+fun <T> CoroutineScope.launchSynchronously(block: suspend CoroutineScope.() -> T): T {
+    var result: Result<T>? = null
+    val objectToSynchronize = Object()
+    synchronized(objectToSynchronize) {
+        launch {
+            result = safelyWithResult(block)
+        }.invokeOnCompletion {
+            synchronized(objectToSynchronize) {
+                objectToSynchronize.notifyAll()
+            }
+        }
+        while (result == null) {
+            objectToSynchronize.wait()
+        }
+    }
+    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/AwaitFirstTests.kt

@@ -0,0 +1,34 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class AwaitFirstTests {
+    private fun CoroutineScope.createTestDeferred(value: Int, wait: Long = 100000) = async(start = CoroutineStart.LAZY) { delay(wait); value }
+    @Test
+    fun testThatAwaitFirstIsWorkingCorrectly() {
+        val baseScope = CoroutineScope(Dispatchers.Default)
+        val resultDeferred = baseScope.createTestDeferred(-1, 0)
+        val deferreds = listOf(
+            baseScope.async { createTestDeferred(0) },
+            baseScope.async { createTestDeferred(1) },
+            baseScope.async { createTestDeferred(2) },
+            resultDeferred
+        )
+        val controlJob = baseScope.launch {
+            delay(1000000)
+        }
+        val result = baseScope.launchSynchronously {
+            val result = deferreds.awaitFirst(baseScope)
+
+            assertTrue(baseScope.isActive)
+            assertTrue(controlJob.isActive)
+
+            result
+        }
+        assertEquals(baseScope.launchSynchronously { resultDeferred.await() }, result)
+        assertTrue(deferreds.all { it == resultDeferred || it.isCancelled })
+    }
+}

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

@@ -0,0 +1,26 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class DoWithFirstTests {
+    @Test
+    fun testHandleOneOf() {
+        val scope = CoroutineScope(Dispatchers.Default)
+        val happenedDeferreds = mutableListOf<Int>()
+        val deferredWhichMustHappen = (-1).asDeferred
+        scope.launchSynchronously {
+            scope.launch {
+                ((0 until 100).map {
+                    DeferredAction(
+                        scope.async { delay(10000); it },
+                        happenedDeferreds::add
+                    )
+                } + DeferredAction(deferredWhichMustHappen, happenedDeferreds::add)).invokeFirstOf(scope)
+            }.join()
+        }
+        assertEquals(1, happenedDeferreds.size)
+        assertEquals(scope.launchSynchronously { deferredWhichMustHappen.await() }, happenedDeferreds.first())
+    }
+}

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

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

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

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

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/AndroidManifest.xml

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

crypto/build.gradle

@@ -0,0 +1,30 @@
+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.common")
+            }
+        }
+        jsMain {
+            dependencies {
+                api npm("crypto-js", "$crypto_js_version")
+            }
+        }
+    }
+}
+
+android {
+    sourceSets {
+        main {
+            java.srcDirs += [ "src/jvmMain/kotlin" ]
+        }
+    }
+}

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

@@ -0,0 +1,77 @@
+package dev.inmo.micro_utils.crypto
+
+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
+
+typealias EncodedBase64String = String
+typealias EncodedByteArray = ByteArray
+
+fun SourceString.encodeBase64String(): EncodedBase64String = encodeToByteArray().encodeBase64String()
+fun SourceString.encodeBase64(): EncodedByteArray = encodeToByteArray().encodeBase64()
+
+fun SourceBytes.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
+    }
+}
+fun SourceBytes.encodeBase64(): EncodedByteArray = encodeBase64String().encodeToByteArray()
+
+fun EncodedBase64String.decodeBase64(): SourceBytes = dropLastWhile { it == BASE64_PAD }.encodeToByteArray().decodeBase64()
+fun EncodedBase64String.decodeBase64String(): SourceString = decodeBase64().decodeToString()
+
+fun EncodedByteArray.decodeBase64(): SourceBytes {
+    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()
+}
+fun EncodedByteArray.decodeBase64String(): SourceString = decodeBase64().decodeToString()

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

@@ -0,0 +1,11 @@
+package dev.inmo.micro_utils.crypto
+
+/**
+ * This typealias shows that corresponding [ByteArray] is an raw data
+ */
+typealias SourceBytes = ByteArray
+/**
+ * This typealias shows that corresponding [String] is an raw data
+ */
+typealias SourceString = String
+