improve SkeletonAnimation

0.12.11

.github/workflows/build.yml

@@ -0,0 +1,28 @@
+
+name: Build
+on: [push]
+jobs:
+  build:
+    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 }}

.github/workflows/dokka_push.yml

@@ -10,12 +10,12 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 1.8
-      - name: Fix android 31.0.0 dx
+          java-version: 11
+      - name: Fix android 32.0.0 dx
         continue-on-error: true
-        run: cd /usr/local/lib/android/sdk/build-tools/31.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
+        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
+        run: ./gradlew build && ./gradlew dokkaHtml
       - name: Publish KDocs
         uses: peaceiris/actions-gh-pages@v3
         with:

.github/workflows/packages_push.yml

@@ -1,28 +0,0 @@
-
-name: Publish package to GitHub Packages
-on: [push]
-jobs:
-  publishing:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v1
-        with:
-          java-version: 1.8
-      - name: Fix android 31.0.0 dx
-        continue-on-error: true
-        run: cd /usr/local/lib/android/sdk/build-tools/31.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 -x signJsPublication -x signJvmPublication -x signKotlinMultiplatformPublication -x signAndroidDebugPublication -x signAndroidReleasePublication -x signKotlinMultiplatformPublication
-        env:
-          GITHUBPACKAGES_USER: ${{ github.actor }}
-          GITHUBPACKAGES_PASSWORD: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -11,5 +11,6 @@ out/
 
 secret.gradle
 local.properties
+kotlin-js-store
 
 publishing.sh

CHANGELOG.md

@@ -1,5 +1,542 @@
 # Changelog
 
+## 0.12.12
+
+* `Common`:
+  * `Compose`:
+    * `JS`:
+      * Add `SkeletonAnimation` stylesheet
+
+## 0.12.11
+
+* `Repos`:
+    * `Cache`:
+        * Override `KeyValue` cache method `values`
+
+## 0.12.10
+
+* `Repos`:
+    * `Cache`:
+        * Hotfix in key values `get`
+
+## 0.12.9
+
+* `Versions`:
+  * `Klock`: `3.0.0` -> `3.1.0`
+* `Repos`:
+    * `Cache`:
+      * Fixes in key values cache
+
+## 0.12.8
+
+* `Versions`:
+    * `Ktor`: `2.1.0` -> `2.1.1`
+    * `Compose`: `1.2.0-alpha01-dev764` -> `1.2.0-alpha01-dev774`
+* `Ktor`:
+  * `Client`:
+    * New extension `HttpClient#bodyOrNull` which returns `null` in case when server responded with `No Content` (204)
+  * `Server`:
+    * New extension `ApplicationCall#respondOrNoContent` which responds `No Content` (204) when passed data is null
+
+## 0.12.7
+
+* `Repos`:
+  * `Cache`:
+    * Force `WriteCRUDCacheRepo` to subscribe on new and updated objects of parent repo
+* `Pagination`:
+  * New function `changeResultsUnchecked(Pagination)`
+
+## 0.12.6
+
+* `MimeeTypes>`:
+  * Fixed absence of `image/*` in known mime types
+
+## 0.12.5
+
+* `Repos`:
+  * `Exposed`:
+    * Fixes in `paginate` extensions
+
+## 0.12.4
+
+* `Versions`:
+    * `Kotlin`: `1.7.0` -> `1.7.10`
+    * `Compose`: `1.2.0-alpha01-dev755` -> `1.2.0-alpha01-dev764`
+
+## 0.12.3
+
+* `Repos`:
+  * `Exposed`:
+    * Add abstract exposed variants of `KeyValue` and `KeyValues` repos
+    * Add new extension `Query#selectPaginated`
+
+## 0.12.2
+
+* `Versions`:
+  * `Serialization`: `1.4.0-RC` -> `1.4.0`
+  * `Compose`: `1.2.0-alpha01-dev753` -> `1.2.0-alpha01-dev755`
+
+## 0.12.1
+
+* `Versions`:
+  * `Ktor`: `2.0.3` -> `2.1.0`
+
+## 0.12.0
+
+**OLD DEPRECATIONS HAVE BEEN REMOVED**
+
+**MINIMAL ANDROID API HAS BEEN ENLARGED UP TO API 21 (Android 5.0)**
+
+* `Versions`
+  * `Kotlin`: `1.6.21` -> `1.7.0`
+  * `Coroutines`: `1.6.3` -> `1.6.4`
+  * `Exposed`: `0.38.2` -> `0.39.2`
+  * `Compose`: `1.2.0-alpha01-dev729` -> `1.2.0-alpha01-dev753`
+  * `Klock`: `2.7.0` -> `3.0.0`
+  * `uuid`: `0.4.1` -> `0.5.0`
+  * `Android Core KTX`: `1.7.0` -> `1.8.0`
+  * `Android AppCompat`: `1.4.1` -> `1.4.2`
+* `Ktor`:
+  * All previously standard functions related to work with binary data by default have been deprecated
+
+## 0.11.14
+
+* `Pagination`:
+    * `PaginationResult` got new field `objectsNumber` which by default is a times between `pagesNumber` and `size`
+
+## 0.11.13
+
+* `Versions`:
+    * `Coroutines`: `1.6.3` -> `1.6.4`
+    * `Compose`: `1.2.0-alpha01-dev629` -> `1.2.0-alpha01-dev731`
+
+## 0.11.12
+
+* `Repos`:
+  * `Common`:
+    * `JVM`:
+      * Fixes in `ReadFileKeyValueRepo` methods (`values`/`keys`)
+
+## 0.11.11
+
+* `Crypto`:
+  * `hmacSha256` has been deprecated
+* `Ktor`:
+  * `Client`:
+    * `BodyPair` has been deprecated
+* `Repos`:
+    * `Cache`:
+      * New interface `CacheRepo`
+      * New interface `FullCacheRepo`
+      * `actualize*` methods inside of full cache repos now open for overriding
+
+## 0.11.10
+
+* `Repos`:
+  * `Cache`:
+    * `KVCache` has been replaced to the package `dev.inmo.micro_utils.repos.cache`
+    * `SimpleKVCache` has been replaced to the package `dev.inmo.micro_utils.repos.cache`
+    * New `KVCache` subtype - `FullKVCache`
+    * Add `Full*` variants of standard repos
+    * Add `cached`/`caching` (for write repos) extensions for all standard types of repos
+
+## 0.11.9
+
+* `Versions`
+    * `Coroutines`: `1.6.1` -> `1.6.3`
+    * `Ktor`: `2.0.2` -> `2.0.3`
+    * `Compose`: `1.2.0-alpha01-dev686` -> `1.2.0-alpha01-dev729`
+
+## 0.11.8
+
+* `Repos`:
+    * `Common`:
+        * Fixes in `FileKeyValueRepo`
+
+## 0.11.7
+
+* `Common`:
+  * New abstractions `SimpleMapper` and `SimpleSuspendableMapper`
+* `Repos`:
+  * `Common`:
+    * Add mappers for `CRUDRepo`
+
+## 0.11.6
+
+* `FSM`:
+  * `Common`
+    * Several fixes related to the jobs handling
+
+## 0.11.5
+
+* `Coroutines`:
+  * `Compose`:
+    * Add extension `StateFlow#asMutableComposeListState` and `StateFlow#asComposeList`
+    * Add extension `StateFlow#asMutableComposeState`/`StateFlow#asComposeState`
+
+## 0.11.4
+
+**THIS VERSION HAS BEEN BROKEN, DO NOT USE IT**
+
+## 0.11.3
+
+* `Ktor`:
+    * Support of `WebSockets` has been improved
+      * `Client`:
+        * New extensions: `HttpClient#openBaseWebSocketFlow`, `HttpClient#openWebSocketFlow`, `HttpClient#openSecureWebSocketFlow`
+
+## 0.11.2
+
+* `Ktor`:
+  * Support of `WebSockets` has been improved and added fixes inside of clients
+
+## 0.11.1
+
+* `Repos`
+  * `Ktor`
+    * In `configureReadKeyValueRepoRoutes` and `configureReadKeyValuesRepoRoutes` configurators fixed requiring of `reversed` property
+
+## 0.11.0
+
+* `Versions`
+    * `UUID`: `0.4.0` -> `0.4.1`
+* `Ktor`
+  * `Client`:
+    * New extension fun `HttpResponse#throwOnUnsuccess`
+    * All old functions, classes and extensions has been rewritten with new ktor-way with types info and keeping `ContentNegotiation` in mind
+  * `Server`:
+      * All old functions, classes and extensions has been rewritten with new ktor-way with types info and keeping `ContentNegotiation` in mind
+* `Repos`
+  * `Ktor`:
+    * Fully rewritten work with all declared repositories
+    * All old functions, classes and extensions has been rewritten with new ktor-way with types info and keeping `ContentNegotiation` in mind
+
+## 0.10.8
+
+* `Common`
+    * Add `Element.isOverflow*` extension properties
+
+## 0.10.7
+
+* `Pagination`:
+    * Now it is possible to use `doForAll*` and `getForAll` functions in non suspend places
+
+## 0.10.6
+
+* `Versions`
+    * `Ktor`: `2.0.1` -> `2.0.2`
+* `Common`
+    * `JS`:
+        * Add `ResizeObserver` functionality
+
+## 0.10.5
+
+* `Versions`
+    * `Compose`: `1.2.0-alpha01-dev683` -> `1.2.0-alpha01-dev686`
+* `Repos`
+    * `Android`:
+        * New function `SharedPreferencesKeyValueRepo`
+* `FSM`
+    * Add `StateHandlingErrorHandler` and opportunity to handle states handling errors
+
+## 0.10.4
+
+* `Versions`:
+    * `Serialization`: `1.3.2` -> `1.3.3`
+
+## 0.10.3
+
+* `Versions`:
+    * `Compose`: `1.2.0-alpha01-dev682` -> `1.2.0-alpha01-dev683`
+* `Coroutines`:
+    * Fixes in `AccumulatorFlow`
+
+## 0.10.2
+
+* `Versions`:
+    * `Compose`: `1.2.0-alpha01-dev675` -> `1.2.0-alpha01-dev682`
+
+## 0.10.1
+
+* `Versions`:
+    * `Ktor`: `2.0.0` -> `2.0.1`
+* `Crypto`:
+    * Add `hmacSha256`
+    * Add `hex`
+
+## 0.10.0
+
+* `Versions`:
+    * `Kotlin`: `1.6.10` -> `1.6.21`
+    * `Compose`: `1.1.1` -> `1.2.0-alpha01-dev675`
+    * `Exposed`: `0.37.3` -> `0.38.2`
+    * `Ktor`: `1.6.8` -> `2.0.0`
+    * `Dokka`: `1.6.10` -> `1.6.21`
+
+## 0.9.24
+
+* `Ktor`:
+    * `Common`:
+        * New extension fun `MPPFile#input`
+
+## 0.9.23
+
+* `Repos`:
+    * `Exposed`:
+        * New property `ExposedRepo#selectAll` to retrieve all the rows in the table
+
+## 0.9.22
+
+* `Ktor`:
+    * `Server`:
+        * Now `createKtorServer` fun is fully customizable
+
+## 0.9.21
+
+* `Repos`:
+    * `Exposed`:
+        * fixes in `AbstractExposedWriteCRUDRepo`
+
+## 0.9.20
+
+* `Repos`:
+    * `Common`:
+        * Fixes in `OneToManyAndroidRepo`
+        * New `CursorIterator`
+
+## 0.9.19
+
+* `Versions`:
+    * `Coroutines`: `1.6.0` -> `1.6.1`
+* `Repos`:
+    * `Exposed`:
+        * Fixes in `ExposedStandardVersionsRepoProxy`
+
+## 0.9.18
+
+* `Common`
+    * New extensions for `Element`: `Element#onActionOutside` and `Element#onClickOutside`
+
+## 0.9.17
+
+* `Common`:
+    * New extensions `Element#onVisibilityChanged`, `Element#onVisible` and `Element#onInvisible`
+* `Coroutines`:
+    * New extension `Element.visibilityFlow()`
+* `FSM`:
+    * Now it is possible to resolve conflicts on `startChain`
+
+## 0.9.16
+
+* `Versions`:
+    * `Klock`: `2.6.3` -> `2.7.0`
+* `Common`:
+    * New extension `Node#onRemoved`
+    * `Compose`:
+        * New extension `Composition#linkWithRoot` for removing of composition with root element
+* `Coroutines`:
+    * `Compose`:
+        * New function `renderComposableAndLinkToContextAndRoot` with linking of composition to root element
+
+## 0.9.15
+
+* `FSM`:
+    * Rename `DefaultUpdatableStatesMachine#compare` to `DefaultUpdatableStatesMachine#shouldReplaceJob`
+    * `DefaultStatesManager` now is extendable
+    * `DefaultStatesMachine` will stop all jobs of states which was removed from `statesManager`
+
+## 0.9.14
+
+* `Versions`:
+    * `Klock`: `2.6.2` -> `2.6.3`
+    * `Ktor`: `1.6.7` -> `1.6.8`
+* `Ktor`:
+    * Add temporal files uploading functionality (for clients to upload and for server to receive)
+
+## 0.9.13
+
+* `Versions`:
+    * `Compose`: `1.1.0` -> `1.1.1`
+
+## 0.9.12
+
+* `Common`:
+    * `JS`:
+        * New function `openLink`
+        * New function `selectFile`
+        * New function `triggerDownloadFile`
+    * `Compose`:
+        * Created :)
+        * `Common`:
+            * `DefaultDisposableEffectResult` as a default realization of `DisposableEffectResult`
+        * `JS`:
+            * `openLink` on top of `openLink` with `String` target from common
+* `Coroutines`:
+    * `Compose`:
+        * `Common`:
+            * New extension `Flow.toMutableState`
+            * New extension `StateFlow.toMutableState`
+        * `JS`:
+            * New function `selectFileOrThrow` on top of `selectFile` from `common`
+            * New function `selectFileOrNull` on top of `selectFile` from `common`
+
+## 0.9.11
+
+* `Versions`:
+    * `Klock`: `2.6.1` -> `2.6.2`
+* `Coroutines`:
+    * `Compose`:
+        * Created :)
+        * New extensions and function:
+            * `Composition#linkWithJob`
+            * `Composition#linkWithContext`
+            * `renderComposableAndLinkToContext`
+
+## 0.9.10
+
+* `Versions`:
+    * `Klock`: `2.5.2` -> `2.6.1`
+* Ktor:
+    * Client:
+        * New function `UnifiedRequester#createStandardWebsocketFlow` without `checkReconnection` arg
+    * Server:
+        * Now it is possible to filter data in `Route#includeWebsocketHandling`
+        * Callback in `Route#includeWebsocketHandling` and dependent methods is `suspend` since now
+        * Add `URLProtocol` support in `Route#includeWebsocketHandling` and dependent methods
+
+## 0.9.9
+
+* `Versions`:
+    * `Klock`: `2.5.1` -> `2.5.2`
+* `Common`:
+    * Add new diff tool - `applyDiff`
+    * Implementation of `IntersectionObserver` in JS part (copypaste of [this](https://youtrack.jetbrains.com/issue/KT-43157#focus=Comments-27-4498582.0-0) comment)
+
+## 0.9.8
+
+* `Versions`:
+    * `Exposed`: `0.37.2` -> `0.37.3`
+    * `Klock`: `2.4.13` -> `2.5.1`
+    * `AppCompat`: `1.4.0` -> `1.4.1`
+
+## 0.9.7
+
+* `Repos`:
+    * `Exposed`:
+        * Fix in `ExposedOneToManyKeyValueRepo` - now it will not use `insertIgnore`
+* `Ktor`:
+    * `Server`:
+        * `Route#includeWebsocketHandling` now will check that `WebSockets` feature and install it if not
+
+## 0.9.6
+
+* `Repos`:
+    * `Exposed`:
+        * Fix in `ExposedOneToManyKeyValueRepo` - now it will not use `deleteIgnoreWhere`
+
+## 0.9.5
+
+* `Versions`:
+    * `Klock`: `2.4.12` -> `2.4.13`
+
+## 0.9.4
+
+* `Pagination`:
+    * `Common`:
+        * Add several `optionallyReverse` functions
+* `Common`:
+    * Changes in `Either`:
+        * Now `Either` uses `optionalT1` and `optionalT2` as main properties
+        * `Either#t1` and `Either#t2` are deprecated
+        * New extensions `Either#mapOnFirst` and `Either#mapOnSecond`
+
+## 0.9.3
+
+* `Versions`:
+    * `UUID`: `0.3.1` -> `0.4.0`
+
+## 0.9.2
+
+* `Versions`:
+    * `Klock`: `2.4.10` -> `2.4.12`
+
+## 0.9.1
+
+* `Repos`:
+    * `Exposed`:
+        * Default realizations of standard interfaces for exposed DB are using public fields for now:
+            * `ExposedReadKeyValueRepo`
+            * `ExposedReadOneToManyKeyValueRepo`
+            * `ExposedStandardVersionsRepoProxy`
+        * New typealiases for one to many exposed realizations:
+            * `ExposedReadKeyValuesRepo`
+            * `ExposedKeyValuesRepo`
+
+## 0.9.0
+
+* `Versions`:
+    * `Kotlin`: `1.5.31` -> `1.6.10`
+    * `Coroutines`: `1.5.2` -> `1.6.0`
+    * `Serialization`: `1.3.1` -> `1.3.2`
+    * `Exposed`: `0.36.2` -> `0.37.2`
+    * `Ktor`: `1.6.5` -> `1.6.7`
+    * `Klock`: `2.4.8` -> `2.4.10`
+
+## 0.8.9
+
+* `Ktor`:
+    * `Server`:
+        * Fixes in `uniloadMultipart`
+    * `Client`:
+        * Fixes in `unimultipart`
+* `FSM`:
+    * Fixes in `DefaultUpdatableStatesMachine`
+
+## 0.8.8
+
+* `Versions`:
+    * `AppCompat`: `1.3.1` -> `1.4.0`
+    * Android Compile SDK: `31.0.0` -> `32.0.0`
+* `FSM`:
+    * `DefaultStatesMachine` now is extendable
+    * New type `UpdatableStatesMachine` with default realization`DefaultUpdatableStatesMachine`
+
+## 0.8.7
+
+* `Ktor`:
+    * `Client`:
+        * `UnifiedRequester` now have no private fields
+        * Add preview work with multipart
+    * `Server`
+        * `UnifiedRouter` now have no private fields
+        * Add preview work with multipart
+
+## 0.8.6
+
+* `Common`:
+    * `Either` extensions `onFirst` and `onSecond` now accept not `crossinline` callbacks
+    * All `joinTo` now accept not `crossinline` callbacks
+
+## 0.8.5
+
+* `Common`:
+    * `repeatOnFailure`
+
+## 0.8.4
+
+* `Ktor`:
+    * `Server`:
+        * Several new `createKtorServer`
+
+## 0.8.3
+
+* `Common`:
+    * Ranges intersection functionality
+    * New type `Optional`
+* `Pagination`:
+    * `Pagination` now extends `ClosedRange<Int>`
+    * `Pagination` intersection functionality
+
 ## 0.8.2
 
 * `Versions`:

android/alerts/common/build.gradle

@@ -10,7 +10,7 @@ kotlin {
     sourceSets {
         androidMain {
             dependencies {
-                api "androidx.appcompat:appcompat-resources:$appcompat_version"
+                api libs.android.appCompat.resources
             }
         }
     }

android/recyclerview/build.gradle

@@ -10,13 +10,13 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
+                api libs.kt.coroutines
                 api project(":micro_utils.common")
             }
         }
         androidMain {
             dependencies {
-                api "androidx.recyclerview:recyclerview:$androidx_recycler_version"
+                api libs.android.recyclerView
             }
         }
     }

build.gradle

@@ -7,12 +7,12 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.1.3'
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
-        classpath "com.getkeepsafe.dexcount:dexcount-gradle-plugin:$dexcount_version"
-        classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
-        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_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
     }
 }
 
@@ -21,6 +21,7 @@ allprojects {
         mavenLocal()
         mavenCentral()
         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

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

@@ -0,0 +1,43 @@
+package dev.inmo.micro_utils.common.compose
+
+import org.jetbrains.compose.web.css.*
+
+object SkeletonAnimation : StyleSheet() {
+    val skeletonKeyFrames: CSSNamedKeyframes by keyframes {
+        to { backgroundPosition("-20% 0") }
+    }
+
+    fun CSSBuilder.includeSkeletonStyle(
+        duration: CSSSizeValue<out CSSUnitTime> = 2.s,
+        timingFunction: AnimationTimingFunction = AnimationTimingFunction.EaseInOut,
+        iterationCount: Int? = null,
+        direction: AnimationDirection = AnimationDirection.Normal,
+        keyFrames: CSSNamedKeyframes = skeletonKeyFrames,
+        hideChildren: Boolean = true,
+        hideText: Boolean = hideChildren
+    ) {
+        backgroundImage("linear-gradient(110deg, rgb(236, 236, 236) 40%, rgb(245, 245, 245) 50%, rgb(236, 236, 236) 65%)")
+        backgroundSize("200% 100%")
+        backgroundPosition("180% 0")
+        animation(keyFrames) {
+            duration(duration)
+            timingFunction(timingFunction)
+            iterationCount(iterationCount)
+            direction(direction)
+        }
+        if (hideText) {
+            property("color", "${Color.transparent} !important")
+        }
+
+        if (hideChildren) {
+            child(self, universal) style {
+                property("visibility", "hidden")
+            }
+        }
+    }
+
+    val skeleton by style {
+        includeSkeletonStyle()
+    }
+}
+

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

@@ -1,3 +1,5 @@
+@file:Suppress("OPT_IN_IS_NOT_ENABLED")
+
 package dev.inmo.micro_utils.common
 
 @RequiresOptIn(

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

@@ -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
                 }
             )
@@ -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 -> {
@@ -153,3 +157,22 @@ inline fun <T> StrictDiff(old: Iterable<T>, new: Iterable<T>) = old.calculateDif
 inline fun <T> Iterable<T>.calculateStrictDiff(
     other: Iterable<T>
 ) = calculateDiff(other, strictComparison = true)
+
+/**
+ * This method call [calculateDiff] with strict mode [strictComparison] and then apply differences to [this]
+ * mutable list
+ */
+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

@@ -1,3 +1,5 @@
+@file:Suppress("unused", "NOTHING_TO_INLINE")
+
 package dev.inmo.micro_utils.common
 
 import kotlinx.serialization.*
@@ -6,7 +8,7 @@ import kotlinx.serialization.descriptors.*
 import kotlinx.serialization.encoding.*
 
 /**
- * Realization of this interface will contains at least one not null - [t1] or [t2]
+ * Realization of this interface will contains at least one not null - [optionalT1] or [optionalT2]
  *
  * @see EitherFirst
  * @see EitherSecond
@@ -14,26 +16,25 @@ import kotlinx.serialization.encoding.*
  * @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 t1: T1?
-    val t2: T2?
+    val optionalT1: Optional<T1>
+    val optionalT2: Optional<T2>
 
-    companion object {
-        fun <T1, T2> serializer(
-            t1Serializer: KSerializer<T1>,
-            t2Serializer: KSerializer<T2>,
-        ): KSerializer<Either<T1, T2>> = EitherSerializer(t1Serializer, t2Serializer)
-    }
+    val t1OrNull: T1?
+        get() = optionalT1.dataOrNull()
+    val t2OrNull: T2?
+        get() = optionalT2.dataOrNull()
 }
 
 class EitherSerializer<T1, T2>(
     t1Serializer: KSerializer<T1>,
     t2Serializer: KSerializer<T2>,
 ) : KSerializer<Either<T1, T2>> {
-    @ExperimentalSerializationApi
-    @InternalSerializationApi
+    @OptIn(InternalSerializationApi::class, ExperimentalSerializationApi::class)
     override val descriptor: SerialDescriptor = buildSerialDescriptor(
         "TypedSerializer",
         SerialKind.CONTEXTUAL
@@ -44,8 +45,6 @@ class EitherSerializer<T1, T2>(
     private val t1EitherSerializer = EitherFirst.serializer(t1Serializer, t2Serializer)
     private val t2EitherSerializer = EitherSecond.serializer(t1Serializer, t2Serializer)
 
-    @ExperimentalSerializationApi
-    @InternalSerializationApi
     override fun deserialize(decoder: Decoder): Either<T1, T2> {
         return decoder.decodeStructure(descriptor) {
             var type: String? = null
@@ -77,8 +76,6 @@ class EitherSerializer<T1, T2>(
     }
 
 
-    @ExperimentalSerializationApi
-    @InternalSerializationApi
     override fun serialize(encoder: Encoder, value: Either<T1, T2>) {
         encoder.encodeStructure(descriptor) {
             when (value) {
@@ -96,25 +93,25 @@ class EitherSerializer<T1, T2>(
 }
 
 /**
- * This type [Either] will always have not nullable [t1]
+ * This type [Either] will always have not nullable [optionalT1]
  */
 @Serializable
 data class EitherFirst<T1, T2>(
-    override val t1: T1
+    val t1: T1
 ) : Either<T1, T2> {
-    override val t2: T2?
-        get() = null
+    override val optionalT1: Optional<T1> = t1.optional
+    override val optionalT2: Optional<T2> = Optional.absent()
 }
 
 /**
- * This type [Either] will always have not nullable [t2]
+ * This type [Either] will always have not nullable [optionalT2]
  */
 @Serializable
 data class EitherSecond<T1, T2>(
-    override val t2: T2
+    val t2: T2
 ) : Either<T1, T2> {
-    override val t1: T1?
-        get() = null
+    override val optionalT1: Optional<T1> = Optional.absent()
+    override val optionalT2: Optional<T2> = t2.optional
 }
 
 /**
@@ -127,23 +124,35 @@ inline fun <T1, T2> Either.Companion.first(t1: T1): Either<T1, T2> = EitherFirst
 inline fun <T1, T2> Either.Companion.second(t2: T2): Either<T1, T2> = EitherSecond(t2)
 
 /**
- * Will call [block] in case when [Either.t1] of [this] is not null
+ * Will call [block] in case when [this] is [EitherFirst]
  */
-inline fun <T1, T2, E : Either<T1, T2>> E.onFirst(crossinline block: (T1) -> Unit): E {
-    val t1 = t1
-    t1 ?.let(block)
+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 [Either.t2] of [this] is not null
+ * Will call [block] in case when [this] is [EitherSecond]
  */
-inline fun <T1, T2, E : Either<T1, T2>> E.onSecond(crossinline block: (T2) -> Unit): E {
-    val t2 = t2
-    t2 ?.let(block)
+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)

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

@@ -1,10 +1,10 @@
 package dev.inmo.micro_utils.common
 
 inline fun <I, R> Iterable<I>.joinTo(
-    crossinline separatorFun: (I) -> R?,
+    separatorFun: (I) -> R?,
     prefix: R? = null,
     postfix: R? = null,
-    crossinline transform: (I) -> R?
+    transform: (I) -> R?
 ): List<R> {
     val result = mutableListOf<R>()
     val iterator = iterator()
@@ -29,11 +29,11 @@ inline fun <I, R> Iterable<I>.joinTo(
     separator: R? = null,
     prefix: R? = null,
     postfix: R? = null,
-    crossinline transform: (I) -> R?
+    transform: (I) -> R?
 ): List<R> = joinTo({ separator }, prefix, postfix, transform)
 
 inline fun <I> Iterable<I>.joinTo(
-    crossinline separatorFun: (I) -> I?,
+    separatorFun: (I) -> I?,
     prefix: I? = null,
     postfix: I? = null
 ): List<I> = joinTo<I, I>(separatorFun, prefix, postfix) { it }
@@ -45,15 +45,15 @@ inline fun <I> Iterable<I>.joinTo(
 ): List<I> = joinTo<I>({ separator }, prefix, postfix)
 
 inline fun <I, reified R> Array<I>.joinTo(
-    crossinline separatorFun: (I) -> R?,
+    separatorFun: (I) -> R?,
     prefix: R? = null,
     postfix: R? = null,
-    crossinline transform: (I) -> R?
+    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,
-    crossinline transform: (I) -> R?
+    transform: (I) -> R?
 ): Array<R> = asIterable().joinTo(separator, prefix, postfix, transform).toTypedArray()

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

@@ -23,11 +23,12 @@ value class FileName(val string: String) {
 }
 
 
-@PreviewFeature
 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/Mapper.kt

@@ -0,0 +1,53 @@
+package dev.inmo.micro_utils.common
+
+import kotlin.jvm.JvmName
+
+interface SimpleMapper<T1, T2> {
+    fun convertToT1(from: T2): T1
+    fun convertToT2(from: T1): T2
+}
+
+@JvmName("convertFromT2")
+fun <T1, T2> SimpleMapper<T1, T2>.convert(from: T2) = convertToT1(from)
+@JvmName("convertFromT1")
+fun <T1, T2> SimpleMapper<T1, T2>.convert(from: T1) = convertToT2(from)
+
+class SimpleMapperImpl<T1, T2>(
+    private val t1: (T2) -> T1,
+    private val t2: (T1) -> T2,
+) : SimpleMapper<T1, T2> {
+    override fun convertToT1(from: T2): T1 = t1.invoke(from)
+
+    override fun convertToT2(from: T1): T2 = t2.invoke(from)
+}
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun <T1, T2> simpleMapper(
+    noinline t1: (T2) -> T1,
+    noinline t2: (T1) -> T2,
+) = SimpleMapperImpl(t1, t2)
+
+interface SimpleSuspendableMapper<T1, T2> {
+    suspend fun convertToT1(from: T2): T1
+    suspend fun convertToT2(from: T1): T2
+}
+
+@JvmName("convertFromT2")
+suspend fun <T1, T2> SimpleSuspendableMapper<T1, T2>.convert(from: T2) = convertToT1(from)
+@JvmName("convertFromT1")
+suspend fun <T1, T2> SimpleSuspendableMapper<T1, T2>.convert(from: T1) = convertToT2(from)
+
+class SimpleSuspendableMapperImpl<T1, T2>(
+    private val t1: suspend (T2) -> T1,
+    private val t2: suspend (T1) -> T2,
+) : SimpleSuspendableMapper<T1, T2> {
+    override suspend fun convertToT1(from: T2): T1 = t1.invoke(from)
+
+    override suspend fun convertToT2(from: T1): T2 = t2.invoke(from)
+}
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun <T1, T2> simpleSuspendableMapper(
+    noinline t1: suspend (T2) -> T1,
+    noinline t2: suspend (T1) -> T2,
+) = SimpleSuspendableMapperImpl(t1, t2)

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

@@ -0,0 +1,97 @@
+@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)
+
+inline val <T : Any> T?.optionalOrAbsentIfNull
+    get() = if (this == null) {
+        Optional.absent<T>()
+    } else {
+        Optional.presented(this)
+    }
+
+/**
+ * Will call [block] when data presented ([Optional.dataPresented] == true)
+ */
+inline fun <T> Optional<T>.onPresented(block: (T) -> Unit): Optional<T> = apply {
+    @OptIn(Warning::class)
+    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 {
+    @OptIn(Warning::class)
+    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 {
+    @OptIn(Warning::class)
+    if (!dataPresented) { block() }
+}
+
+/**
+ * Will call [block] when data presented ([Optional.dataPresented] == true)
+ */
+inline fun <T, R> Optional<T>.mapOnAbsent(block: () -> R): R? = run {
+    @OptIn(Warning::class)
+    if (!dataPresented) { block() } else null
+}
+
+/**
+ * Returns [Optional.data] if [Optional.dataPresented] of [this] is true, or null otherwise
+ */
+fun <T> Optional<T>.dataOrNull() = @OptIn(Warning::class) 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) = @OptIn(Warning::class) 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) = @OptIn(Warning::class) 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

@@ -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/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

@@ -2,8 +2,7 @@ package dev.inmo.micro_utils.common
 
 import org.khronos.webgl.ArrayBuffer
 import org.w3c.dom.ErrorEvent
-import org.w3c.files.File
-import org.w3c.files.FileReader
+import org.w3c.files.*
 import kotlin.js.Promise
 
 /**
@@ -24,6 +23,11 @@ fun MPPFile.readBytesPromise() = Promise<ByteArray> { success, failure ->
     reader.readAsArrayBuffer(this)
 }
 
+fun MPPFile.readBytes(): ByteArray {
+    val reader = FileReaderSync()
+    return reader.readAsArrayBuffer(this).toByteArray()
+}
+
 private suspend fun MPPFile.dirtyReadBytes(): ByteArray = readBytesPromise().await()
 
 /**
@@ -40,5 +44,11 @@ actual val MPPFile.filesize: Long
  * @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/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

@@ -22,6 +22,11 @@ actual val MPPFile.filesize: Long
 /**
  * @suppress
  */
+actual val MPPFile.bytesAllocatorSync: ByteArrayAllocator
+    get() = ::readBytes
+/**
+ * @suppress
+ */
 actual val MPPFile.bytesAllocator: SuspendByteArrayAllocator
     get() = {
         doInIO {

coroutines/build.gradle

@@ -10,12 +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 "org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines_version"
+                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/FlowAsListState.kt

@@ -0,0 +1,26 @@
+package dev.inmo.micro_utils.coroutines.compose
+
+import androidx.compose.runtime.*
+import androidx.compose.runtime.snapshots.SnapshotStateList
+import dev.inmo.micro_utils.common.applyDiff
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun <reified T> Flow<List<T>>.asMutableComposeListState(
+    scope: CoroutineScope
+): SnapshotStateList<T> {
+    val state = mutableStateListOf<T>()
+    subscribeSafelyWithoutExceptions(scope) {
+        state.applyDiff(it)
+    }
+    return state
+}
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun <reified T> Flow<List<T>>.asComposeList(
+    scope: CoroutineScope
+): List<T> = asMutableComposeListState(scope)
+

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

@@ -0,0 +1,35 @@
+package dev.inmo.micro_utils.coroutines.compose
+
+import androidx.compose.runtime.*
+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>.asMutableComposeState(
+    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>.asMutableComposeState(
+    scope: CoroutineScope
+): MutableState<T> = asMutableComposeState(value, scope)
+
+fun <T> Flow<T>.asComposeState(
+    initial: T,
+    scope: CoroutineScope
+): State<T> {
+    val state = asMutableComposeState(initial, scope)
+    return derivedStateOf { state.value }
+}
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun <T> StateFlow<T>.asComposeState(
+    scope: CoroutineScope
+): State<T> = asComposeState(value, scope)
+

coroutines/compose/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/compose/FlowToMutableState.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

@@ -6,11 +6,12 @@ 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
-private data class DataRetrievedAccumulatorFlowStep(val data: Any) : AccumulatorFlowStep
-private data class SubscribeAccumulatorFlowStep(val channel: Channel<Any>) : AccumulatorFlowStep
-private data class UnsubscribeAccumulatorFlowStep(val channel: Channel<Any>) : AccumulatorFlowStep
+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:
@@ -26,12 +27,12 @@ class AccumulatorFlow<T>(
     private val subscope = scope.LinkedSupervisorScope()
     private val activeData = ArrayDeque<T>()
     private val dataMutex = Mutex()
-    private val channelsForBroadcast = mutableListOf<Channel<Any>>()
+    private val channelsForBroadcast = mutableListOf<Channel<T>>()
     private val channelsMutex = Mutex()
-    private val steps = subscope.actor<AccumulatorFlowStep> { step ->
+    private val steps = subscope.actor<AccumulatorFlowStep<T>> { step ->
         when (step) {
             is DataRetrievedAccumulatorFlowStep -> {
-                if (activeData.first() === step.data) {
+                if (activeData.firstOrNull() === step.data) {
                     dataMutex.withLock {
                         activeData.removeFirst()
                     }
@@ -42,7 +43,7 @@ class AccumulatorFlow<T>(
                 dataMutex.withLock {
                     val dataToSend = activeData.toList()
                     safelyWithoutExceptions {
-                        dataToSend.forEach { step.channel.send(it as Any) }
+                        dataToSend.forEach { step.channel.send(it) }
                     }
                 }
             }
@@ -58,24 +59,29 @@ class AccumulatorFlow<T>(
         channelsMutex.withLock {
             channelsForBroadcast.forEach { channel ->
                 safelyWithResult {
-                    channel.send(it as Any)
+                    channel.send(it)
                 }
             }
         }
     }
 
     override suspend fun collectSafely(collector: FlowCollector<T>) {
-        val channel = Channel<Any>(Channel.UNLIMITED, BufferOverflow.SUSPEND)
+        val channel = Channel<T>(Channel.UNLIMITED, BufferOverflow.SUSPEND)
         steps.send(SubscribeAccumulatorFlowStep(channel))
-        for (data in channel) {
-            try {
-                collector.emit(data as T)
-                steps.send(DataRetrievedAccumulatorFlowStep(data))
-            } finally {
-                channel.cancel()
-                steps.send(UnsubscribeAccumulatorFlowStep(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()
     }
 }
 

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()
+}

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

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.crypto
+
+val HEX_ARRAY = "0123456789abcdef".toCharArray()
+
+fun SourceBytes.hex(): String {
+    val hexChars = CharArray(size * 2)
+    for (j in indices) {
+        val v: Int = this[j].toInt() and 0xFF
+        hexChars[j * 2] = HEX_ARRAY[v ushr 4]
+        hexChars[j * 2 + 1] = HEX_ARRAY[v and 0x0F]
+    }
+    return hexChars.concatToString()
+}
+
+fun SourceString.hex(): String = encodeToByteArray().hex()

crypto/src/commonTest/kotlin/dev/inmo/micro_utils/crypto/Hex.kt

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.crypto
+
+import kotlin.test.*
+
+class Hex {
+    @Test
+    fun testSimpleHmacSHA256Message() {
+        val text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+        val resultHex = text.hex()
+        assertEquals(
+            "4c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742c2073656420646f20656975736d6f642074656d706f7220696e6369646964756e74207574206c61626f726520657420646f6c6f7265206d61676e6120616c697175612e20557420656e696d206164206d696e696d2076656e69616d2c2071756973206e6f737472756420657865726369746174696f6e20756c6c616d636f206c61626f726973206e69736920757420616c697175697020657820656120636f6d6d6f646f20636f6e7365717561742e2044756973206175746520697275726520646f6c6f7220696e20726570726568656e646572697420696e20766f6c7570746174652076656c697420657373652063696c6c756d20646f6c6f726520657520667567696174206e756c6c612070617269617475722e204578636570746575722073696e74206f6363616563617420637570696461746174206e6f6e2070726f6964656e742c2073756e7420696e2063756c706120717569206f666669636961206465736572756e74206d6f6c6c697420616e696d20696420657374206c61626f72756d2e",
+            resultHex
+        )
+    }
+}

defaultAndroidSettings.gradle

@@ -26,12 +26,12 @@ ext {
 }
 
 android {
-    compileSdkVersion "$android_compileSdkVersion".toInteger()
-    buildToolsVersion "$android_buildToolsVersion"
+    compileSdkVersion libs.versions.android.props.compileSdk.get().toInteger()
+    buildToolsVersion libs.versions.android.props.buildTools.get()
 
     defaultConfig {
-        minSdkVersion "$android_minSdkVersion".toInteger()
-        targetSdkVersion "$android_compileSdkVersion".toInteger()
+        minSdkVersion libs.versions.android.props.minSdk.get().toInteger()
+        targetSdkVersion libs.versions.android.props.compileSdk.get().toInteger()
         versionCode "${android_code_version}".toInteger()
         versionName "$version"
     }

extensions.gradle

@@ -21,6 +21,7 @@ allprojects {
         releaseMode = (project.hasProperty('RELEASE_MODE') && project.property('RELEASE_MODE') == "true") || System.getenv('RELEASE_MODE') == "true"
 
         mppProjectWithSerializationPresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerialization.gradle"
+        mppProjectWithSerializationAndComposePresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerializationAndCompose.gradle"
         mppJavaProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJavaProject.gradle"
         mppAndroidProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppAndroidProject.gradle"
 

fsm/common/build.gradle

@@ -10,6 +10,7 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
+                api project(":micro_utils.common")
                 api project(":micro_utils.coroutines")
             }
         }

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

@@ -47,24 +47,11 @@ fun <I : O, O : State> CheckableHandlerHolder(
     }
 )
 
-@Deprecated("Renamed", ReplaceWith("CheckableHandlerHolder"))
-fun <I : O, O : State> StateHandlerHolder(
-    inputKlass: KClass<I>,
-    strict: Boolean = false,
-    delegateTo: StatesHandler<I, O>
-) = CheckableHandlerHolder(inputKlass, strict, delegateTo)
-
 inline fun <reified I : O, O : State> CheckableHandlerHolder(
     strict: Boolean = false,
     delegateTo: StatesHandler<I, O>
 ) = CheckableHandlerHolder(I::class, strict, delegateTo)
 
-@Deprecated("Renamed", ReplaceWith("CheckableHandlerHolder"))
-inline fun <reified I : O, O : State> StateHandlerHolder(
-    strict: Boolean = false,
-    delegateTo: StatesHandler<I, O>
-) = CheckableHandlerHolder(strict, delegateTo)
-
 inline fun <reified I : O, O: State> StatesHandler<I, O>.holder(
     strict: Boolean = true
 ) = CheckableHandlerHolder<I, O>(

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

@@ -1,8 +1,14 @@
 package dev.inmo.micro_utils.fsm.common
 
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.common.Optional
+import dev.inmo.micro_utils.common.onPresented
+import dev.inmo.micro_utils.coroutines.*
+import dev.inmo.micro_utils.fsm.common.utils.StateHandlingErrorHandler
+import dev.inmo.micro_utils.fsm.common.utils.defaultStateHandlingErrorHandler
 import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 
 /**
  * Default [StatesMachine] may [startChain] and use inside logic for handling [State]s. By default you may use
@@ -10,13 +16,24 @@ import kotlinx.coroutines.*
  * handling until [start] method will be called
  */
 interface StatesMachine<T : State> : StatesHandler<T, T> {
+    suspend fun launchStateHandling(
+        state: T,
+        handlers: List<CheckableHandlerHolder<in T, T>>,
+        onStateHandlingErrorHandler: StateHandlingErrorHandler<T>
+    ): T? {
+        return runCatchingSafely {
+            handlers.firstOrNull { it.checkHandleable(state) } ?.run {
+                handleState(state)
+            }
+        }.getOrElse {
+            onStateHandlingErrorHandler(state, it)
+        }
+    }
     suspend fun launchStateHandling(
         state: T,
         handlers: List<CheckableHandlerHolder<in T, T>>
     ): T? {
-        return handlers.firstOrNull { it.checkHandleable(state) } ?.run {
-            handleState(state)
-        }
+        return launchStateHandling(state, handlers, defaultStateHandlingErrorHandler())
     }
 
     /**
@@ -35,24 +52,66 @@ interface StatesMachine<T : State> : StatesHandler<T, T> {
          */
         operator fun <T: State> invoke(
             statesManager: StatesManager<T>,
-            handlers: List<CheckableHandlerHolder<in T, T>>
-        ) = DefaultStatesMachine(statesManager, handlers)
+            handlers: List<CheckableHandlerHolder<in T, T>>,
+            onStateHandlingErrorHandler: StateHandlingErrorHandler<T> = defaultStateHandlingErrorHandler()
+        ) = DefaultStatesMachine(statesManager, handlers, onStateHandlingErrorHandler)
     }
 }
 
 /**
  * Default realization of [StatesMachine]. It uses [statesManager] for incapsulation of [State]s storing and contexts
- * resolving, and uses [launchStateHandling] for [State] handling
+ * resolving, and uses [launchStateHandling] for [State] handling.
+ *
+ * This class suppose to be extended in case you wish some custom behaviour inside of [launchStateHandling], for example
  */
-class DefaultStatesMachine <T: State>(
-    private val statesManager: StatesManager<T>,
-    private val handlers: List<CheckableHandlerHolder<in T, T>>
+open class DefaultStatesMachine <T: State>(
+    protected val statesManager: StatesManager<T>,
+    protected val handlers: List<CheckableHandlerHolder<in T, T>>,
+    protected val onStateHandlingErrorHandler: StateHandlingErrorHandler<T> = defaultStateHandlingErrorHandler()
 ) : StatesMachine<T> {
     /**
      * Will call [launchStateHandling] for state handling
      */
     override suspend fun StatesMachine<in T>.handleState(state: T): T? = launchStateHandling(state, handlers)
 
+    override suspend fun launchStateHandling(state: T, handlers: List<CheckableHandlerHolder<in T, T>>): T? {
+        return launchStateHandling(state, handlers, onStateHandlingErrorHandler)
+    }
+
+    /**
+     * This
+     */
+    protected val statesJobs = mutableMapOf<T, Job>()
+    protected val statesJobsMutex = Mutex()
+
+    protected open suspend fun performUpdate(state: T) {
+        val newState = launchStateHandling(state, handlers)
+        if (newState == null) {
+            statesManager.endChain(state)
+        } else {
+            statesManager.update(state, newState)
+        }
+    }
+
+    open suspend fun performStateUpdate(previousState: Optional<T>, actualState: T, scope: CoroutineScope) {
+        statesJobsMutex.withLock {
+            statesJobs[actualState] ?.cancel()
+            statesJobs[actualState] = scope.launch {
+                performUpdate(actualState)
+            }.also { job ->
+                job.invokeOnCompletion { _ ->
+                    scope.launch {
+                        statesJobsMutex.withLock {
+                            if (statesJobs[actualState] == job) {
+                                statesJobs.remove(actualState)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * Launch handling of states. On [statesManager] [StatesManager.onStartChain],
      * [statesManager] [StatesManager.onChainStateUpdated] will be called lambda with performing of state. If
@@ -60,23 +119,21 @@ class DefaultStatesMachine <T: State>(
      * [StatesManager.endChain].
      */
     override fun start(scope: CoroutineScope): Job = scope.launchSafelyWithoutExceptions {
-        val statePerformer: suspend (T) -> Unit = { state: T ->
-            val newState = launchStateHandling(state, handlers)
-            if (newState != null) {
-                statesManager.update(state, newState)
-            } else {
-                statesManager.endChain(state)
-            }
-        }
-        statesManager.onStartChain.subscribeSafelyWithoutExceptions(this) {
-            launch { statePerformer(it) }
+        (statesManager.getActiveStates().asFlow() + statesManager.onStartChain).subscribeSafelyWithoutExceptions(this) {
+            launch { performStateUpdate(Optional.absent(), it, scope.LinkedSupervisorScope()) }
         }
         statesManager.onChainStateUpdated.subscribeSafelyWithoutExceptions(this) {
-            launch { statePerformer(it.second) }
+            launch { performStateUpdate(Optional.presented(it.first), it.second, scope.LinkedSupervisorScope()) }
         }
-
-        statesManager.getActiveStates().forEach {
-            launch { statePerformer(it) }
+        statesManager.onEndChain.subscribeSafelyWithoutExceptions(this) { removedState ->
+            launch {
+                statesJobsMutex.withLock {
+                    val stateInMap = statesJobs.keys.firstOrNull { stateInMap -> stateInMap == removedState }
+                    if (stateInMap === removedState) {
+                        statesJobs[stateInMap] ?.cancel()
+                    }
+                }
+            }
         }
     }
 

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

@@ -0,0 +1,74 @@
+package dev.inmo.micro_utils.fsm.common
+
+import dev.inmo.micro_utils.common.*
+import dev.inmo.micro_utils.fsm.common.utils.StateHandlingErrorHandler
+import dev.inmo.micro_utils.fsm.common.utils.defaultStateHandlingErrorHandler
+import kotlinx.coroutines.*
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * This extender of [StatesMachine] interface declare one new function [updateChain]. Realizations of this interface
+ * must be able to perform update of chain in internal [StatesManager]
+ */
+interface UpdatableStatesMachine<T : State> : StatesMachine<T> {
+    /**
+     * Update chain with current state equal to [currentState] with [newState]. Behaviour of this update preforming
+     * in cases when [currentState] does not exist in [StatesManager] must be declared inside of realization of
+     * [StatesManager.update] function
+     */
+    suspend fun updateChain(currentState: T, newState: T)
+}
+
+open class DefaultUpdatableStatesMachine<T : State>(
+    statesManager: StatesManager<T>,
+    handlers: List<CheckableHandlerHolder<in T, T>>,
+    onStateHandlingErrorHandler: StateHandlingErrorHandler<T> = defaultStateHandlingErrorHandler()
+) : DefaultStatesMachine<T>(
+    statesManager,
+    handlers,
+    onStateHandlingErrorHandler
+), UpdatableStatesMachine<T> {
+    protected val jobsStates = mutableMapOf<Job, T>()
+
+    /**
+     * Realization of this update will use the [Job] of [previousState] in [statesJobs] and [jobsStates] if
+     * [previousState] is [Optional.presented] and [shouldReplaceJob] has returned true for [previousState] and [actualState]. In
+     * other words, [Job] of [previousState] WILL NOT be replaced with the new one if they are "equal". Equality of
+     * states is solved in [shouldReplaceJob] and can be rewritten in subclasses
+     */
+    override suspend fun performStateUpdate(previousState: Optional<T>, actualState: T, scope: CoroutineScope) {
+        statesJobsMutex.withLock {
+            if (shouldReplaceJob(previousState, actualState)) {
+                statesJobs[actualState] ?.cancel()
+            }
+            val job = previousState.mapOnPresented {
+                statesJobs.remove(it)
+            } ?.takeIf { it.isActive } ?: scope.launch {
+                performUpdate(actualState)
+            }.also { job ->
+                job.invokeOnCompletion { _ ->
+                    scope.launch {
+                        statesJobsMutex.withLock {
+                            statesJobs.remove(
+                                jobsStates[job] ?: return@withLock
+                            )
+                            jobsStates.remove(job)
+                        }
+                    }
+                }
+            }
+            jobsStates.remove(job)
+            statesJobs[actualState] = job
+            jobsStates[job] = actualState
+        }
+    }
+
+    /**
+     * Compare if [previous] potentially lead to the same behaviour with [new]
+     */
+    protected open suspend fun shouldReplaceJob(previous: Optional<T>, new: T): Boolean = previous.dataOrNull() != new
+
+    override suspend fun updateChain(currentState: T, newState: T) {
+        statesManager.update(currentState, newState)
+    }
+}

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

@@ -7,6 +7,12 @@ import kotlin.reflect.KClass
 
 class FSMBuilder<T : State>(
     var statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
+    val fsmBuilder: (statesManager: StatesManager<T>, states: List<CheckableHandlerHolder<T, T>>) -> StatesMachine<T> = { statesManager, states ->
+        StatesMachine(
+            statesManager,
+            states
+        )
+    },
     var defaultStateHandler: StatesHandler<T, T>? = StatesHandler { null }
 ) {
     private var states = mutableListOf<CheckableHandlerHolder<T, T>>()
@@ -42,7 +48,7 @@ class FSMBuilder<T : State>(
         add(filter, handler)
     }
 
-    fun build() = StatesMachine(
+    fun build() = fsmBuilder(
         statesManager,
         states.toList().let { list ->
             defaultStateHandler ?.let { list + it.holder { true } } ?: list

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

@@ -37,36 +37,49 @@ interface DefaultStatesManagerRepo<T : State> {
 
 /**
  * @param repo This repo will be used as repository for storing states. All operations with this repo will happen BEFORE
- * any event will be sent to [onChainStateUpdated], [onStartChain] or [onEndChain]. By default will be used
+ * any event will be sent to [onChainStateUpdated], [onStartChain] or [onEndChain]. By default, will be used
  * [InMemoryDefaultStatesManagerRepo] or you may create custom [DefaultStatesManagerRepo] and pass as [repo] parameter
- * @param onContextsConflictResolver Receive old [State], new one and the state currently placed on new [State.context]
+ * @param onStartContextsConflictResolver Receive current [State] and the state passed with [startChain]. In case when
+ * this callback will return true, currently placed on the [State.context] [State] will be replaced by new state
+ * with [endChain] with current state
+ * @param onUpdateContextsConflictResolver Receive old [State], new one and the state currently placed on new [State.context]
  * key. In case when this callback will returns true, the state placed on [State.context] of new will be replaced by
  * new state by using [endChain] with that state
  */
-class DefaultStatesManager<T : State>(
-    private val repo: DefaultStatesManagerRepo<T> = InMemoryDefaultStatesManagerRepo(),
-    private val onContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean = { _, _, _ -> true }
+open class DefaultStatesManager<T : State>(
+    protected val repo: DefaultStatesManagerRepo<T> = InMemoryDefaultStatesManagerRepo(),
+    protected val onStartContextsConflictResolver: suspend (current: T, new: T) -> Boolean = { _, _ -> true },
+    protected val onUpdateContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean = { _, _, _ -> true }
 ) : StatesManager<T> {
-    private val _onChainStateUpdated = MutableSharedFlow<Pair<T, T>>(0)
+    protected val _onChainStateUpdated = MutableSharedFlow<Pair<T, T>>(0)
     override val onChainStateUpdated: Flow<Pair<T, T>> = _onChainStateUpdated.asSharedFlow()
-    private val _onStartChain = MutableSharedFlow<T>(0)
+    protected val _onStartChain = MutableSharedFlow<T>(0)
     override val onStartChain: Flow<T> = _onStartChain.asSharedFlow()
-    private val _onEndChain = MutableSharedFlow<T>(0)
+    protected val _onEndChain = MutableSharedFlow<T>(0)
     override val onEndChain: Flow<T> = _onEndChain.asSharedFlow()
 
-    private val mapMutex = Mutex()
+    protected val mapMutex = Mutex()
+
+    constructor(
+        repo: DefaultStatesManagerRepo<T>,
+        onContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean
+    ) : this (
+        repo,
+        onUpdateContextsConflictResolver = onContextsConflictResolver
+    )
 
     override suspend fun update(old: T, new: T) = mapMutex.withLock {
         val stateByOldContext: T? = repo.getContextState(old.context)
         when {
             stateByOldContext != old -> return@withLock
             stateByOldContext == null || old.context == new.context -> {
+                repo.removeState(old)
                 repo.set(new)
                 _onChainStateUpdated.emit(old to new)
             }
             else -> {
                 val stateOnNewOneContext = repo.getContextState(new.context)
-                if (stateOnNewOneContext == null || onContextsConflictResolver(old, new, stateOnNewOneContext)) {
+                if (stateOnNewOneContext == null || onUpdateContextsConflictResolver(old, new, stateOnNewOneContext)) {
                     stateOnNewOneContext ?.let { endChainWithoutLock(it) }
                     repo.removeState(old)
                     repo.set(new)
@@ -77,13 +90,17 @@ class DefaultStatesManager<T : State>(
     }
 
     override suspend fun startChain(state: T) = mapMutex.withLock {
-        if (!repo.contains(state.context)) {
+        val stateOnContext = repo.getContextState(state.context)
+        if (stateOnContext == null || onStartContextsConflictResolver(stateOnContext, state)) {
+            stateOnContext ?.let {
+                endChainWithoutLock(it)
+            }
             repo.set(state)
             _onStartChain.emit(state)
         }
     }
 
-    private suspend fun endChainWithoutLock(state: T) {
+    protected open suspend fun endChainWithoutLock(state: T) {
         if (repo.getContextState(state.context) == state) {
             repo.removeState(state)
             _onEndChain.emit(state)

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

@@ -1,16 +0,0 @@
-package dev.inmo.micro_utils.fsm.common.managers
-
-import dev.inmo.micro_utils.fsm.common.State
-import kotlinx.coroutines.flow.*
-
-/**
- * Creates [DefaultStatesManager] with [InMemoryDefaultStatesManagerRepo]
- *
- * @param onContextsConflictResolver Receive old [State], new one and the state currently placed on new [State.context]
- * key. In case when this callback will returns true, the state placed on [State.context] of new will be replaced by
- * new state by using [endChain] with that state
- */
-@Deprecated("Use DefaultStatesManager instead", ReplaceWith("DefaultStatesManager"))
-fun <T: State> InMemoryStatesManager(
-    onContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean = { _, _, _ -> true }
-) = DefaultStatesManager(onContextsConflictResolver = onContextsConflictResolver)

fsm/common/src/commonMain/kotlin/dev/inmo/micro_utils/fsm/common/utils/StateHandlingErrorHandler.kt

@@ -0,0 +1,6 @@
+package dev.inmo.micro_utils.fsm.common.utils
+
+typealias StateHandlingErrorHandler<T> = suspend (T, Throwable) -> T?
+val DefaultStateHandlingErrorHandler: StateHandlingErrorHandler<*> = { _, _ -> null }
+inline fun <T> defaultStateHandlingErrorHandler(): StateHandlingErrorHandler<T> = DefaultStateHandlingErrorHandler as StateHandlingErrorHandler<T>
+

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

@@ -1,7 +1,6 @@
 import dev.inmo.micro_utils.fsm.common.*
 import dev.inmo.micro_utils.fsm.common.dsl.buildFSM
 import dev.inmo.micro_utils.fsm.common.managers.DefaultStatesManager
-import dev.inmo.micro_utils.fsm.common.managers.InMemoryStatesManager
 import kotlinx.coroutines.*
 
 sealed interface TrafficLightState : State {

github_release.gradle

@@ -21,7 +21,7 @@ if (new File(projectDir, "secret.gradle").exists()) {
         owner "InsanusMokrassar"
         repo "MicroUtils"
 
-        tagName "${project.version}"
+        tagName "v${project.version}"
         releaseName "${project.version}"
         targetCommitish "${project.version}"
 

gradle.properties

@@ -7,43 +7,12 @@ android.useAndroidX=true
 android.enableJetifier=true
 org.gradle.jvmargs=-Xmx2g
 
-kotlin_version=1.5.31
-kotlin_coroutines_version=1.5.2
-kotlin_serialisation_core_version=1.3.1
-kotlin_exposed_version=0.36.2
-
-ktor_version=1.6.5
-
-klockVersion=2.4.8
-
-github_release_plugin_version=2.2.12
-
-uuidVersion=0.3.1
-
-# ANDROID
-
-core_ktx_version=1.7.0
-androidx_recycler_version=1.2.1
-appcompat_version=1.3.1
-
-android_minSdkVersion=19
-android_compileSdkVersion=31
-android_buildToolsVersion=31.0.0
-dexcount_version=3.0.0
-junit_version=4.12
-test_ext_junit_version=1.1.2
-espresso_core=3.3.0
-
 # JS NPM
 
 crypto_js_version=4.1.1
 
-# Dokka
-
-dokka_version=1.5.31
-
 # Project data
 
 group=dev.inmo
-version=0.8.2
-android_code_version=82
+version=0.12.12
+android_code_version=151

gradle/libs.versions.toml

@@ -0,0 +1,87 @@
+[versions]
+
+kt = "1.7.10"
+kt-serialization = "1.4.0"
+kt-coroutines = "1.6.4"
+
+jb-compose = "1.2.0-alpha01-dev774"
+jb-exposed = "0.39.2"
+jb-dokka = "1.7.10"
+
+klock = "3.1.0"
+uuid = "0.5.0"
+
+ktor = "2.1.1"
+
+gh-release = "2.4.1"
+
+android-gradle = "7.2.2"
+dexcount = "3.1.0"
+
+android-coreKtx = "1.8.0"
+android-recyclerView = "1.2.1"
+android-appCompat = "1.4.2"
+android-espresso = "3.4.0"
+android-test = "1.1.3"
+
+android-props-minSdk = "21"
+android-props-compileSdk = "32"
+android-props-buildTools = "32.0.0"
+
+[libraries]
+
+kt-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kt" }
+
+kt-serialization = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kt-serialization" }
+kt-serialization-cbor = { module = "org.jetbrains.kotlinx:kotlinx-serialization-cbor", version.ref = "kt-serialization" }
+
+kt-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kt-coroutines" }
+kt-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kt-coroutines" }
+kt-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kt-coroutines" }
+
+
+ktor-io = { module = "io.ktor:ktor-io", version.ref = "ktor" }
+ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
+ktor-client = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
+ktor-client-cio = { module = "io.ktor:ktor-client-cio", version.ref = "ktor" }
+ktor-client-java = { module = "io.ktor:ktor-client-java", version.ref = "ktor" }
+ktor-client-websockets = { module = "io.ktor:ktor-client-websockets", version.ref = "ktor" }
+ktor-client-logging = { module = "io.ktor:ktor-client-logging", version.ref = "ktor" }
+ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
+ktor-server = { module = "io.ktor:ktor-server", version.ref = "ktor" }
+ktor-server-cio = { module = "io.ktor:ktor-server-cio", version.ref = "ktor" }
+ktor-server-host-common = { module = "io.ktor:ktor-server-host-common", version.ref = "ktor" }
+ktor-websockets = { module = "io.ktor:ktor-websockets", version.ref = "ktor" }
+ktor-server-websockets = { module = "io.ktor:ktor-server-websockets", version.ref = "ktor" }
+ktor-server-statusPages = { module = "io.ktor:ktor-server-status-pages", version.ref = "ktor" }
+ktor-server-content-negotiation = { module = "io.ktor:ktor-server-content-negotiation", version.ref = "ktor" }
+
+
+klock = { module = "com.soywiz.korlibs.klock:klock", version.ref = "klock" }
+uuid = { module = "com.benasher44:uuid", version.ref = "uuid" }
+
+
+jb-exposed = { module = "org.jetbrains.exposed:exposed-core", version.ref = "jb-exposed" }
+
+
+android-coreKtx = { module = "androidx.core:core-ktx", version.ref = "android-coreKtx" }
+android-recyclerView = { module = "androidx.recyclerview:recyclerview", version.ref = "android-recyclerView" }
+android-appCompat-resources = { module = "androidx.appcompat:appcompat-resources", version.ref = "android-appCompat" }
+android-espresso = { module = "androidx.test.espresso:espresso-core", version.ref = "android-espresso" }
+android-test-junit = { module = "androidx.test.ext:junit", version.ref = "android-test" }
+
+
+kt-test-js = { module = "org.jetbrains.kotlin:kotlin-test-js", version.ref = "kt" }
+kt-test-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kt" }
+
+
+buildscript-kt-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kt" }
+buildscript-kt-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kt" }
+buildscript-jb-dokka = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "jb-dokka" }
+buildscript-gh-release = { module = "com.github.breadmoirai:github-release", version.ref = "gh-release" }
+buildscript-android-gradle = { module = "com.android.tools.build:gradle", version.ref = "android-gradle" }
+buildscript-android-dexcount = { module = "com.getkeepsafe.dexcount:dexcount-gradle-plugin", version.ref = "dexcount" }
+
+[plugins]
+
+jb-compose = { id = "org.jetbrains.compose", version.ref = "jb-compose" }

gradle/wrapper/gradle-wrapper.properties

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

ktor/client/build.gradle

@@ -12,7 +12,7 @@ kotlin {
             dependencies {
                 api internalProject("micro_utils.ktor.common")
                 api internalProject("micro_utils.coroutines")
-                api "io.ktor:ktor-client-core:$ktor_version"
+                api libs.ktor.client
             }
         }
     }

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

@@ -0,0 +1,9 @@
+package dev.inmo.micro_utils.ktor.client
+
+import io.ktor.client.call.body
+import io.ktor.client.statement.HttpResponse
+import io.ktor.http.HttpStatusCode
+
+suspend inline fun <reified T : Any> HttpResponse.bodyOrNull() = takeIf {
+    status == HttpStatusCode.OK
+} ?.body<T>()

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

@@ -1,57 +1,62 @@
 package dev.inmo.micro_utils.ktor.client
 
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.coroutines.safely
 import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.client.HttpClient
-import io.ktor.client.features.websocket.ws
-import io.ktor.http.cio.websocket.Frame
-import io.ktor.http.cio.websocket.readBytes
+import io.ktor.client.plugins.pluginOrNull
+import io.ktor.client.plugins.websocket.WebSockets
+import io.ktor.client.plugins.websocket.ws
+import io.ktor.client.request.HttpRequestBuilder
+import io.ktor.websocket.Frame
+import io.ktor.websocket.readBytes
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.isActive
 import kotlinx.serialization.DeserializationStrategy
 
 /**
  * @param checkReconnection This lambda will be called when it is required to reconnect to websocket to establish
  * connection. Must return true in case if must be reconnected. By default always reconnecting
  */
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
 inline fun <T> HttpClient.createStandardWebsocketFlow(
     url: String,
-    crossinline checkReconnection: (Throwable?) -> Boolean = { true },
+    crossinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
+    noinline requestBuilder: HttpRequestBuilder.() -> Unit = {},
     crossinline conversation: suspend (StandardKtorSerialInputData) -> T
 ): Flow<T> {
+    pluginOrNull(WebSockets) ?: error("Plugin $WebSockets must be installed for using createStandardWebsocketFlow")
+
     val correctedUrl = url.asCorrectWebSocketUrl
 
     return channelFlow {
-        val producerScope = this@channelFlow
         do {
-            val reconnect = try {
-                safely {
-                    ws(correctedUrl) {
-                        for (received in incoming) {
-                            when (received) {
-                                is Frame.Binary -> producerScope.send(conversation(received.readBytes()))
-                                else -> {
-                                    producerScope.close()
-                                    return@ws
-                                }
+            val reconnect = runCatchingSafely {
+                ws(correctedUrl, requestBuilder) {
+                    for (received in incoming) {
+                        when (received) {
+                            is Frame.Binary -> send(conversation(received.data))
+                            else -> {
+                                close()
+                                return@ws
                             }
                         }
                     }
                 }
                 checkReconnection(null)
-            } catch (e: Throwable) {
+            }.getOrElse { e ->
                 checkReconnection(e).also {
                     if (!it) {
-                        producerScope.close(e)
+                        close(e)
                     }
                 }
             }
-        } while (reconnect)
-        if (!producerScope.isClosedForSend) {
-            safely(
-                { it.printStackTrace() }
-            ) {
-                producerScope.close()
+        } while (reconnect && isActive)
+
+        if (isActive) {
+            safely {
+                close()
             }
         }
     }
@@ -61,14 +66,17 @@ inline fun <T> HttpClient.createStandardWebsocketFlow(
  * @param checkReconnection This lambda will be called when it is required to reconnect to websocket to establish
  * connection. Must return true in case if must be reconnected. By default always reconnecting
  */
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
 inline fun <T> HttpClient.createStandardWebsocketFlow(
     url: String,
-    crossinline checkReconnection: (Throwable?) -> Boolean = { true },
     deserializer: DeserializationStrategy<T>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    crossinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    noinline requestBuilder: HttpRequestBuilder.() -> Unit = {},
 ) = createStandardWebsocketFlow(
     url,
-    checkReconnection
+    checkReconnection,
+    requestBuilder
 ) {
     serialFormat.decodeDefault(deserializer, it)
 }

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

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.ktor.client
+
+import io.ktor.client.plugins.ClientRequestException
+import io.ktor.client.statement.HttpResponse
+import io.ktor.http.isSuccess
+
+inline fun HttpResponse.throwOnUnsuccess(
+    unsuccessMessage: () -> String
+) {
+    if (status.isSuccess()) {
+        return
+    }
+
+    throw ClientRequestException(this, unsuccessMessage())
+}

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

@@ -0,0 +1,6 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import io.ktor.client.request.forms.InputProvider
+
+expect suspend fun MPPFile.inputProvider(): InputProvider

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

@@ -0,0 +1,103 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.Warning
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
+import dev.inmo.micro_utils.coroutines.safely
+import dev.inmo.micro_utils.ktor.common.*
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.pluginOrNull
+import io.ktor.client.plugins.websocket.*
+import io.ktor.client.request.HttpRequestBuilder
+import io.ktor.http.URLProtocol
+import kotlinx.coroutines.channels.SendChannel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.isActive
+
+/**
+ * @param checkReconnection This lambda will be called when it is required to reconnect to websocket to establish
+ * connection. Must return true in case if must be reconnected. By default always reconnecting
+ */
+@Warning("This feature is internal and should not be used directly. It is can be changed without any notification and warranty on compile-time or other guaranties")
+inline fun <reified T : Any> openBaseWebSocketFlow(
+    noinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
+    noinline webSocketSessionRequest: suspend SendChannel<T>.() -> Unit
+): Flow<T> {
+    return channelFlow {
+        do {
+            val reconnect = runCatchingSafely {
+                webSocketSessionRequest()
+                checkReconnection(null)
+            }.getOrElse { e ->
+                checkReconnection(e).also {
+                    if (!it) {
+                        close(e)
+                    }
+                }
+            }
+        } while (reconnect && isActive)
+
+        if (isActive) {
+            safely {
+                close()
+            }
+        }
+    }
+}
+
+/**
+ * @param checkReconnection This lambda will be called when it is required to reconnect to websocket to establish
+ * connection. Must return true in case if must be reconnected. By default always reconnecting
+ */
+inline fun <reified T : Any> HttpClient.openWebSocketFlow(
+    url: String,
+    useSecureConnection: Boolean,
+    noinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
+    noinline requestBuilder: HttpRequestBuilder.() -> Unit = {}
+): Flow<T> {
+    pluginOrNull(WebSockets) ?: error("Plugin $WebSockets must be installed for using createStandardWebsocketFlow")
+
+    return openBaseWebSocketFlow<T>(checkReconnection) {
+        val block: suspend DefaultClientWebSocketSession.() -> Unit = {
+            while (isActive) {
+                send(receiveDeserialized<T>())
+            }
+        }
+
+        if (useSecureConnection) {
+            wss(url, requestBuilder, block)
+        } else {
+            ws(url, requestBuilder, block)
+        }
+    }
+}
+
+/**
+ * @param checkReconnection This lambda will be called when it is required to reconnect to websocket to establish
+ * connection. Must return true in case if must be reconnected. By default always reconnecting
+ */
+inline fun <reified T : Any> HttpClient.openWebSocketFlow(
+    url: String,
+    noinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
+    noinline requestBuilder: HttpRequestBuilder.() -> Unit = {}
+): Flow<T> = openWebSocketFlow(url, false, checkReconnection, requestBuilder)
+
+/**
+ * @param checkReconnection This lambda will be called when it is required to reconnect to websocket to establish
+ * connection. Must return true in case if must be reconnected. By default always reconnecting
+ */
+inline fun <reified T : Any> HttpClient.openSecureWebSocketFlow(
+    url: String,
+    noinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
+    noinline requestBuilder: HttpRequestBuilder.() -> Unit = {}
+): Flow<T> = openWebSocketFlow(url, true, checkReconnection, requestBuilder)
+
+/**
+ * @param checkReconnection This lambda will be called when it is required to reconnect to websocket to establish
+ * connection. Must return true in case if must be reconnected. By default always reconnecting
+ */
+inline fun <reified T : Any> HttpClient.createStandardWebsocketFlow(
+    url: String,
+    noinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
+    noinline requestBuilder: HttpRequestBuilder.() -> Unit = {}
+): Flow<T> = openWebSocketFlow(url, checkReconnection, requestBuilder)

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

@@ -1,16 +1,21 @@
 package dev.inmo.micro_utils.ktor.client
 
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.filename
 import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.client.HttpClient
-import io.ktor.client.request.get
-import io.ktor.client.request.post
+import io.ktor.client.call.body
+import io.ktor.client.request.*
+import io.ktor.client.request.forms.*
+import io.ktor.client.statement.readBytes
+import io.ktor.http.*
+import io.ktor.utils.io.core.ByteReadPacket
 import kotlinx.serialization.*
 
-typealias BodyPair<T> = Pair<SerializationStrategy<T>, T>
-
+@Deprecated("This class will be removed soon. It is now recommended to use built-in ktor features instead")
 class UnifiedRequester(
-    private val client: HttpClient = HttpClient(),
-    private val serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    val client: HttpClient = HttpClient(),
+    val serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
 ) {
     suspend fun <ResultType> uniget(
         url: String,
@@ -27,30 +32,86 @@ class UnifiedRequester(
 
     suspend fun <BodyType, ResultType> unipost(
         url: String,
-        bodyInfo: BodyPair<BodyType>,
+        bodyInfo: Pair<SerializationStrategy<BodyType>, BodyType>,
         resultDeserializer: DeserializationStrategy<ResultType>
     ) = client.unipost(url, bodyInfo, resultDeserializer, serialFormat)
 
+    suspend fun <ResultType> unimultipart(
+        url: String,
+        filename: String,
+        inputProvider: InputProvider,
+        resultDeserializer: DeserializationStrategy<ResultType>,
+        mimetype: String = "*/*",
+        additionalParametersBuilder: FormBuilder.() -> Unit = {},
+        dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
+        requestBuilder: HttpRequestBuilder.() -> Unit = {},
+    ): ResultType = client.unimultipart(url, filename, inputProvider, resultDeserializer, mimetype, additionalParametersBuilder, dataHeadersBuilder, requestBuilder, serialFormat)
+
+    suspend fun <BodyType, ResultType> unimultipart(
+        url: String,
+        filename: String,
+        inputProvider: InputProvider,
+        otherData: Pair<SerializationStrategy<BodyType>, BodyType>,
+        resultDeserializer: DeserializationStrategy<ResultType>,
+        mimetype: String = "*/*",
+        additionalParametersBuilder: FormBuilder.() -> Unit = {},
+        dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
+        requestBuilder: HttpRequestBuilder.() -> Unit = {},
+    ): ResultType = client.unimultipart(url, filename, otherData, inputProvider, resultDeserializer, mimetype, additionalParametersBuilder, dataHeadersBuilder, requestBuilder, serialFormat)
+
+    suspend fun <ResultType> unimultipart(
+        url: String,
+        mppFile: MPPFile,
+        resultDeserializer: DeserializationStrategy<ResultType>,
+        mimetype: String = "*/*",
+        additionalParametersBuilder: FormBuilder.() -> Unit = {},
+        dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
+        requestBuilder: HttpRequestBuilder.() -> Unit = {}
+    ): ResultType = client.unimultipart(
+        url, mppFile, resultDeserializer, mimetype, additionalParametersBuilder, dataHeadersBuilder, requestBuilder, serialFormat
+    )
+
+    suspend fun <BodyType, ResultType> unimultipart(
+        url: String,
+        mppFile: MPPFile,
+        otherData: Pair<SerializationStrategy<BodyType>, BodyType>,
+        resultDeserializer: DeserializationStrategy<ResultType>,
+        mimetype: String = "*/*",
+        additionalParametersBuilder: FormBuilder.() -> Unit = {},
+        dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
+        requestBuilder: HttpRequestBuilder.() -> Unit = {}
+    ): ResultType = client.unimultipart(
+        url, mppFile, otherData, resultDeserializer, mimetype, additionalParametersBuilder, dataHeadersBuilder, requestBuilder, serialFormat
+    )
+
     fun <T> createStandardWebsocketFlow(
         url: String,
-        checkReconnection: (Throwable?) -> Boolean = { true },
-        deserializer: DeserializationStrategy<T>
-    ) = client.createStandardWebsocketFlow(url, checkReconnection, deserializer, serialFormat)
+        checkReconnection: suspend (Throwable?) -> Boolean,
+        deserializer: DeserializationStrategy<T>,
+        requestBuilder: HttpRequestBuilder.() -> Unit = {},
+    ) = client.createStandardWebsocketFlow(url, deserializer, checkReconnection, serialFormat, requestBuilder)
+
+    fun <T> createStandardWebsocketFlow(
+        url: String,
+        deserializer: DeserializationStrategy<T>,
+        requestBuilder: HttpRequestBuilder.() -> Unit = {},
+    ) = createStandardWebsocketFlow(url, { true }, deserializer, requestBuilder)
 }
 
+@Deprecated("This property will be removed soon. It is now recommended to use built-in ktor features instead")
 val defaultRequester = UnifiedRequester()
 
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
 suspend fun <ResultType> HttpClient.uniget(
     url: String,
     resultDeserializer: DeserializationStrategy<ResultType>,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
-) = get<StandardKtorSerialInputData>(
-    url
-).let {
-    serialFormat.decodeDefault(resultDeserializer, it)
+) = get(url).let {
+    serialFormat.decodeDefault(resultDeserializer, it.body<StandardKtorSerialInputData>())
 }
 
 
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
 fun <T> SerializationStrategy<T>.encodeUrlQueryValue(
     value: T,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
@@ -59,13 +120,141 @@ fun <T> SerializationStrategy<T>.encodeUrlQueryValue(
     value
 )
 
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
 suspend fun <BodyType, ResultType> HttpClient.unipost(
     url: String,
-    bodyInfo: BodyPair<BodyType>,
+    bodyInfo: Pair<SerializationStrategy<BodyType>, BodyType>,
     resultDeserializer: DeserializationStrategy<ResultType>,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
-) = post<StandardKtorSerialInputData>(url) {
-    body = serialFormat.encodeDefault(bodyInfo.first, bodyInfo.second)
+) = post(url) {
+    setBody(
+        serialFormat.encodeDefault(bodyInfo.first, bodyInfo.second)
+    )
 }.let {
-    serialFormat.decodeDefault(resultDeserializer, it)
+    serialFormat.decodeDefault(resultDeserializer, it.body<StandardKtorSerialInputData>())
 }
+
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
+suspend fun <ResultType> HttpClient.unimultipart(
+    url: String,
+    filename: String,
+    inputProvider: InputProvider,
+    resultDeserializer: DeserializationStrategy<ResultType>,
+    mimetype: String = "*/*",
+    additionalParametersBuilder: FormBuilder.() -> Unit = {},
+    dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
+    requestBuilder: HttpRequestBuilder.() -> Unit = {},
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+): ResultType = submitFormWithBinaryData(
+    url,
+    formData = formData {
+        append(
+            "bytes",
+            inputProvider,
+            Headers.build {
+                append(HttpHeaders.ContentType, mimetype)
+                append(HttpHeaders.ContentDisposition, "filename=\"$filename\"")
+                dataHeadersBuilder()
+            }
+        )
+        additionalParametersBuilder()
+    }
+) {
+    requestBuilder()
+}.let { serialFormat.decodeDefault(resultDeserializer, it.body<StandardKtorSerialInputData>()) }
+
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
+suspend fun <BodyType, ResultType> HttpClient.unimultipart(
+    url: String,
+    filename: String,
+    otherData: Pair<SerializationStrategy<BodyType>, BodyType>,
+    inputProvider: InputProvider,
+    resultDeserializer: DeserializationStrategy<ResultType>,
+    mimetype: String = "*/*",
+    additionalParametersBuilder: FormBuilder.() -> Unit = {},
+    dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
+    requestBuilder: HttpRequestBuilder.() -> Unit = {},
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+): ResultType = unimultipart(
+    url,
+    filename,
+    inputProvider,
+    resultDeserializer,
+    mimetype,
+    additionalParametersBuilder = {
+        val serialized = serialFormat.encodeDefault(otherData.first, otherData.second)
+        append(
+            "data",
+            InputProvider(serialized.size.toLong()) {
+                ByteReadPacket(serialized)
+            },
+            Headers.build {
+                append(HttpHeaders.ContentType, ContentType.Application.Cbor.contentType)
+                append(HttpHeaders.ContentDisposition, "filename=data.bytes")
+                dataHeadersBuilder()
+            }
+        )
+        additionalParametersBuilder()
+    },
+    dataHeadersBuilder,
+    requestBuilder,
+    serialFormat
+)
+
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
+suspend fun <ResultType> HttpClient.unimultipart(
+    url: String,
+    mppFile: MPPFile,
+    resultDeserializer: DeserializationStrategy<ResultType>,
+    mimetype: String = "*/*",
+    additionalParametersBuilder: FormBuilder.() -> Unit = {},
+    dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
+    requestBuilder: HttpRequestBuilder.() -> Unit = {},
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+): ResultType = unimultipart(
+    url,
+    mppFile.filename.string,
+    mppFile.inputProvider(),
+    resultDeserializer,
+    mimetype,
+    additionalParametersBuilder,
+    dataHeadersBuilder,
+    requestBuilder,
+    serialFormat
+)
+
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
+suspend fun <BodyType, ResultType> HttpClient.unimultipart(
+    url: String,
+    mppFile: MPPFile,
+    otherData: Pair<SerializationStrategy<BodyType>, BodyType>,
+    resultDeserializer: DeserializationStrategy<ResultType>,
+    mimetype: String = "*/*",
+    additionalParametersBuilder: FormBuilder.() -> Unit = {},
+    dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
+    requestBuilder: HttpRequestBuilder.() -> Unit = {},
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+): ResultType = unimultipart(
+    url,
+    mppFile,
+    resultDeserializer,
+    mimetype,
+    additionalParametersBuilder = {
+        val serialized = serialFormat.encodeDefault(otherData.first, otherData.second)
+        append(
+            "data",
+            InputProvider(serialized.size.toLong()) {
+                ByteReadPacket(serialized)
+            },
+            Headers.build {
+                append(HttpHeaders.ContentType, ContentType.Application.Cbor.contentType)
+                append(HttpHeaders.ContentDisposition, "filename=data.bytes")
+                dataHeadersBuilder()
+            }
+        )
+        additionalParametersBuilder()
+    },
+    dataHeadersBuilder,
+    requestBuilder,
+    serialFormat
+)

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

@@ -0,0 +1,19 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.ktor.common.*
+import io.ktor.client.HttpClient
+
+expect suspend fun HttpClient.tempUpload(
+    fullTempUploadDraftPath: String,
+    file: MPPFile,
+    onUpload: (uploaded: Long, count: Long) -> Unit = { _, _ -> }
+): TemporalFileId
+
+suspend fun UnifiedRequester.tempUpload(
+    fullTempUploadDraftPath: String,
+    file: MPPFile,
+    onUpload: (uploaded: Long, count: Long) -> Unit = { _, _ -> }
+): TemporalFileId = client.tempUpload(
+    fullTempUploadDraftPath, file, onUpload
+)

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

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

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

@@ -0,0 +1,59 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.ktor.common.TemporalFileId
+import io.ktor.client.HttpClient
+import kotlinx.coroutines.*
+import org.w3c.dom.mediasource.ENDED
+import org.w3c.dom.mediasource.ReadyState
+import org.w3c.xhr.*
+import org.w3c.xhr.XMLHttpRequest.Companion.DONE
+
+suspend fun tempUpload(
+    fullTempUploadDraftPath: String,
+    file: MPPFile,
+    onUpload: (Long, Long) -> Unit
+): TemporalFileId {
+    val formData = FormData()
+    val answer = CompletableDeferred<TemporalFileId>(currentCoroutineContext().job)
+
+    formData.append(
+        "data",
+        file
+    )
+
+    val request = XMLHttpRequest()
+    request.responseType = XMLHttpRequestResponseType.TEXT
+    request.upload.onprogress = {
+        onUpload(it.loaded.toLong(), it.total.toLong())
+    }
+    request.onload = {
+        if (request.status == 200.toShort()) {
+            answer.complete(TemporalFileId(request.responseText))
+        } else {
+            answer.completeExceptionally(Exception("Something went wrong: $it"))
+        }
+    }
+    request.onerror = {
+        answer.completeExceptionally(Exception("Something went wrong: $it"))
+    }
+    request.open("POST", fullTempUploadDraftPath, true)
+    request.send(formData)
+
+    answer.invokeOnCompletion {
+        runCatching {
+            if (request.readyState != DONE) {
+                request.abort()
+            }
+        }
+    }
+
+    return answer.await()
+}
+
+
+actual suspend fun HttpClient.tempUpload(
+    fullTempUploadDraftPath: String,
+    file: MPPFile,
+    onUpload: (uploaded: Long, count: Long) -> Unit
+): TemporalFileId = dev.inmo.micro_utils.ktor.client.tempUpload(fullTempUploadDraftPath, file, onUpload)

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

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

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

@@ -0,0 +1,40 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.filename
+import dev.inmo.micro_utils.ktor.common.TemporalFileId
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.onUpload
+import io.ktor.client.request.forms.formData
+import io.ktor.client.request.forms.submitFormWithBinaryData
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.Headers
+import io.ktor.http.HttpHeaders
+import java.net.URLConnection
+
+internal val MPPFile.mimeType: String
+    get() = URLConnection.getFileNameMap().getContentTypeFor(filename.name) ?: "*/*"
+
+actual suspend fun HttpClient.tempUpload(
+    fullTempUploadDraftPath: String,
+    file: MPPFile,
+    onUpload: (Long, Long) -> Unit
+): TemporalFileId {
+    val inputProvider = file.inputProvider()
+    val fileId = submitFormWithBinaryData(
+        fullTempUploadDraftPath,
+        formData = formData {
+            append(
+                "data",
+                inputProvider,
+                Headers.build {
+                    append(HttpHeaders.ContentType, file.mimeType)
+                    append(HttpHeaders.ContentDisposition, "filename=\"${file.filename.string}\"")
+                }
+            )
+        }
+    ) {
+        onUpload(onUpload)
+    }.bodyAsText()
+    return TemporalFileId(fileId)
+}

ktor/common/build.gradle

@@ -10,8 +10,11 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api "org.jetbrains.kotlinx:kotlinx-serialization-cbor:$kotlin_serialisation_core_version"
-                api "com.soywiz.korlibs.klock:klock:$klockVersion"
+                api internalProject("micro_utils.common")
+                api libs.kt.serialization.cbor
+                api libs.klock
+                api libs.uuid
+                api libs.ktor.io
             }
         }
     }

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

@@ -0,0 +1,6 @@
+package dev.inmo.micro_utils.ktor.common
+
+import dev.inmo.micro_utils.common.MPPFile
+import io.ktor.utils.io.core.Input
+
+expect fun MPPFile.input(): Input

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

@@ -1,3 +1,5 @@
+@file:Suppress("NOTHING_TO_INLINE")
+
 package dev.inmo.micro_utils.ktor.common
 
 import kotlinx.serialization.*

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

@@ -0,0 +1,10 @@
+package dev.inmo.micro_utils.ktor.common
+
+import kotlin.jvm.JvmInline
+import kotlinx.serialization.Serializable
+
+const val DefaultTemporalFilesSubPath = "temp_upload"
+
+@Serializable
+@JvmInline
+value class TemporalFileId(val string: String)

ktor/common/src/jsMain/kotlin/dev/inmo/micro_utils/ktor/common/ActualMPPFileInput.kt

@@ -0,0 +1,7 @@
+package dev.inmo.micro_utils.ktor.common
+
+import dev.inmo.micro_utils.common.*
+import io.ktor.utils.io.core.ByteReadPacket
+import io.ktor.utils.io.core.Input
+
+actual fun MPPFile.input(): Input = ByteReadPacket(readBytes())

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

@@ -0,0 +1,7 @@
+package dev.inmo.micro_utils.ktor.common
+
+import dev.inmo.micro_utils.common.MPPFile
+import io.ktor.utils.io.core.Input
+import io.ktor.utils.io.streams.asInput
+
+actual fun MPPFile.input(): Input = inputStream().asInput()

ktor/server/build.gradle

@@ -16,10 +16,11 @@ kotlin {
 
         jvmMain {
             dependencies {
-                api "io.ktor:ktor-server:$ktor_version"
-                api "io.ktor:ktor-server-cio:$ktor_version"
-                api "io.ktor:ktor-server-host-common:$ktor_version"
-                api "io.ktor:ktor-websockets:$ktor_version"
+                api libs.ktor.server
+                api libs.ktor.server.cio
+                api libs.ktor.server.host.common
+                api libs.ktor.server.websockets
+                api libs.ktor.server.statusPages
             }
         }
     }

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

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.ktor.server
+
+import io.ktor.server.application.ApplicationCall
+import io.ktor.server.response.responseType
+import io.ktor.util.InternalAPI
+import io.ktor.util.reflect.TypeInfo
+
+@InternalAPI
+suspend fun <T : Any> ApplicationCall.respond(
+    message: T,
+    typeInfo: TypeInfo
+) {
+    response.responseType = typeInfo
+    response.pipeline.execute(this, message as Any)
+}

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

@@ -2,42 +2,60 @@ package dev.inmo.micro_utils.ktor.server
 
 import dev.inmo.micro_utils.coroutines.safely
 import dev.inmo.micro_utils.ktor.common.*
-import io.ktor.http.cio.websocket.*
-import io.ktor.routing.Route
-import io.ktor.websocket.webSocket
+import io.ktor.http.URLProtocol
+import io.ktor.server.application.install
+import io.ktor.server.application.pluginOrNull
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.application
+import io.ktor.server.websocket.*
+import io.ktor.websocket.send
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.collect
 import kotlinx.serialization.SerializationStrategy
 
-private suspend fun DefaultWebSocketSession.checkReceivedAndCloseIfExists() {
-    if (incoming.tryReceive() != null) {
-        close()
-        throw CorrectCloseException
-    }
-}
-
+@Deprecated("This method will be removed soon")
 fun <T> Route.includeWebsocketHandling(
     suburl: String,
     flow: Flow<T>,
-    converter: (T) -> StandardKtorSerialInputData
+    protocol: URLProtocol? = null,
+    converter: suspend WebSocketServerSession.(T) -> StandardKtorSerialInputData?
 ) {
-    webSocket(suburl) {
+    application.apply {
+        pluginOrNull(WebSockets) ?: install(WebSockets)
+    }
+    webSocket(suburl, protocol ?.name) {
         safely {
             flow.collect {
-                send(converter(it))
+                converter(it) ?.let { data ->
+                    send(data)
+                }
             }
         }
     }
 }
 
+@Deprecated("This method will be removed soon")
 fun <T> Route.includeWebsocketHandling(
     suburl: String,
     flow: Flow<T>,
     serializer: SerializationStrategy<T>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    protocol: URLProtocol? = null,
+    filter: (suspend WebSocketServerSession.(T) -> Boolean)? = null
 ) = includeWebsocketHandling(
     suburl,
-    flow
-) {
-    serialFormat.encodeDefault(serializer, it)
-}
+    flow,
+    protocol,
+    converter = if (filter == null) {
+        {
+            serialFormat.encodeDefault(serializer, it)
+        }
+    } else {
+        {
+            if (filter(it)) {
+                serialFormat.encodeDefault(serializer, it)
+            } else {
+                null
+            }
+        }
+    }
+)

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

@@ -0,0 +1,31 @@
+package dev.inmo.micro_utils.ktor.server
+
+import dev.inmo.micro_utils.coroutines.safely
+import dev.inmo.micro_utils.ktor.common.*
+import io.ktor.http.URLProtocol
+import io.ktor.server.application.install
+import io.ktor.server.application.pluginOrNull
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.application
+import io.ktor.server.websocket.*
+import io.ktor.websocket.send
+import kotlinx.coroutines.flow.Flow
+import kotlinx.serialization.SerializationStrategy
+
+inline fun <reified T : Any> Route.includeWebsocketHandling(
+    suburl: String,
+    flow: Flow<T>,
+    protocol: URLProtocol? = null,
+    noinline dataMapper: suspend WebSocketServerSession.(T) -> T? = { it }
+) {
+    application.apply {
+        pluginOrNull(WebSockets) ?: install(WebSockets)
+    }
+    webSocket(suburl, protocol ?.name) {
+        safely {
+            flow.collect {
+                sendSerialized(dataMapper(it) ?: return@collect)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.ktor.server
+
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.application.ApplicationCall
+import io.ktor.server.response.respond
+
+suspend inline fun <reified T : Any> ApplicationCall.respondOrNoContent(
+    data: T?
+) {
+    if (data == null) {
+        respond(HttpStatusCode.NoContent)
+    } else {
+        respond(data)
+    }
+}

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

@@ -1,28 +1,36 @@
 package dev.inmo.micro_utils.ktor.server
 
+import dev.inmo.micro_utils.common.*
 import dev.inmo.micro_utils.coroutines.safely
 import dev.inmo.micro_utils.ktor.common.*
-import io.ktor.application.ApplicationCall
-import io.ktor.application.call
-import io.ktor.http.ContentType
-import io.ktor.http.HttpStatusCode
-import io.ktor.request.receive
-import io.ktor.response.respond
-import io.ktor.response.respondBytes
-import io.ktor.routing.Route
+import io.ktor.http.*
+import io.ktor.http.content.*
+import io.ktor.server.application.ApplicationCall
+import io.ktor.server.application.call
+import io.ktor.server.request.receive
+import io.ktor.server.request.receiveMultipart
+import io.ktor.server.response.respond
+import io.ktor.server.response.respondBytes
+import io.ktor.server.routing.Route
+import io.ktor.server.websocket.WebSocketServerSession
 import io.ktor.util.pipeline.PipelineContext
+import io.ktor.utils.io.core.*
 import kotlinx.coroutines.flow.Flow
-import kotlinx.serialization.*
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.SerializationStrategy
 
+@Deprecated("This class method will be removed soon. It is now recommended to use built-in ktor features instead")
 class UnifiedRouter(
-    private val serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
-    private val serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+    val serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    val serialFormatContentType: ContentType = standardKtorSerialFormatContentType
 ) {
     fun <T> Route.includeWebsocketHandling(
         suburl: String,
         flow: Flow<T>,
-        serializer: SerializationStrategy<T>
-    ) = includeWebsocketHandling(suburl, flow, serializer, serialFormat)
+        serializer: SerializationStrategy<T>,
+        protocol: URLProtocol? = null,
+        filter: (suspend WebSocketServerSession.(T) -> Boolean)? = null
+    ) = includeWebsocketHandling(suburl, flow, serializer, serialFormat, protocol, filter)
 
     suspend fun <T> PipelineContext<*, ApplicationCall>.unianswer(
         answerSerializer: SerializationStrategy<T>,
@@ -81,10 +89,16 @@ class UnifiedRouter(
             call.respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
         }
     }
+
+    companion object {
+        val default
+            get() = defaultUnifiedRouter
+    }
 }
 
 val defaultUnifiedRouter = UnifiedRouter()
 
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
 suspend fun <T> ApplicationCall.unianswer(
     answerSerializer: SerializationStrategy<T>,
     answer: T
@@ -95,6 +109,7 @@ suspend fun <T> ApplicationCall.unianswer(
     )
 }
 
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
 suspend fun <T> ApplicationCall.uniload(
     deserializer: DeserializationStrategy<T>
 ) = safely {
@@ -104,6 +119,153 @@ suspend fun <T> ApplicationCall.uniload(
     )
 }
 
+suspend fun ApplicationCall.uniloadMultipart(
+    onFormItem: (PartData.FormItem) -> Unit = {},
+    onCustomFileItem: (PartData.FileItem) -> Unit = {},
+    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
+    onBinaryContent: (PartData.BinaryItem) -> Unit = {}
+) = safely {
+    val multipartData = receiveMultipart()
+
+    var resultInput: Input? = null
+
+    multipartData.forEachPart {
+        when (it) {
+            is PartData.FormItem -> onFormItem(it)
+            is PartData.FileItem -> {
+                when (it.name) {
+                    "bytes" -> resultInput = it.provider()
+                    else -> onCustomFileItem(it)
+                }
+            }
+            is PartData.BinaryItem -> onBinaryContent(it)
+            is PartData.BinaryChannelItem -> onBinaryChannelItem(it)
+        }
+    }
+
+    resultInput ?: error("Bytes has not been received")
+}
+
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
+suspend fun <T> ApplicationCall.uniloadMultipart(
+    deserializer: DeserializationStrategy<T>,
+    onFormItem: (PartData.FormItem) -> Unit = {},
+    onCustomFileItem: (PartData.FileItem) -> Unit = {},
+    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
+    onBinaryContent: (PartData.BinaryItem) -> Unit = {}
+): Pair<Input, T> {
+    var data: Optional<T>? = null
+    val resultInput = uniloadMultipart(
+        onFormItem,
+        {
+            if (it.name == "data") {
+                data = standardKtorSerialFormat.decodeDefault(deserializer, it.provider().readBytes()).optional
+            } else {
+                onCustomFileItem(it)
+            }
+        },
+        onBinaryChannelItem,
+        onBinaryContent
+    )
+
+    val completeData = data ?: error("Data has not been received")
+    return resultInput to (completeData.dataOrNull().let { it as T })
+}
+
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
+suspend fun <T> ApplicationCall.uniloadMultipartFile(
+    deserializer: DeserializationStrategy<T>,
+    onFormItem: (PartData.FormItem) -> Unit = {},
+    onCustomFileItem: (PartData.FileItem) -> Unit = {},
+    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
+    onBinaryContent: (PartData.BinaryItem) -> Unit = {},
+) = safely {
+    val multipartData = receiveMultipart()
+
+    var resultInput: MPPFile? = null
+    var data: Optional<T>? = null
+
+    multipartData.forEachPart {
+        when (it) {
+            is PartData.FormItem -> onFormItem(it)
+            is PartData.FileItem -> {
+                when (it.name) {
+                    "bytes" -> {
+                        val name = FileName(it.originalFileName ?: error("File name is unknown for default part"))
+                        resultInput = MPPFile.createTempFile(
+                            name.nameWithoutExtension.let {
+                                var resultName = it
+                                while (resultName.length < 3) {
+                                    resultName += "_"
+                                }
+                                resultName
+                            },
+                            ".${name.extension}"
+                        ).apply {
+                            outputStream().use { fileStream ->
+                                it.streamProvider().use {
+                                    it.copyTo(fileStream)
+                                }
+                            }
+                        }
+                    }
+                    "data" -> data = standardKtorSerialFormat.decodeDefault(deserializer, it.provider().readBytes()).optional
+                    else -> onCustomFileItem(it)
+                }
+            }
+            is PartData.BinaryItem -> onBinaryContent(it)
+            is PartData.BinaryChannelItem -> onBinaryChannelItem(it)
+        }
+    }
+
+    val completeData = data ?: error("Data has not been received")
+    (resultInput ?: error("Bytes has not been received")) to (completeData.dataOrNull().let { it as T })
+}
+
+suspend fun ApplicationCall.uniloadMultipartFile(
+    onFormItem: (PartData.FormItem) -> Unit = {},
+    onCustomFileItem: (PartData.FileItem) -> Unit = {},
+    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
+    onBinaryContent: (PartData.BinaryItem) -> Unit = {},
+) = safely {
+    val multipartData = receiveMultipart()
+
+    var resultInput: MPPFile? = null
+
+    multipartData.forEachPart {
+        when (it) {
+            is PartData.FormItem -> onFormItem(it)
+            is PartData.FileItem -> {
+                if (it.name == "bytes") {
+                    val name = FileName(it.originalFileName ?: error("File name is unknown for default part"))
+                    resultInput = MPPFile.createTempFile(
+                        name.nameWithoutExtension.let {
+                            var resultName = it
+                            while (resultName.length < 3) {
+                                resultName += "_"
+                            }
+                            resultName
+                        },
+                        ".${name.extension}"
+                    ).apply {
+                        outputStream().use { fileStream ->
+                            it.streamProvider().use {
+                                it.copyTo(fileStream)
+                            }
+                        }
+                    }
+                } else {
+                    onCustomFileItem(it)
+                }
+            }
+            is PartData.BinaryItem -> onBinaryContent(it)
+            is PartData.BinaryChannelItem -> onBinaryChannelItem(it)
+        }
+    }
+
+    resultInput ?: error("Bytes has not been received")
+}
+
 suspend fun ApplicationCall.getParameterOrSendError(
     field: String
 ) = parameters[field].also {
@@ -124,6 +286,7 @@ suspend fun ApplicationCall.getQueryParameterOrSendError(
     }
 }
 
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
 fun <T> ApplicationCall.decodeUrlQueryValue(
     field: String,
     deserializer: DeserializationStrategy<T>
@@ -134,6 +297,7 @@ fun <T> ApplicationCall.decodeUrlQueryValue(
     )
 }
 
+@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
 suspend fun <T> ApplicationCall.decodeUrlQueryValueOrSendError(
     field: String,
     deserializer: DeserializationStrategy<T>

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

@@ -1,7 +1,9 @@
 package dev.inmo.micro_utils.ktor.server
 
-import io.ktor.application.Application
+import dev.inmo.micro_utils.ktor.server.configurators.KtorApplicationConfigurator
+import io.ktor.server.application.Application
 import io.ktor.server.cio.CIO
+import io.ktor.server.cio.CIOApplicationEngine
 import io.ktor.server.engine.*
 import kotlin.random.Random
 
@@ -9,16 +11,57 @@ fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configurati
     engine: ApplicationEngineFactory<TEngine, TConfiguration>,
     host: String = "localhost",
     port: Int = Random.nextInt(1024, 65535),
+    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
+    additionalConfigurationConfigurator: TConfiguration.() -> Unit = {},
     block: Application.() -> Unit
-): TEngine {
-    val env = applicationEngineEnvironment {
+): TEngine = embeddedServer(
+    engine,
+    applicationEngineEnvironment {
         module(block)
         connector {
-            this@connector.host = host
-            this@connector.port = port
+            this.host = host
+            this.port = port
         }
-    }
-    return embeddedServer(engine, env)
+        additionalEngineEnvironmentConfigurator()
+    },
+    additionalConfigurationConfigurator
+)
+
+/**
+ * Create server with [CIO] server engine without starting of it
+ *
+ * @see ApplicationEngine.start
+ */
+fun createKtorServer(
+    host: String = "localhost",
+    port: Int = Random.nextInt(1024, 65535),
+    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
+    additionalConfigurationConfigurator: CIOApplicationEngine.Configuration.() -> Unit = {},
+    block: Application.() -> Unit
+): CIOApplicationEngine = createKtorServer(
+    CIO,
+    host,
+    port,
+    additionalEngineEnvironmentConfigurator,
+    additionalConfigurationConfigurator,
+    block
+)
+
+fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configuration> createKtorServer(
+    engine: ApplicationEngineFactory<TEngine, TConfiguration>,
+    host: String = "localhost",
+    port: Int = Random.nextInt(1024, 65535),
+    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
+    additionalConfigurationConfigurator: TConfiguration.() -> Unit = {},
+    configurators: List<KtorApplicationConfigurator>
+): TEngine = createKtorServer(
+    engine,
+    host,
+    port,
+    additionalEngineEnvironmentConfigurator,
+    additionalConfigurationConfigurator
+) {
+    configurators.forEach { it.apply { configure() } }
 }
 
 /**
@@ -29,5 +72,7 @@ fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configurati
 fun createKtorServer(
     host: String = "localhost",
     port: Int = Random.nextInt(1024, 65535),
-    block: Application.() -> Unit
-): ApplicationEngine = createKtorServer(CIO, host, port, block)
+    configurators: List<KtorApplicationConfigurator>,
+    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
+    additionalConfigurationConfigurator: CIOApplicationEngine.Configuration.() -> Unit = {},
+): ApplicationEngine = createKtorServer(CIO, host, port, additionalEngineEnvironmentConfigurator, additionalConfigurationConfigurator, configurators)

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

@@ -0,0 +1,133 @@
+package dev.inmo.micro_utils.ktor.server
+
+import com.benasher44.uuid.uuid4
+import dev.inmo.micro_utils.common.FileName
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.micro_utils.ktor.common.DefaultTemporalFilesSubPath
+import dev.inmo.micro_utils.ktor.common.TemporalFileId
+import dev.inmo.micro_utils.ktor.server.configurators.ApplicationRoutingConfigurator
+import io.ktor.http.HttpStatusCode
+import io.ktor.http.content.PartData
+import io.ktor.http.content.streamProvider
+import io.ktor.server.application.call
+import io.ktor.server.request.receiveMultipart
+import io.ktor.server.response.respond
+import io.ktor.server.response.respondText
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.post
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.attribute.FileTime
+
+class TemporalFilesRoutingConfigurator(
+    private val subpath: String = DefaultTemporalFilesSubPath,
+    private val unifiedRouter: UnifiedRouter = UnifiedRouter.default,
+    private val temporalFilesUtilizer: TemporalFilesUtilizer = TemporalFilesUtilizer
+) : ApplicationRoutingConfigurator.Element {
+    interface TemporalFilesUtilizer {
+        fun start(filesMap: MutableMap<TemporalFileId, MPPFile>, filesMutex: Mutex, onNewFileFlow: Flow<TemporalFileId>): Job
+
+        companion object : TemporalFilesUtilizer {
+            class ByTimerUtilizer(
+                private val removeMillis: Long,
+                private val scope: CoroutineScope
+            ) : TemporalFilesUtilizer {
+                override fun start(
+                    filesMap: MutableMap<TemporalFileId, MPPFile>,
+                    filesMutex: Mutex,
+                    onNewFileFlow: Flow<TemporalFileId>
+                ): Job = scope.launchSafelyWithoutExceptions {
+                    while (isActive) {
+                        val filesWithCreationInfo = filesMap.mapNotNull { (fileId, file) ->
+                            fileId to ((Files.getAttribute(file.toPath(), "creationTime") as? FileTime) ?.toMillis() ?: return@mapNotNull null)
+                        }
+                        if (filesWithCreationInfo.isEmpty()) {
+                            delay(removeMillis)
+                            continue
+                        }
+                        var min = filesWithCreationInfo.first()
+                        for (fileWithCreationInfo in filesWithCreationInfo) {
+                            if (fileWithCreationInfo.second < min.second) {
+                                min = fileWithCreationInfo
+                            }
+                        }
+                        delay(System.currentTimeMillis() - (min.second + removeMillis))
+                        filesMutex.withLock {
+                            filesMap.remove(min.first)
+                        } ?.delete()
+                    }
+
+                }
+            }
+
+            override fun start(
+                filesMap: MutableMap<TemporalFileId, MPPFile>,
+                filesMutex: Mutex,
+                onNewFileFlow: Flow<TemporalFileId>
+            ): Job = Job()
+        }
+    }
+
+    private val temporalFilesMap = mutableMapOf<TemporalFileId, MPPFile>()
+    private val temporalFilesMutex = Mutex()
+    private val filesFlow = MutableSharedFlow<TemporalFileId>()
+    val utilizerJob = temporalFilesUtilizer.start(temporalFilesMap, temporalFilesMutex, filesFlow.asSharedFlow())
+
+    override fun Route.invoke() {
+        post(subpath) {
+            unifiedRouter.apply {
+                val multipart = call.receiveMultipart()
+
+                var fileInfo: Pair<TemporalFileId, MPPFile>? = null
+                var part = multipart.readPart()
+
+                while (part != null) {
+                    if (part is PartData.FileItem) {
+                        break
+                    }
+                    part = multipart.readPart()
+                }
+
+                part ?.let {
+                    if (it is PartData.FileItem) {
+                        val fileId = TemporalFileId(uuid4().toString())
+                        val fileName = it.originalFileName ?.let { FileName(it) } ?: return@let
+                        fileInfo = fileId to File.createTempFile(fileId.string, ".${fileName.extension}").apply {
+                            outputStream().use { outputStream ->
+                                it.streamProvider().use {
+                                    it.copyTo(outputStream)
+                                }
+                            }
+                            deleteOnExit()
+                        }
+                    }
+                }
+
+                fileInfo ?.also { (fileId, file) ->
+                    temporalFilesMutex.withLock {
+                        temporalFilesMap[fileId] = file
+                    }
+                    call.respondText(fileId.string)
+                    launchSafelyWithoutExceptions { filesFlow.emit(fileId) }
+                } ?: call.respond(HttpStatusCode.BadRequest)
+            }
+        }
+    }
+
+    suspend fun removeTemporalFile(temporalFileId: TemporalFileId) {
+        temporalFilesMutex.withLock {
+            temporalFilesMap.remove(temporalFileId)
+        }
+    }
+
+    fun getTemporalFile(temporalFileId: TemporalFileId) = temporalFilesMap[temporalFileId]
+
+    suspend fun getAndRemoveTemporalFile(temporalFileId: TemporalFileId) = temporalFilesMutex.withLock {
+        temporalFilesMap.remove(temporalFileId)
+    }
+}

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

@@ -1,14 +1,15 @@
 package dev.inmo.micro_utils.ktor.server.configurators
 
-import io.ktor.application.Application
-import io.ktor.application.install
-import io.ktor.features.CachingHeaders
+import io.ktor.server.application.Application
+import io.ktor.server.application.install
+import io.ktor.server.plugins.cachingheaders.CachingHeaders
+import io.ktor.server.plugins.cachingheaders.CachingHeadersConfig
 import kotlinx.serialization.Contextual
 
 data class ApplicationCachingHeadersConfigurator(
     private val elements: List<@Contextual Element>
 ) : KtorApplicationConfigurator {
-    fun interface Element { operator fun CachingHeaders.Configuration.invoke() }
+    fun interface Element { operator fun CachingHeadersConfig.invoke() }
 
     override fun Application.configure() {
         install(CachingHeaders) {

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

@@ -1,8 +1,9 @@
 package dev.inmo.micro_utils.ktor.server.configurators
 
-import io.ktor.application.*
-import io.ktor.routing.Route
-import io.ktor.routing.Routing
+import dev.inmo.micro_utils.ktor.server.configurators.ApplicationRoutingConfigurator.Element
+import io.ktor.server.application.*
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.Routing
 import kotlinx.serialization.Contextual
 import kotlinx.serialization.Serializable
 
@@ -18,7 +19,7 @@ class ApplicationRoutingConfigurator(
     }
 
     override fun Application.configure() {
-        featureOrNull(Routing) ?.apply {
+        pluginOrNull(Routing) ?.apply {
             rootInstaller.apply { invoke() }
         } ?: install(Routing) {
             rootInstaller.apply { invoke() }

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

@@ -1,14 +1,15 @@
 package dev.inmo.micro_utils.ktor.server.configurators
 
-import io.ktor.application.Application
-import io.ktor.application.install
-import io.ktor.sessions.Sessions
+import io.ktor.server.application.Application
+import io.ktor.server.application.install
+import io.ktor.server.sessions.Sessions
+import io.ktor.server.sessions.SessionsConfig
 import kotlinx.serialization.Contextual
 
 class ApplicationSessionsConfigurator(
     private val elements: List<@Contextual Element>
 ) : KtorApplicationConfigurator {
-    fun interface Element { operator fun Sessions.Configuration.invoke() }
+    fun interface Element { operator fun SessionsConfig.invoke() }
 
     override fun Application.configure() {
         install(Sessions) {

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

@@ -1,6 +1,6 @@
 package dev.inmo.micro_utils.ktor.server.configurators
 
-import io.ktor.application.Application
+import io.ktor.server.application.Application
 
 interface KtorApplicationConfigurator {
     fun Application.configure()

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

@@ -1,14 +1,15 @@
 package dev.inmo.micro_utils.ktor.server.configurators
 
-import io.ktor.application.Application
-import io.ktor.application.install
-import io.ktor.features.StatusPages
+import io.ktor.server.application.Application
+import io.ktor.server.application.install
+import io.ktor.server.plugins.statuspages.StatusPages
+import io.ktor.server.plugins.statuspages.StatusPagesConfig
 import kotlinx.serialization.Contextual
 
 class StatusPagesConfigurator(
     private val elements: List<@Contextual Element>
 ) : KtorApplicationConfigurator {
-    fun interface Element { operator fun StatusPages.Configuration.invoke() }
+    fun interface Element { operator fun StatusPagesConfig.invoke() }
 
     override fun Application.configure() {
         install(StatusPages) {

language_codes/generator/build.gradle

@@ -4,8 +4,8 @@ buildscript {
     }
 
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
+        classpath libs.buildscript.kt.gradle
+        classpath libs.buildscript.kt.serialization
     }
 }
 
@@ -16,11 +16,11 @@ plugins {
 }
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-    implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialisation_core_version"
+    implementation libs.kt.stdlib
+    implementation libs.kt.serialization
 
-    implementation "io.ktor:ktor-client-core:$ktor_version"
-    implementation "io.ktor:ktor-client-java:$ktor_version"
+    implementation libs.ktor.client
+    implementation libs.ktor.client.java
 }
 
 mainClassName="MainKt"

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

@@ -1,5 +1,6 @@
 import io.ktor.client.HttpClient
 import io.ktor.client.request.get
+import io.ktor.client.statement.bodyAsText
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.builtins.ListSerializer
@@ -164,7 +165,7 @@ suspend fun main(vararg args: String) {
 
     val ietfLanguageCodes = json.decodeFromString(
         ListSerializer(LanguageCode.serializer()),
-        client.get(ietfLanguageCodesLink)
+        client.get(ietfLanguageCodesLink).bodyAsText()
     ).map {
         it.copy(
             title = it.title
@@ -175,7 +176,7 @@ suspend fun main(vararg args: String) {
     }
     val ietfLanguageCodesWithTagsMap = json.decodeFromString(
         ListSerializer(LanguageCodeWithTag.serializer()),
-        client.get(ietfLanguageCodesAdditionalTagsLink)
+        client.get(ietfLanguageCodesAdditionalTagsLink).bodyAsText()
     ).filter { it.withSubtag != it.tag }.groupBy { it.tag }
 
     val tags = ietfLanguageCodes.map {

mime_types/mimes_generator/mime_generator.py

@@ -0,0 +1,52 @@
+import requests
+from bs4 import BeautifulSoup
+import pandas as pd
+import itertools
+
+def fix_name(category, raw_name):
+    splitted = raw_name.replace('-', '+').replace('.', '+').replace(',', '+').split('+')
+    out1 = ""
+    for s in splitted:
+        out1 += s.capitalize()
+
+    result = ""
+    if out1[0].isdigit():
+        result += category[0].capitalize()
+        result += out1
+    else:
+        result += out1
+    return result
+
+if __name__ == '__main__':
+    df = pd.read_html(open('table.html', 'r'))
+    mimes = []
+    for row in df[0].iterrows():
+        mime = row[1][1]
+        mime_category = mime.split('/', 1)[0]
+        mime_name = mime.split('/', 1)[1]
+        mimes.append({
+            'mime_category': mime_category,
+            'mime_name': mime_name,
+        })
+
+    # codegen
+
+    mimes.sort(key=lambda x: x['mime_category'])
+    grouped = itertools.groupby(mimes, lambda x: x['mime_category'])
+    code = ''
+    code2 = 'internal val knownMimeTypes: Set<MimeType> = setOf(\n'
+    code2 += '    KnownMimeTypes.Any,\n'
+    for key, group in grouped:
+        group_name = key.capitalize()
+        code += '@Serializable(MimeTypeSerializer::class)\nsealed class %s(raw: String) : MimeType, KnownMimeTypes(raw) {\n' % group_name
+        code += '    @Serializable(MimeTypeSerializer::class)\n    object Any: %s ("%s/*")\n' % (group_name, key)
+        for mime in group:
+            name = fix_name(mime['mime_category'], mime['mime_name'])
+            code += '    @Serializable(MimeTypeSerializer::class)\n    object %s: %s ("%s/%s")\n' % (name, group_name, mime['mime_category'], mime['mime_name'])
+            code2 += '    KnownMimeTypes.%s.%s,\n' % (group_name, name)
+        code += '}\n\n'
+    code2 += ')\n'
+    with open('out1.txt', 'w') as file:
+        file.write(code)
+    with open('out2.txt', 'w') as file:
+        file.write(code2)

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

@@ -2017,6 +2017,7 @@ internal val knownMimeTypes: Set<MimeType> = setOf(
     KnownMimeTypes.Chemical.XCml,
     KnownMimeTypes.Chemical.XCsml,
     KnownMimeTypes.Chemical.XXyz,
+    KnownMimeTypes.Image.Any,
     KnownMimeTypes.Image.Bmp,
     KnownMimeTypes.Image.Cgm,
     KnownMimeTypes.Image.G3fax,

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

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.mime_types
 
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.Serializer
+import kotlinx.serialization.*
 import kotlinx.serialization.descriptors.*
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
@@ -16,6 +15,7 @@ fun mimeType(raw: String) = mimesCache.getOrPut(raw) {
 
 internal fun parseMimeType(raw: String): MimeType = CustomMimeType(raw)
 
+@Suppress("OPT_IN_USAGE")
 @Serializer(MimeType::class)
 object MimeTypeSerializer : KSerializer<MimeType> {
     override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("mimeType", PrimitiveKind.STRING)

mppProjectWithSerialization.gradle

@@ -23,7 +23,7 @@ kotlin {
         commonMain {
             dependencies {
                 implementation kotlin('stdlib')
-                api "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialisation_core_version"
+                implementation libs.kt.serialization
             }
         }
         commonTest {
@@ -46,8 +46,8 @@ kotlin {
         androidTest {
             dependencies {
                 implementation kotlin('test-junit')
-                implementation "androidx.test.ext:junit:$test_ext_junit_version"
-                implementation "androidx.test.espresso:espresso-core:$espresso_core"
+                implementation libs.android.test.junit
+                implementation libs.android.espresso
             }
         }
     }