fixes in ExposedOneToManyKeyValueRepo and includeWebsocketHandling

0.9.6

.github/workflows/dokka_push.yml

@@ -11,8 +11,11 @@ jobs:
       - uses: actions/setup-java@v1
         with:
           java-version: 11
+      - name: Fix android 32.0.0 dx
+        continue-on-error: true
+        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
       - name: Build
-        run: ./gradlew build && ./gradlew dokkaHtml
+        run: ./gradlew dokkaHtml
       - name: Publish KDocs
         uses: peaceiris/actions-gh-pages@v3
         with:

.github/workflows/packages_push.yml

@@ -1,14 +1,17 @@
 
-name: Build
+name: Publish package to GitHub Packages
 on: [push]
 jobs:
-  build:
+  publishing:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
           java-version: 11
+      - name: Fix android 32.0.0 dx
+        continue-on-error: true
+        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
       - name: Rewrite version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
@@ -19,6 +22,7 @@ jobs:
         run: ./gradlew build
       - name: Publish
         continue-on-error: true
-        run: ./gradlew publishAllPublicationsToGiteaRepository
+        run: ./gradlew --no-parallel publishAllPublicationsToGithubPackagesRepository -x signJsPublication -x signJvmPublication -x signKotlinMultiplatformPublication -x signAndroidDebugPublication -x signAndroidReleasePublication -x signKotlinMultiplatformPublication
         env:
-          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+          GITHUBPACKAGES_USER: ${{ github.actor }}
+          GITHUBPACKAGES_PASSWORD: ${{ secrets.GITHUB_TOKEN }}

.space.kts

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

CHANGELOG.md

@@ -1,789 +1,5 @@
 # Changelog
 
-## 0.18.1
-
-* `Common`:
-    * Add `MapDiff`
-* `Coroutines`:
-    * Add `SmartMutex`
-
-## 0.18.0
-
-**ALL PREVIOUSLY DEPRECATED FUNCTIONALITY HAVE BEEN REMOVED**
-
-* `Versions`:
-    * `Android Fragments`: `1.5.6` -> `1.5.7`
-* `Ktor`:
-    * `Server`:
-        * Now it is possible to take query parameters as list
-* `Repos`:
-    * `Common`:
-        * New `WriteKeyValuesRepo.removeWithValue`
-    * `Cache`:
-        * Rename full caching factories functions to `fullyCached`
-
-## 0.17.8
-
-* `Versions`:
-    * `Ktor`: `2.2.4` -> `2.3.0`
-
-## 0.17.7
-
-* `Versions`:
-    * `Android CoreKtx`: `1.9.0` -> `1.10.0`
-* `Startup`:
-    * Add support of `linuxX64` and `mingwX64` platforms
-
-## 0.17.6
-
-* `Versions`:
-    * `Kotlin`: `1.8.10` -> `1.8.20`
-    * `KSLog`: `1.0.0` -> `1.1.1`
-    * `Compose`: `1.3.1` -> `1.4.0`
-    * `Koin`: `3.3.2` -> `3.4.0`
-    * `RecyclerView`: `1.2.1` -> `1.3.0`
-    * `Fragment`: `1.5.5` -> `1.5.6`
-* Experimentally (`!!!`) add `linuxX64` and `mingwX64` targets
-
-## 0.17.5
-
-* `Common`:
-    * Conversations of number primitives with bounds care
-* `Repos`:
-    * `Common`:
-        * By default, `getAll` for repos will take all the size of repo as page size
-        * New extension for all built-in repos `maxPagePagination`
-    * All the repos got `getAll` functions
-
-## 0.17.4
-
-* `Serialization`:
-    * `Mapper`:
-        * Module inited
-* `Versions`:
-    * `Compose`: `1.3.1-rc02` -> `1.3.1`
-
-## 0.17.3
-
-* `Common`:
-    * Add `fixed` extensions for `Float` and `Double`
-    * New function `emptyDiff`
-    * Now you may pass custom `comparisonFun` to all `diff` functions
-
-## 0.17.2
-
-* `FSM`:
-    * `DefaultStatesManager.onUpdateContextsConflictResolver` and `DefaultStatesManager.onStartContextsConflictResolver` now return `false` by default
-
-## 0.17.1
-
-* **Hotfix** for absence of jvm dependencies in android modules
-* `Versions`:
-    * `Ktor`: `2.2.3` -> `2.2.4`
-
-## 0.17.0
-
-* `Versions`:
-    * `Kotlin`: `1.7.20` -> `1.8.10`
-    * `Serialization`: `1.4.1` -> `1.5.0`
-    * `KSLog`: `0.5.4` -> `1.0.0`
-    * `AppCompat`: `1.6.0` -> `1.6.1`
-
-## 0.16.13
-
-* `Repos`:
-    * `Generator`:
-        * Module has been created
-
-## 0.16.12
-
-* `Repos`:
-    * `Exposed`:
-        * `CommonExposedRepo.selectByIds` uses `foldRight` by default instead of raw foreach
-* `Koin`:
-    * `Generator`:
-        * Module has been created
-
-## 0.16.11
-
-* `LanguageCodes`:
-    * In android and JVM targets now available `toJavaLocale` and from Java `Locale` conversations from/to
-      `IetfLanguageCode`
-
-## 0.16.10
-
-* `Repos`:
-    * `Cache`:
-        * New transformer type: `ReadCRUDFromKeyValueRepo`
-        * New transformer type: `ReadKeyValueFromCRUDRepo`
-* `Pagination`:
-    * New `paginate` extensions with `reversed` support for `List`/`Set`
-
-## 0.16.9
-
-* `Versions`:
-    * `Koin`: `3.2.2` -> `3.3.2`
-    * `AppCompat`: `1.5.1` -> `1.6.0`
-* `Ktor`:
-    * `Client`
-        * `HttpResponse.bodyOrNull` now retrieve callback to check if body should be received or null
-        * New extension `HttpResponse.bodyOrNullOnNoContent`
-
-## 0.16.8
-
-* `Versions`:
-    * `Ktor`: `2.2.2` -> `2.2.3`
-* `Ktor`:
-    * `Client`
-        * Fixes in `HttpClient.uniUpload`
-    * `Server`
-        * Fixes in `PartData.FileItem.download`
-* `Repos`:
-    * `Cache`:
-        * New type of caches: `FallbackCacheRepo`
-        * Fixes in `Write*` variants of cached repos
-        * New type `ActionWrapper`
-        * New `AutoRecache*` classes for all types of repos as `FallbackCacheRepo`s
-    * `Common`:
-        * New transformations for key-value and key-values vice-verse
-        * Fixes in `FileReadKeyValueRepo`
-
-## 0.16.7
-
-* `Common`:
-    * New extensions `ifTrue`/`ifFalse`/`alsoIfTrue`/`alsoIfFalse`/`letIfTrue`/`letIfFalse`
-    * `Diff` now is serializable
-    * Add `IndexedValue` serializer
-    * `repeatOnFailure` extending: now you may pass any lambda to check if continue to try/do something
-    * `Compose`:
-        * New extension `MutableState.asState`
-* `Coroutines`:
-    * `Compose`:
-        * All the `Flow` conversations to compose `State`/`MutableState`/`SnapshotStateList`/`List` got several new
-        parameters
-        * `Flow.toMutableState` now is deprecated in favor to `asMutableComposeState`
-* `Repos`:
-    * `Cache`:
-        * New type `FullCacheRepo`
-        * New type `CommonCacheRepo`
-        * `CacheRepo` got `invalidate` method. It will fully reload `FullCacheRepo` and just clear `CommonCacheRepo`
-        * New extensions `KVCache.actualizeAll`
-
-## 0.16.6
-
-* `Startup`:
-    * `Launcher`:
-        * Improvements in `StartLauncherPlugin#start` methods
-        * Add opportunity to pass second argument on `JVM` platform as log level
-* `Repos`:
-    * `Ktor`:
-        * `Client`:
-            * All clients repos got opportunity to customize their flows
-    * `Exposed`:
-        * Extensions `eqOrIsNull` and `neqOrIsNotNull` for `Column`
-
-## 0.16.5
-
-* `Versions`:
-    * `Ktor`: `2.2.1` -> `2.2.2`
-
-## 0.16.4
-
-* `Coroutines`:
-    * Create `launchInCurrentThread`
-
-## 0.16.3
-
-* `Startup`:
-    * `Launcher`:
-        * All starting API have been moved into `StartLauncherPlugin` and do not require serialize/deserialize cycle for now
-
-## 0.16.2
-
-* `Versions`:
-    * `Compose`: `1.2.1` -> `1.2.2`
-* `Startup`:
-    * Module become available on `JS` target
-
-## 0.16.1
-
-* `Coroutines`:
-    * New `runCatchingSafely`/`safelyWithResult` with receivers
-* `SafeWrapper`:
-    * Module inited
-
-## 0.16.0
-
-* `Versions`:
-    * `Ktor`: `2.1.3` -> `2.2.1`
-    * `Android Fragment`: `1.5.3` -> `1.5.5`
-
-## 0.15.1
-
-* `Startup`:
-    * Inited :)
-    * `Plugin`:
-        * Inited :)
-    * `Launcher`:
-        * Inited :)
-
-## 0.15.0
-
-* `Repos`:
-    * `CRUD`:
-        * `Common`:
-            * New method `ReadCRUDRepo#getIdsByPagination`
-        * `Android`:
-            * `AbstractAndroidCRUDRepo` got new abstract method `toId`
-        * `Exposed`:
-            * `CommonExposedRepo` new abstract property `asId`
-        * `Ktor`:
-            * `Client`:
-                * `KtorReadCRUDRepoClient` now requires `paginationIdType`
-* `LanguageCodes`:
-    * Updates and fixes in generation
-* `MimeTypes`:
-    * Updates and fixes in generation
-
-## 0.14.4
-
-* `Common`:
-    * `JVM`:
-        * New extension `downloadToTempFile`
-* `Ktor`:
-    * `Server`:
-        * Small fix in `handleUniUpload`
-        * `ApplicationCall#uniloadMultipartFile` now uses `uniloadMultipart`
-    * `Common`:
-        * New extension `downloadToTempFile`
-    * `Client`:
-        * New extensions on top of `uniUpload`
-
-## 0.14.3
-
-* `Common`:
-    * New type `Progress`
-* `Ktor`:
-    * `Client`:
-        * New universal `uniUpload` extension for `HttpClient`
-    * `Server`:
-        * New universal `handleUniUpload` extension for `ApplicationCall`
-        * Add extensions `download` and `downloadToTemporalFile`
-
-## 0.14.2
-
-* `Versions`:
-    * `Exposed`: `0.40.1` -> `0.41.1`
-
-
-## 0.14.1
-
-* `Versions`:
-    * `Klock`: `3.3.1` -> `3.4.0`
-    * `UUID`: `0.5.0` -> `0.6.0`
-
-## 0.14.0
-
-**ALL DEPRECATIONS HAVE BEEN REMOVED**
-
-* `Versions`:
-    * `Kotlin`: `1.7.10` -> `1.7.20`
-    * `Klock`: `3.3.0` -> `3.3.1`
-    * `Compose`: `1.2.0` -> `1.2.1`
-    * `Exposed`: `0.39.2` -> `0.40.1`
-
-## 0.13.2
-
-* `Versions`:
-    * `Klock`: `3.1.0` -> `3.3.0`
-    * `Ktor`: `2.1.2` -> `2.1.3`
-
-## 0.13.1
-
-* `Repos`:
-    * `Exposed`:
-      * `AbstractExposedWriteCRUDRepo#createAndInsertId` now is optional and returns nullable value
-
-## 0.13.0
-
-**ALL DEPRECATIONS HAVE BEEN REMOVED**
-**A LOT OF KTOR METHODS RELATED TO UnifierRouter/UnifiedRequester HAVE BEEN REMOVED**
-
-* `Repos`:
-  * `Exposed`:
-    * `AbstractExposedWriteCRUDRepo` got two new methods: `update` with `it` as `UpdateBuilder<Int>` and `createAndInsertId`
-      * Old `update` method has been deprecated and not recommended to override anymore in realizations
-      * Old `insert` method now is `open` instead of `abstract` and can be omitted
-    * `AbstractExposedKeyValueRepo` got two new methods: `update` with `it` as `UpdateBuilder<Int>` and `insertKey`
-      * Old `update` method has been deprecated and not recommended to override anymore
-      * Old `insert` method now is `open` instead of `abstract` and can be omitted in realizations
-
-## 0.12.17
-
-* `Versions`:
-    * `JB Compose`: `1.2.0-alpha01-dev774` -> `1.2.0-beta02`
-    * `Ktor`: `2.1.1` -> `2.1.2`
-    * `Koin`: `3.2.0` -> `3.2.2`
-
-## 0.12.16
-
-* `Coroutines`:
-  * `Android`:
-    * Add class `FlowOnHierarchyChangeListener`
-    * Add `ViewGroup#setOnHierarchyChangeListenerRecursively(OnHierarchyChangeListener)`
-
-## 0.12.15
-
-* `Common`:
-    * `applyDiff` will return `Diff` object since this release
-    * `Android`:
-      * New functions/extensions `findViewsByTag` and `findViewsByTagInActivity`
-* `Coroutines`:
-    * Add `Flow` extensions `flatMap`, `flatMapNotNull` and `flatten`
-    * Add `Flow` extensions `takeNotNull` and `filterNotNull`
-
-## 0.12.14
-
-* `Versions`:
-  * `Android CoreKTX`: `1.8.0` -> `1.9.0`
-  * `Android AppCompat`: `1.4.2` -> `1.5.1`
-  * Android Compile SDK: 32 -> 33
-  * Android Build Tools: 32.0.0 -> 33.0.0
-* `Common`:
-  * `Android`:
-    * Add `argumentOrNull`/`argumentOrThrow` delegates for fragments
-* `Coroutines`:
-  * Rewrite `awaitFirstWithDeferred` onto `CompletableDeferred` instead of coroutines suspending
-
-## 0.12.13
-
-* `Coroutines`:
-  * Add opportunity to use markers in actors (solution of [#160](https://github.com/InsanusMokrassar/MicroUtils/issues/160))
-* `Koin`:
-  * Module inited :)
-* `Repos`:
-  * `Android`:
-    * Add typealias `KeyValueSPRepo` and opportunity to create shared preferences `KeyValue` repo with `KeyValueStore(...)` (fix of [#155](https://github.com/InsanusMokrassar/MicroUtils/issues/155))
-
-## 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`:

android/alerts/common/build.gradle

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

android/recyclerview/build.gradle

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

build.gradle

@@ -7,13 +7,12 @@ buildscript {
     }
 
     dependencies {
-        classpath libs.buildscript.kt.gradle
-        classpath libs.buildscript.kt.serialization
-        classpath libs.buildscript.kt.ksp
-        classpath libs.buildscript.jb.dokka
-        classpath libs.buildscript.gh.release
-        classpath libs.buildscript.android.gradle
-        classpath libs.buildscript.android.dexcount
+        classpath 'com.android.tools.build:gradle:7.0.4'
+        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"
     }
 }
 
@@ -22,8 +21,6 @@ allprojects {
         mavenLocal()
         mavenCentral()
         google()
-        maven { url "https://maven.pkg.jetbrains.space/public/p/compose/dev" }
-        maven { url "https://git.inmo.dev/api/packages/InsanusMokrassar/maven" }
     }
 
     // temporal crutch until legacy tests will be stabled or legacy target will be removed

common/build.gradle

@@ -16,19 +16,6 @@ kotlin {
         androidMain {
             dependencies {
                 api project(":micro_utils.coroutines")
-                api libs.android.fragment
-            }
-            dependsOn jvmMain
-        }
-
-        linuxX64Main {
-            dependencies {
-                api libs.okio
-            }
-        }
-        mingwX64Main {
-            dependencies {
-                api libs.okio
             }
         }
     }

common/compose/build.gradle

@@ -1,18 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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/commonMain/kotlin/dev/inmo/micro_utils/common/compose/MutableStateAsState.kt

@@ -1,10 +0,0 @@
-package dev.inmo.micro_utils.common.compose
-
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.State
-import androidx.compose.runtime.derivedStateOf
-
-/**
- * Converts current [MutableState] to immutable [State] using [derivedStateOf]
- */
-fun <T> MutableState<T>.asState(): State<T> = derivedStateOf { this.value }

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

@@ -1,9 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

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

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

@@ -1,5 +1,3 @@
-@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

@@ -2,8 +2,6 @@
 
 package dev.inmo.micro_utils.common
 
-import kotlinx.serialization.Serializable
-
 private inline fun <T> getObject(
     additional: MutableList<T>,
     iterator: Iterator<T>
@@ -16,29 +14,16 @@ private inline fun <T> getObject(
 /**
  * Diff object which contains information about differences between two [Iterable]s
  *
- * See tests for more info
- *
- * @param removed The objects which has been presented in the old collection but absent in new one. Index here is the index in the old collection
- * @param added The object which appear in new collection only. Indexes here show the index in the new collection
- * @param replaced Pair of old-new changes. First object has been presented in the old collection on its
- * [IndexedValue.index] place, the second one is the object in new collection. Both have indexes due to the fact that in
- * case when some value has been replaced after adds or removes in original collection the object index will be changed
- *
  * @see calculateDiff
  */
-@Serializable
 data class Diff<T> internal constructor(
-    val removed: List<@Serializable(IndexedValueSerializer::class) IndexedValue<T>>,
+    val removed: List<IndexedValue<T>>,
     /**
      * Old-New values pairs
      */
-    val replaced: List<Pair<@Serializable(IndexedValueSerializer::class) IndexedValue<T>, @Serializable(IndexedValueSerializer::class) IndexedValue<T>>>,
-    val added: List<@Serializable(IndexedValueSerializer::class) IndexedValue<T>>
-) {
-    fun isEmpty(): Boolean = removed.isEmpty() && replaced.isEmpty() && added.isEmpty()
-}
-
-fun <T> emptyDiff(): Diff<T> = Diff(emptyList(), emptyList(), emptyList())
+    val replaced: List<Pair<IndexedValue<T>, IndexedValue<T>>>,
+    val added: List<IndexedValue<T>>
+)
 
 private inline fun <T> performChanges(
     potentialChanges: MutableList<Pair<IndexedValue<T>?, IndexedValue<T>?>>,
@@ -47,18 +32,17 @@ private inline fun <T> performChanges(
     changedList: MutableList<Pair<IndexedValue<T>, IndexedValue<T>>>,
     removedList: MutableList<IndexedValue<T>>,
     addedList: MutableList<IndexedValue<T>>,
-    comparisonFun: (T?, T?) -> Boolean
+    strictComparison: Boolean
 ) {
     var i = -1
     val (oldObject, newObject) = potentialChanges.lastOrNull() ?: return
     for ((old, new) in potentialChanges.take(potentialChanges.size - 1)) {
         i++
-        val oldOneEqualToNewObject = comparisonFun(old ?.value, newObject ?.value)
-        val newOneEqualToOldObject = comparisonFun(new ?.value, oldObject ?.value)
+        val oldOneEqualToNewObject = old ?.value === newObject ?.value || (old ?.value == newObject ?.value && !strictComparison)
+        val newOneEqualToOldObject = new ?.value === oldObject ?.value || (new ?.value == oldObject ?.value && !strictComparison)
         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
                 }
             )
@@ -108,7 +92,7 @@ private inline fun <T> performChanges(
  */
 fun <T> Iterable<T>.calculateDiff(
     other: Iterable<T>,
-    comparisonFun: (T?, T?) -> Boolean
+    strictComparison: Boolean = false
 ): Diff<T> {
     var i = -1
     var j = -1
@@ -136,60 +120,31 @@ fun <T> Iterable<T>.calculateDiff(
         }
 
         when {
-            comparisonFun(oldObject, newObject) -> {
-                changedObjects.addAll(potentiallyChangedObjects.map {
-                    @Suppress("UNCHECKED_CAST")
-                    it as Pair<IndexedValue<T>, IndexedValue<T>>
-                })
+            oldObject === newObject || (oldObject == newObject && !strictComparison) -> {
+                changedObjects.addAll(potentiallyChangedObjects.map { it as Pair<IndexedValue<T>, IndexedValue<T>> })
                 potentiallyChangedObjects.clear()
             }
             else -> {
                 potentiallyChangedObjects.add(oldObject ?.let { IndexedValue(i, oldObject) } to newObject ?.let { IndexedValue(j, newObject) })
                 val previousOldsAdditionsSize = additionalInOld.size
                 val previousNewsAdditionsSize = additionalInNew.size
-                performChanges(potentiallyChangedObjects, additionalInOld, additionalInNew, changedObjects, removedObjects, addedObjects, comparisonFun)
+                performChanges(potentiallyChangedObjects, additionalInOld, additionalInNew, changedObjects, removedObjects, addedObjects, strictComparison)
                 i -= (additionalInOld.size - previousOldsAdditionsSize)
                 j -= (additionalInNew.size - previousNewsAdditionsSize)
             }
         }
     }
     potentiallyChangedObjects.add(null to null)
-    performChanges(potentiallyChangedObjects, additionalInOld, additionalInNew, changedObjects, removedObjects, addedObjects, comparisonFun)
+    performChanges(potentiallyChangedObjects, additionalInOld, additionalInNew, changedObjects, removedObjects, addedObjects, strictComparison)
 
     return Diff(removedObjects.toList(), changedObjects.toList(), addedObjects.toList())
 }
-
-/**
- * Calculating [Diff] object
- *
- * @param strictComparison If this parameter set to true, objects which are not equal by links will be used as different
- * objects. For example, in case of two "Example" string they will be equal by value, but CAN be different by links
- */
-fun <T> Iterable<T>.calculateDiff(
-    other: Iterable<T>,
-    strictComparison: Boolean = false
-): Diff<T> = calculateDiff(
-    other,
-    comparisonFun = if (strictComparison) {
-        { t1, t2 ->
-            t1 === t2
-        }
-    } else {
-        { t1, t2 ->
-            t1 === t2 || t1 == t2 // small optimization for cases when t1 and t2 are the same - comparison will be faster potentially
-        }
-    }
-)
 inline fun <T> Iterable<T>.diff(
     other: Iterable<T>,
     strictComparison: Boolean = false
 ): Diff<T> = calculateDiff(other, strictComparison)
-inline fun <T> Iterable<T>.diff(
-    other: Iterable<T>,
-    noinline comparisonFun: (T?, T?) -> Boolean
-): Diff<T> = calculateDiff(other, comparisonFun)
 
-inline fun <T> Diff(old: Iterable<T>, new: Iterable<T>) = old.calculateDiff(new, strictComparison = false)
+inline fun <T> Diff(old: Iterable<T>, new: Iterable<T>) = old.calculateDiff(new)
 inline fun <T> StrictDiff(old: Iterable<T>, new: Iterable<T>) = old.calculateDiff(new, true)
 
 /**
@@ -198,52 +153,3 @@ 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)
-
-/**
- * Applies [diff] to [this] [MutableList]
- */
-fun <T> MutableList<T>.applyDiff(
-    diff: Diff<T>
-) {
-    for (i in diff.removed.indices.sortedDescending()) {
-        removeAt(diff.removed[i].index)
-    }
-    diff.added.forEach { (i, t) ->
-        add(i, t)
-    }
-    diff.replaced.forEach { (_, new) ->
-        set(new.index, new.value)
-    }
-}
-
-/**
- * This method call [calculateDiff] with strict mode [strictComparison] and then apply differences to [this]
- * mutable list
- */
-fun <T> MutableList<T>.applyDiff(
-    source: Iterable<T>,
-    strictComparison: Boolean = false
-): Diff<T> = calculateDiff(source, strictComparison).also {
-    applyDiff(it)
-}
-
-/**
- * This method call [calculateDiff] and then apply differences to [this]
- * mutable list
- */
-fun <T> MutableList<T>.applyDiff(
-    source: Iterable<T>,
-    comparisonFun: (T?, T?) -> Boolean
-): Diff<T> = calculateDiff(source, comparisonFun).also {
-    applyDiff(it)
-}
-
-/**
- * Reverse [this] [Diff]. Result will contain [Diff.added] on [Diff.removed] (and vice-verse), all the
- * [Diff.replaced] values will be reversed too
- */
-fun <T> Diff<T>.reversed() = Diff(
-    removed = added,
-    replaced = replaced.map { it.second to it.first },
-    added = removed
-)

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

@@ -1,5 +1,3 @@
-@file:Suppress("unused", "NOTHING_TO_INLINE")
-
 package dev.inmo.micro_utils.common
 
 import kotlinx.serialization.*
@@ -23,18 +21,26 @@ import kotlinx.serialization.encoding.*
 sealed interface Either<T1, T2> {
     val optionalT1: Optional<T1>
     val optionalT2: Optional<T2>
-
-    val t1OrNull: T1?
+    @Deprecated("Use optionalT1 instead", ReplaceWith("optionalT1"))
+    val t1: T1?
         get() = optionalT1.dataOrNull()
-    val t2OrNull: T2?
+    @Deprecated("Use optionalT2 instead", ReplaceWith("optionalT2"))
+    val t2: T2?
         get() = optionalT2.dataOrNull()
+
+    companion object {
+        fun <T1, T2> serializer(
+            t1Serializer: KSerializer<T1>,
+            t2Serializer: KSerializer<T2>,
+        ): KSerializer<Either<T1, T2>> = EitherSerializer(t1Serializer, t2Serializer)
+    }
 }
 
 class EitherSerializer<T1, T2>(
     t1Serializer: KSerializer<T1>,
     t2Serializer: KSerializer<T2>,
 ) : KSerializer<Either<T1, T2>> {
-    @OptIn(InternalSerializationApi::class, ExperimentalSerializationApi::class)
+    @OptIn(ExperimentalSerializationApi::class, InternalSerializationApi::class)
     override val descriptor: SerialDescriptor = buildSerialDescriptor(
         "TypedSerializer",
         SerialKind.CONTEXTUAL
@@ -45,6 +51,7 @@ class EitherSerializer<T1, T2>(
     private val t1EitherSerializer = EitherFirst.serializer(t1Serializer, t2Serializer)
     private val t2EitherSerializer = EitherSecond.serializer(t1Serializer, t2Serializer)
 
+    @OptIn(ExperimentalSerializationApi::class, InternalSerializationApi::class)
     override fun deserialize(decoder: Decoder): Either<T1, T2> {
         return decoder.decodeStructure(descriptor) {
             var type: String? = null
@@ -76,6 +83,7 @@ class EitherSerializer<T1, T2>(
     }
 
 
+    @OptIn(ExperimentalSerializationApi::class, InternalSerializationApi::class)
     override fun serialize(encoder: Encoder, value: Either<T1, T2>) {
         encoder.encodeStructure(descriptor) {
             when (value) {
@@ -97,7 +105,7 @@ class EitherSerializer<T1, T2>(
  */
 @Serializable
 data class EitherFirst<T1, T2>(
-    val t1: T1
+    override val t1: T1
 ) : Either<T1, T2> {
     override val optionalT1: Optional<T1> = t1.optional
     override val optionalT2: Optional<T2> = Optional.absent()
@@ -108,7 +116,7 @@ data class EitherFirst<T1, T2>(
  */
 @Serializable
 data class EitherSecond<T1, T2>(
-    val t2: T2
+    override val t2: T2
 ) : Either<T1, T2> {
     override val optionalT1: Optional<T1> = Optional.absent()
     override val optionalT2: Optional<T2> = t2.optional

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

@@ -1,43 +0,0 @@
-package dev.inmo.micro_utils.common
-
-inline fun <T> Boolean.letIfTrue(block: () -> T): T? {
-    return if (this) {
-        block()
-    } else {
-        null
-    }
-}
-
-inline fun <T> Boolean.letIfFalse(block: () -> T): T? {
-    return if (this) {
-        null
-    } else {
-        block()
-    }
-}
-
-inline fun Boolean.alsoIfTrue(block: () -> Unit): Boolean {
-    letIfTrue(block)
-    return this
-}
-
-inline fun Boolean.alsoIfFalse(block: () -> Unit): Boolean {
-    letIfFalse(block)
-    return this
-}
-
-inline fun <T> Boolean.ifTrue(block: () -> T): T? {
-    return if (this) {
-        block()
-    } else {
-        null
-    }
-}
-
-inline fun <T> Boolean.ifFalse(block: () -> T): T? {
-    return if (this) {
-        null
-    } else {
-        block()
-    }
-}

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

@@ -1,30 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.Serializer
-import kotlinx.serialization.builtins.PairSerializer
-import kotlinx.serialization.builtins.serializer
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-
-class IndexedValueSerializer<T>(private val subSerializer: KSerializer<T>) : KSerializer<IndexedValue<T>> {
-    private val originalSerializer = PairSerializer(Int.serializer(), subSerializer)
-    override val descriptor: SerialDescriptor
-        get() = originalSerializer.descriptor
-
-    override fun deserialize(decoder: Decoder): IndexedValue<T> {
-        val pair = originalSerializer.deserialize(decoder)
-        return IndexedValue(
-            pair.first,
-            pair.second
-        )
-    }
-
-    override fun serialize(encoder: Encoder, value: IndexedValue<T>) {
-        originalSerializer.serialize(
-            encoder,
-            Pair(value.index, value.value)
-        )
-    }
-}

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

@@ -1,135 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Contains diff based on the comparison of objects with the same [K].
- *
- * @param removed Contains map with keys removed from parent map
- * @param changed Contains map with keys values changed new map in comparison with old one
- * @param added Contains map with new keys and values
- */
-data class MapDiff<K, V> @Warning(warning) constructor(
-    val removed: Map<K, V>,
-    val changed: Map<K, Pair<V, V>>,
-    val added: Map<K, V>
-) {
-    fun isEmpty() = removed.isEmpty() && changed.isEmpty() && added.isEmpty()
-    inline fun isNotEmpty() = !isEmpty()
-
-    companion object {
-        private const val warning = "This feature can be changed without any warranties. Use with caution and only in case you know what you are doing"
-        fun <K, V> empty() = MapDiff<K, V>(emptyMap(), emptyMap(), emptyMap())
-    }
-}
-
-private inline fun <K, V> createCompareFun(
-    strictComparison: Boolean
-): (K, V, V) -> Boolean = if (strictComparison) {
-    { _, first, second -> first === second }
-} else {
-    { _, first, second -> first == second }
-}
-
-/**
- * Compare [this] [Map] with the [other] one in principle when [other] is newer than [this]
- *
- * @param compareFun Will be used to determine changed values
- */
-fun <K, V> Map<K, V>.diff(
-    other: Map<K, V>,
-    compareFun: (K, V, V) -> Boolean
-): MapDiff<K, V> {
-    val removed: Map<K, V> = (keys - other.keys).associateWith {
-        getValue(it)
-    }
-    val added: Map<K, V> = (other.keys - keys).associateWith {
-        other.getValue(it)
-    }
-    val changed = keys.intersect(other.keys).mapNotNull {
-        val old = getValue(it)
-        val new = other.getValue(it)
-        if (compareFun(it, old, new)) {
-            return@mapNotNull null
-        } else {
-            it to (old to new)
-        }
-    }.toMap()
-
-    return MapDiff(
-        removed,
-        changed,
-        added
-    )
-}
-
-/**
- * Compare [this] [Map] with the [other] one in principle when [other] is newer than [this]
- *
- * @param strictComparison If true, will use strict (===) comparison for the values' comparison. Otherwise, standard
- * `equals` will be used
- */
-fun <K, V> Map<K, V>.diff(
-    other: Map<K, V>,
-    strictComparison: Boolean = false
-): MapDiff<K, V> = diff(
-    other,
-    compareFun = createCompareFun(strictComparison)
-)
-
-/**
- * Will apply [mapDiff] to [this] [MutableMap]
- */
-fun <K, V> MutableMap<K, V>.applyDiff(
-    mapDiff: MapDiff<K, V>
-) {
-    mapDiff.apply {
-        removed.keys.forEach { remove(it) }
-        changed.forEach { (k, oldNew) ->
-            put(k, oldNew.second)
-        }
-        added.forEach { (k, new) ->
-            put(k, new)
-        }
-    }
-}
-
-/**
- * Will apply changes with [from] map into [this] one
- *
- * @param compareFun Will be used to determine changed values
- *
- * @return [MapDiff] applied to [this] [MutableMap]
- */
-fun <K, V> MutableMap<K, V>.applyDiff(
-    from: Map<K, V>,
-    compareFun: (K, V, V) -> Boolean
-): MapDiff<K, V> {
-    return diff(from, compareFun).also {
-        applyDiff(it)
-    }
-}
-
-/**
- * Will apply changes with [from] map into [this] one
- *
- * @param strictComparison If true, will use strict (===) comparison for the values' comparison. Otherwise, standard
- * `equals` will be used
- *
- * @return [MapDiff] applied to [this] [MutableMap]
- */
-fun <K, V> MutableMap<K, V>.applyDiff(
-    from: Map<K, V>,
-    strictComparison: Boolean = false
-): MapDiff<K, V> = applyDiff(
-    from,
-    compareFun = createCompareFun(strictComparison)
-)
-
-/**
- * Reverse [this] [MapDiff]. Result will contain [MapDiff.added] on [MapDiff.removed] (and vice-verse), all the
- * [MapDiff.changed] values will be reversed too
- */
-fun <K, V> MapDiff<K, V>.reversed(): MapDiff<K, V> = MapDiff(
-    removed = added,
-    changed = changed.mapValues { (_, oldNew) -> oldNew.second to oldNew.first },
-    added = removed
-)

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

@@ -1,53 +0,0 @@
-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

@@ -41,18 +41,10 @@ data class Optional<T> internal constructor(
 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) }
 }
 
@@ -60,7 +52,6 @@ inline fun <T> Optional<T>.onPresented(block: (T) -> Unit): Optional<T> = apply
  * 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
 }
 
@@ -68,7 +59,6 @@ inline fun <T, R> Optional<T>.mapOnPresented(block: (T) -> R): R? = run {
  * 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() }
 }
 
@@ -76,22 +66,27 @@ inline fun <T> Optional<T>.onAbsent(block: () -> Unit): Optional<T> = apply {
  * 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
+    if (!dataPresented) { @Suppress("UNCHECKED_CAST") block() } else null
 }
 
 /**
  * Returns [Optional.data] if [Optional.dataPresented] of [this] is true, or null otherwise
  */
-fun <T> Optional<T>.dataOrNull() = @OptIn(Warning::class) if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else null
+fun <T> Optional<T>.dataOrNull() = if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else null
 
 /**
  * Returns [Optional.data] if [Optional.dataPresented] of [this] is true, or throw [throwable] otherwise
  */
-fun <T> Optional<T>.dataOrThrow(throwable: Throwable) = @OptIn(Warning::class) if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else throw throwable
+fun <T> Optional<T>.dataOrThrow(throwable: Throwable) = if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else throw throwable
 
 
 /**
  * Returns [Optional.data] if [Optional.dataPresented] of [this] is true, or call [block] and returns the result of it
  */
-inline fun <T> Optional<T>.dataOrElse(block: () -> T) = @OptIn(Warning::class) if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else block()
+inline fun <T> Optional<T>.dataOrElse(block: () -> T) = if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else block()
+
+/**
+ * Returns [Optional.data] if [Optional.dataPresented] of [this] is true, or call [block] and returns the result of it
+ */
+@Deprecated("dataOrElse now is inline", ReplaceWith("dataOrElse", "dev.inmo.micro_utils.common.dataOrElse"))
+suspend fun <T> Optional<T>.dataOrElseSuspendable(block: suspend () -> T) = if (dataPresented) @Suppress("UNCHECKED_CAST") (data as T) else block()

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

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

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

@@ -1,37 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.serialization.Serializable
-import kotlin.jvm.JvmInline
-
-@Serializable
-@JvmInline
-value class Progress private constructor(
-    val of1: Double
-) {
-    val of1Float
-        get() = of1.toFloat()
-    val of100
-        get() = of1 * 100
-    val of100Float
-        get() = of100.toFloat()
-    val of100Int
-        get() = of100.toInt()
-
-    init {
-        require(of1 in rangeOfValues) {
-            "Progress main value should be in $rangeOfValues, but incoming value is $of1"
-        }
-    }
-
-    companion object {
-        val rangeOfValues = 0.0 .. 1.0
-
-        val START = Progress(rangeOfValues.start)
-        val COMPLETED = Progress(rangeOfValues.endInclusive)
-
-        operator fun invoke(of1: Double) = Progress(of1.coerceIn(rangeOfValues))
-        operator fun invoke(part: Number, total: Number) = Progress(
-            part.toDouble() / total.toDouble()
-        )
-    }
-}

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

@@ -1,80 +0,0 @@
-@file:Suppress(
-  "RemoveRedundantCallsOfConversionMethods",
-  "RedundantVisibilityModifier",
-)
-
-package dev.inmo.micro_utils.common
-
-import kotlin.Byte
-import kotlin.Double
-import kotlin.Float
-import kotlin.Int
-import kotlin.Long
-import kotlin.Short
-import kotlin.Suppress
-
-public operator fun Progress.plus(other: Progress): Progress = Progress(of1 + other.of1)
-
-public operator fun Progress.minus(other: Progress): Progress = Progress(of1 - other.of1)
-
-public operator fun Progress.plus(i: Byte): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Byte): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Byte): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Byte): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Byte): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.plus(i: Short): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Short): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Short): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Short): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Short): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.plus(i: Int): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Int): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Int): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Int): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Int): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.plus(i: Long): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Long): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Long): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Long): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Long): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.plus(i: Float): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Float): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Float): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Float): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Float): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.plus(i: Double): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Double): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Double): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Double): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Double): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.compareTo(other: Progress): Int = (of1 - other.of1).toInt()

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

@@ -1,27 +1,5 @@
 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(
-    onFailure: (Throwable) -> Boolean,
-    action: () -> R
-): Result<R> {
-    do {
-        runCatching {
-            action()
-        }.onFailure {
-            if (!onFailure(it)) {
-                return Result.failure(it)
-            }
-        }.onSuccess {
-            return Result.success(it)
-        }
-    } while (true)
-}
-
 /**
  * Executes the given [action] until getting of successful result specified number of [times].
  *
@@ -32,23 +10,12 @@ inline fun <R> repeatOnFailure(
     onEachFailure: (Throwable) -> Unit = {},
     action: (Int) -> R
 ): Optional<R> {
-    var i = 0
-    val result = repeatOnFailure(
-        {
-            onEachFailure(it)
-            if (i < times) {
-                i++
-                true
-            } else {
-                false
-            }
+    repeat(times) {
+        runCatching {
+            action(it)
+        }.onFailure(onEachFailure).onSuccess {
+            return Optional.presented(it)
         }
-    ) {
-        action(i)
-    }
-    return if (result.isSuccess) {
-        Optional.presented(result.getOrThrow())
-    } else {
-        Optional.absent()
     }
+    return Optional.absent()
 }

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

@@ -1,6 +0,0 @@
-package dev.inmo.micro_utils.common
-
-val FixedSignsRange = 0 .. 100
-
-expect fun Float.fixed(signs: Int): Float
-expect fun Double.fixed(signs: Int): Double

common/src/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, _) in withIndex) {
+            for ((i, v) 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 oldList.indices) {
-            for ((i, _) in withIndex) {
+        for (step in 0 until oldList.size) {
+            for ((i, v) in withIndex) {
                 val mutable = oldList.toMutableList()
                 val changes = (
                     if (step == 0) i until oldList.size else (i until oldList.size step step)
@@ -73,83 +73,4 @@ 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

@@ -1,61 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/OnClickOutside.kt

@@ -1,38 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/jsMain/kotlin/dev/inmo/micro_utils/common/toFixed.kt

@@ -1,4 +0,0 @@
-package dev.inmo.micro_utils.common
-
-actual fun Float.fixed(signs: Int): Float = this.asDynamic().toFixed(signs.coerceIn(FixedSignsRange)).unsafeCast<String>().toFloat()
-actual fun Double.fixed(signs: Int): Double = this.asDynamic().toFixed(signs.coerceIn(FixedSignsRange)).unsafeCast<String>().toDouble()

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

@@ -1,20 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import java.io.File
-import java.io.InputStream
-import java.util.UUID
-
-fun InputStream.downloadToTempFile(
-    fileName: String = UUID.randomUUID().toString(),
-    fileExtension: String? = ".temp",
-    folder: File? = null
-) = File.createTempFile(
-    fileName,
-    fileExtension,
-    folder
-).apply {
-    outputStream().use {
-        copyTo(it)
-    }
-    deleteOnExit()
-}

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

@@ -1,12 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import java.math.BigDecimal
-import java.math.RoundingMode
-
-actual fun Float.fixed(signs: Int): Float = BigDecimal.valueOf(this.toDouble())
-    .setScale(signs.coerceIn(FixedSignsRange), RoundingMode.HALF_UP)
-    .toFloat();
-
-actual fun Double.fixed(signs: Int): Double = BigDecimal.valueOf(this)
-    .setScale(signs.coerceIn(FixedSignsRange), RoundingMode.HALF_UP)
-    .toDouble();

common/src/linuxX64Main/kotlin/ActualMPPFile.kt

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

common/src/linuxX64Main/kotlin/fixed.kt

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

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

@@ -1,76 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import android.os.Bundle
-import android.os.Parcelable
-import androidx.fragment.app.Fragment
-import java.io.Serializable
-import kotlin.reflect.KProperty
-
-object ArgumentPropertyNullableDelegate {
-    operator fun <T: Any> getValue(thisRef: Fragment, property: KProperty<*>): T? {
-        val arguments = thisRef.arguments ?: return null
-        val key = property.name
-        return when (property.getter.returnType.classifier) {
-            // Scalars
-            String::class -> arguments.getString(key)
-            Boolean::class -> arguments.getBoolean(key)
-            Byte::class -> arguments.getByte(key)
-            Char::class -> arguments.getChar(key)
-            Double::class -> arguments.getDouble(key)
-            Float::class -> arguments.getFloat(key)
-            Int::class -> arguments.getInt(key)
-            Long::class -> arguments.getLong(key)
-            Short::class -> arguments.getShort(key)
-
-            // References
-            Bundle::class -> arguments.getBundle(key)
-            CharSequence::class -> arguments.getCharSequence(key)
-            Parcelable::class -> arguments.getParcelable(key)
-
-            // Scalar arrays
-            BooleanArray::class -> arguments.getBooleanArray(key)
-            ByteArray::class -> arguments.getByteArray(key)
-            CharArray::class -> arguments.getCharArray(key)
-            DoubleArray::class -> arguments.getDoubleArray(key)
-            FloatArray::class -> arguments.getFloatArray(key)
-            IntArray::class -> arguments.getIntArray(key)
-            LongArray::class -> arguments.getLongArray(key)
-            ShortArray::class -> arguments.getShortArray(key)
-            Array::class -> {
-                val componentType = property.returnType.classifier ?.javaClass ?.componentType!!
-                @Suppress("UNCHECKED_CAST") // Checked by reflection.
-                when {
-                    Parcelable::class.java.isAssignableFrom(componentType) -> {
-                        arguments.getParcelableArray(key)
-                    }
-                    String::class.java.isAssignableFrom(componentType) -> {
-                        arguments.getStringArray(key)
-                    }
-                    CharSequence::class.java.isAssignableFrom(componentType) -> {
-                        arguments.getCharSequenceArray(key)
-                    }
-                    Serializable::class.java.isAssignableFrom(componentType) -> {
-                        arguments.getSerializable(key)
-                    }
-                    else -> {
-                        val valueType = componentType.canonicalName
-                        throw IllegalArgumentException(
-                            "Illegal value array type $valueType for key \"$key\""
-                        )
-                    }
-                }
-            }
-            Serializable::class -> arguments.getSerializable(key)
-            else -> null
-        } as? T
-    }
-}
-
-object ArgumentPropertyNonNullableDelegate {
-    operator fun <T: Any> getValue(thisRef: Fragment, property: KProperty<*>): T {
-        return ArgumentPropertyNullableDelegate.getValue<T>(thisRef, property)!!
-    }
-}
-
-fun argumentOrNull() = ArgumentPropertyNullableDelegate
-fun argumentOrThrow() = ArgumentPropertyNonNullableDelegate

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

@@ -1,61 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import android.app.Activity
-import android.view.View
-import android.view.ViewGroup
-import androidx.core.view.children
-import androidx.fragment.app.Fragment
-
-fun findViewsByTag(viewGroup: ViewGroup, tag: Any?): List<View> {
-    return viewGroup.children.flatMap {
-        findViewsByTag(it, tag)
-    }.toList()
-}
-
-fun findViewsByTag(viewGroup: ViewGroup, key: Int, tag: Any?): List<View> {
-    return viewGroup.children.flatMap {
-        findViewsByTag(it, key, tag)
-    }.toList()
-}
-
-fun findViewsByTag(view: View, tag: Any?): List<View> {
-    val result = mutableListOf<View>()
-    if (view.tag == tag) {
-        result.add(view)
-    }
-    if (view is ViewGroup) {
-        result.addAll(findViewsByTag(view, tag))
-    }
-    return result.toList()
-}
-
-fun findViewsByTag(view: View, key: Int, tag: Any?): List<View> {
-    val result = mutableListOf<View>()
-    if (view.getTag(key) == tag) {
-        result.add(view)
-    }
-    if (view is ViewGroup) {
-        result.addAll(findViewsByTag(view, key, tag))
-    }
-    return result.toList()
-}
-
-fun Activity.findViewsByTag(tag: Any?) = rootView ?.let {
-    findViewsByTag(it, tag)
-}
-
-fun Activity.findViewsByTag(key: Int, tag: Any?) = rootView ?.let {
-    findViewsByTag(it, key, tag)
-}
-
-fun Fragment.findViewsByTag(tag: Any?) = view ?.let {
-    findViewsByTag(it, tag)
-}
-
-fun Fragment.findViewsByTag(key: Int, tag: Any?) = view ?.let {
-    findViewsByTag(it, key, tag)
-}
-
-fun Fragment.findViewsByTagInActivity(tag: Any?) = activity ?.findViewsByTag(tag)
-
-fun Fragment.findViewsByTagInActivity(key: Int, tag: Any?) = activity ?.findViewsByTag(key, tag)

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

@@ -1,7 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import android.app.Activity
-import android.view.View
-
-val Activity.rootView: View?
-    get() = findViewById<View?>(android.R.id.content) ?.rootView ?: window.decorView.findViewById<View?>(android.R.id.content) ?.rootView

common/src/mingwX64Main/kotlin/ActualMPPFile.kt

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

common/src/mingwX64Main/kotlin/fixed.kt

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

coroutines/build.gradle

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

coroutines/compose/build.gradle

@@ -1,20 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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.ExceptionHandler
-import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandlerWithNull
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.withContext
-import kotlin.coroutines.CoroutineContext
-
-/**
- * Each value of [this] [Flow] will trigger [applyDiff] to the result [SnapshotStateList]
- *
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [SnapshotStateList]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- */
-@Suppress("NOTHING_TO_INLINE")
-inline fun <reified T> Flow<List<T>>.asMutableComposeListState(
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    noinline onException: ExceptionHandler<List<T>?> = defaultSafelyWithoutExceptionHandlerWithNull,
-): SnapshotStateList<T> {
-    val state = mutableStateListOf<T>()
-    val changeBlock: suspend (List<T>) -> Unit = useContextOnChange ?.let {
-        {
-            withContext(useContextOnChange) {
-                state.applyDiff(it)
-            }
-        }
-    } ?: {
-        state.applyDiff(it)
-    }
-    subscribeSafelyWithoutExceptions(scope, onException, changeBlock)
-    return state
-}
-
-/**
- * In fact, it is just classcast of [asMutableComposeListState] to [List]
- *
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [List]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- *
- * @return Changing in time [List] which follow [Flow] values
- */
-@Suppress("NOTHING_TO_INLINE")
-inline fun <reified T> Flow<List<T>>.asComposeList(
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    noinline onException: ExceptionHandler<List<T>?> = defaultSafelyWithoutExceptionHandlerWithNull,
-): List<T> = asMutableComposeListState(scope, useContextOnChange, onException)
-

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

@@ -1,94 +0,0 @@
-package dev.inmo.micro_utils.coroutines.compose
-
-import androidx.compose.runtime.*
-import dev.inmo.micro_utils.common.compose.asState
-import dev.inmo.micro_utils.coroutines.ExceptionHandler
-import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandlerWithNull
-import dev.inmo.micro_utils.coroutines.doInUI
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.withContext
-import kotlin.coroutines.CoroutineContext
-
-/**
- * Will map [this] [Flow] as [MutableState]. Returned [MutableState] WILL NOT change source [Flow]
- *
- * @param initial First value which will be passed to the result [MutableState]
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [MutableState]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- */
-fun <T> Flow<T>.asMutableComposeState(
-    initial: T,
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-): MutableState<T> {
-    val state = mutableStateOf(initial)
-    val changeBlock: suspend (T) -> Unit = useContextOnChange ?.let {
-        {
-            withContext(useContextOnChange) {
-                state.value = it
-            }
-        }
-    } ?: {
-        state.value = it
-    }
-    subscribeSafelyWithoutExceptions(scope, onException, block = changeBlock)
-    return state
-}
-
-/**
- * Will map [this] [StateFlow] as [MutableState]. Returned [MutableState] WILL NOT change source [StateFlow].
- * This conversation will pass its [StateFlow.value] as the first value
- *
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [MutableState]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- */
-@Suppress("NOTHING_TO_INLINE")
-inline fun <T> StateFlow<T>.asMutableComposeState(
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-): MutableState<T> = asMutableComposeState(value, scope, useContextOnChange, onException)
-
-/**
- * Will create [MutableState] using [asMutableComposeState] and use [asState] to convert it as immutable state
- *
- * @param initial First value which will be passed to the result [State]
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [State]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- */
-fun <T> Flow<T>.asComposeState(
-    initial: T,
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-): State<T> {
-    val state = asMutableComposeState(initial, scope, useContextOnChange, onException)
-    return state.asState()
-}
-
-/**
- * Will map [this] [StateFlow] as [State]. This conversation will pass its [StateFlow.value] as the first value
- *
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [State]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- */
-@Suppress("NOTHING_TO_INLINE")
-inline fun <T> StateFlow<T>.asComposeState(
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-): State<T> = asComposeState(value, scope, useContextOnChange, onException)
-

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

@@ -1,14 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

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

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

@@ -6,12 +6,11 @@ import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import kotlin.coroutines.cancellation.CancellationException
 
-private sealed interface AccumulatorFlowStep<T>
-private data class DataRetrievedAccumulatorFlowStep<T>(val data: T) : AccumulatorFlowStep<T>
-private data class SubscribeAccumulatorFlowStep<T>(val channel: Channel<T>) : AccumulatorFlowStep<T>
-private data class UnsubscribeAccumulatorFlowStep<T>(val channel: Channel<T>) : AccumulatorFlowStep<T>
+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
 
 /**
  * This [Flow] will have behaviour very similar to [SharedFlow], but there are several differences:
@@ -27,12 +26,12 @@ class AccumulatorFlow<T>(
     private val subscope = scope.LinkedSupervisorScope()
     private val activeData = ArrayDeque<T>()
     private val dataMutex = Mutex()
-    private val channelsForBroadcast = mutableListOf<Channel<T>>()
+    private val channelsForBroadcast = mutableListOf<Channel<Any>>()
     private val channelsMutex = Mutex()
-    private val steps = subscope.actor<AccumulatorFlowStep<T>> { step ->
+    private val steps = subscope.actor<AccumulatorFlowStep> { step ->
         when (step) {
             is DataRetrievedAccumulatorFlowStep -> {
-                if (activeData.firstOrNull() === step.data) {
+                if (activeData.first() === step.data) {
                     dataMutex.withLock {
                         activeData.removeFirst()
                     }
@@ -43,7 +42,7 @@ class AccumulatorFlow<T>(
                 dataMutex.withLock {
                     val dataToSend = activeData.toList()
                     safelyWithoutExceptions {
-                        dataToSend.forEach { step.channel.send(it) }
+                        dataToSend.forEach { step.channel.send(it as Any) }
                     }
                 }
             }
@@ -59,29 +58,24 @@ class AccumulatorFlow<T>(
         channelsMutex.withLock {
             channelsForBroadcast.forEach { channel ->
                 safelyWithResult {
-                    channel.send(it)
+                    channel.send(it as Any)
                 }
             }
         }
     }
 
     override suspend fun collectSafely(collector: FlowCollector<T>) {
-        val channel = Channel<T>(Channel.UNLIMITED, BufferOverflow.SUSPEND)
+        val channel = Channel<Any>(Channel.UNLIMITED, BufferOverflow.SUSPEND)
         steps.send(SubscribeAccumulatorFlowStep(channel))
-        val result = runCatchingSafely {
-            for (data in channel) {
-                val emitResult = runCatchingSafely {
-                    collector.emit(data)
-                }
-                if (emitResult.isSuccess || emitResult.exceptionOrNull() is CancellationException) {
-                    steps.send(DataRetrievedAccumulatorFlowStep(data))
-                }
-                emitResult.getOrThrow()
+        for (data in channel) {
+            try {
+                collector.emit(data as T)
+                steps.send(DataRetrievedAccumulatorFlowStep(data))
+            } finally {
+                channel.cancel()
+                steps.send(UnsubscribeAccumulatorFlowStep(channel))
             }
         }
-        channel.cancel()
-        steps.send(UnsubscribeAccumulatorFlowStep(channel))
-        result.getOrThrow()
     }
 }
 

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

@@ -1,15 +1,19 @@
 package dev.inmo.micro_utils.coroutines
 
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.consumeAsFlow
+import kotlinx.coroutines.launch
 
 fun <T> CoroutineScope.actor(
     channelCapacity: Int = Channel.UNLIMITED,
     block: suspend (T) -> Unit
 ): Channel<T> {
     val channel = Channel<T>(channelCapacity)
-    channel.consumeAsFlow().subscribe(this, block)
+    launch {
+        for (data in channel) {
+            block(data)
+        }
+    }
     return channel
 }
 

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

@@ -1,30 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.consumeAsFlow
-
-fun <T> CoroutineScope.actorAsync(
-    channelCapacity: Int = Channel.UNLIMITED,
-    markerFactory: suspend (T) -> Any? = { null },
-    block: suspend (T) -> Unit
-): Channel<T> {
-    val channel = Channel<T>(channelCapacity)
-    channel.consumeAsFlow().subscribeAsync(this, markerFactory, block)
-    return channel
-}
-
-inline fun <T> CoroutineScope.safeActorAsync(
-    channelCapacity: Int = Channel.UNLIMITED,
-    noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
-    noinline markerFactory: suspend (T) -> Any? = { null },
-    crossinline block: suspend (T) -> Unit
-): Channel<T> = actorAsync(
-    channelCapacity,
-    markerFactory
-) {
-    safely(onException) {
-        block(it)
-    }
-}
-

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

@@ -6,19 +6,23 @@ import kotlin.coroutines.*
 suspend fun <T> Iterable<Deferred<T>>.awaitFirstWithDeferred(
     scope: CoroutineScope,
     cancelOnResult: Boolean = true
-): Pair<Deferred<T>, T> {
-    val resultDeferred = CompletableDeferred<Pair<Deferred<T>, T>>()
-    val scope = scope.LinkedSupervisorScope()
-    forEach {
-        scope.launch {
-            resultDeferred.complete(it to it.await())
-            scope.cancel()
+): Pair<Deferred<T>, T> = suspendCoroutine<Pair<Deferred<T>, T>> { continuation ->
+    scope.launch(SupervisorJob()) {
+        val scope = this
+        forEach {
+            scope.launch {
+                continuation.resume(it to it.await())
+                scope.cancel()
+            }
         }
     }
-    return resultDeferred.await().also {
-        if (cancelOnResult) {
-            forEach {
-                runCatchingSafely { it.cancel() }
+}.also {
+    if (cancelOnResult) {
+        forEach {
+            try {
+                it.cancel()
+            } catch (e: IllegalStateException) {
+                e.printStackTrace()
             }
         }
     }

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

@@ -1,39 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.flow.*
-import kotlin.js.JsName
-import kotlin.jvm.JvmName
-
-inline fun <T, R> Flow<Flow<T>>.flatMap(
-    crossinline mapper: suspend (T) -> R
-) = flow {
-    collect {
-        it.collect {
-            emit(mapper(it))
-        }
-    }
-}
-
-@JsName("flatMapIterable")
-@JvmName("flatMapIterable")
-inline fun <T, R> Flow<Iterable<T>>.flatMap(
-    crossinline mapper: suspend (T) -> R
-) = map {
-    it.asFlow()
-}.flatMap(mapper)
-
-inline fun <T, R> Flow<Flow<T>>.flatMapNotNull(
-    crossinline mapper: suspend (T) -> R
-) = flatMap(mapper).takeNotNull()
-
-@JsName("flatMapNotNullIterable")
-@JvmName("flatMapNotNullIterable")
-inline fun <T, R> Flow<Iterable<T>>.flatMapNotNull(
-    crossinline mapper: suspend (T) -> R
-) = flatMap(mapper).takeNotNull()
-
-fun <T> Flow<Flow<T>>.flatten() = flatMap { it }
-
-@JsName("flattenIterable")
-@JvmName("flattenIterable")
-fun <T> Flow<Iterable<T>>.flatten() = flatMap { it }

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

@@ -1,6 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.flow.*
-
-fun <T> Flow<T>.takeNotNull() = mapNotNull { it }
-fun <T> Flow<T>.filterNotNull() = takeNotNull()

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

@@ -115,21 +115,10 @@ suspend inline fun <T> runCatchingSafely(
     safely(onException, block)
 }
 
-suspend inline fun <T, R> T.runCatchingSafely(
-    noinline onException: ExceptionHandler<R> = defaultSafelyExceptionHandler,
-    noinline block: suspend T.() -> R
-): Result<R> = runCatching {
-    safely(onException) { block() }
-}
-
 suspend inline fun <T> safelyWithResult(
     noinline block: suspend CoroutineScope.() -> T
 ): Result<T> = runCatchingSafely(defaultSafelyExceptionHandler, block)
 
-suspend inline fun <T, R> T.safelyWithResult(
-    noinline block: suspend T.() -> R
-): Result<R> = runCatchingSafely(defaultSafelyExceptionHandler, block)
-
 /**
  * Use this handler in cases you wish to include handling of exceptions by [defaultSafelyWithoutExceptionHandler] and
  * returning null at one time

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

@@ -1,136 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.currentCoroutineContext
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlin.contracts.ExperimentalContracts
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
-
-/**
- * It is interface which will work like classic [Mutex], but in difference have [lockStateFlow] for listening of the
- * [SmartMutex] state.
- *
- * There is [Mutable] and [Immutable] realizations. In case you are owner and manager current state of lock, you need
- * [Mutable] [SmartMutex]. Otherwise, [Immutable].
- *
- * Any [Mutable] [SmartMutex] may produce its [Immutable] variant which will contains [lockStateFlow] equal to its
- * [Mutable] creator
- */
-sealed interface SmartMutex {
-    val lockStateFlow: StateFlow<Boolean>
-
-    /**
-     * * True - locked
-     * * False - unlocked
-     */
-    val isLocked: Boolean
-        get() = lockStateFlow.value
-
-    /**
-     * Immutable variant of [SmartMutex]. In fact will depend on the owner of [lockStateFlow]
-     */
-    class Immutable(override val lockStateFlow: StateFlow<Boolean>) : SmartMutex
-
-    /**
-     * Mutable variant of [SmartMutex]. With that variant you may [lock] and [unlock]. Besides, you may create
-     * [Immutable] variant of [this] instance with [immutable] factory
-     *
-     * @param locked Preset state of [isLocked] and its internal [_lockStateFlow]
-     */
-    class Mutable(locked: Boolean = false) : SmartMutex {
-        private val _lockStateFlow = MutableStateFlow<Boolean>(locked)
-        override val lockStateFlow: StateFlow<Boolean> = _lockStateFlow.asStateFlow()
-
-        private val internalChangesMutex = Mutex()
-
-        fun immutable() = Immutable(lockStateFlow)
-
-        /**
-         * Holds call until this [SmartMutex] will be re-locked. That means that while [isLocked] == true, [holds] will
-         * wait for [isLocked] == false and then try to lock
-         */
-        suspend fun lock() {
-            do {
-                waitUnlock()
-                val shouldContinue = internalChangesMutex.withLock {
-                    if (_lockStateFlow.value) {
-                        true
-                    } else {
-                        _lockStateFlow.value = true
-                        false
-                    }
-                }
-            } while (shouldContinue && currentCoroutineContext().isActive)
-        }
-
-        /**
-         * Will try to lock this [SmartMutex] immediataly
-         *
-         * @return True if lock was successful. False otherwise
-         */
-        suspend fun tryLock(): Boolean {
-            return if (!_lockStateFlow.value) {
-                internalChangesMutex.withLock {
-                    if (!_lockStateFlow.value) {
-                        _lockStateFlow.value = true
-                        true
-                    } else {
-                        false
-                    }
-                }
-            } else {
-                false
-            }
-        }
-
-        /**
-         * If [isLocked] == true - will change it to false and return true. If current call will not unlock this
-         * [SmartMutex] - false
-         */
-        suspend fun unlock(): Boolean {
-            return if (_lockStateFlow.value) {
-                internalChangesMutex.withLock {
-                    if (_lockStateFlow.value) {
-                        _lockStateFlow.value = false
-                        true
-                    } else {
-                        false
-                    }
-                }
-            } else {
-                false
-            }
-        }
-    }
-}
-
-/**
- * Will call [SmartMutex.Mutable.lock], then execute [action] and return the result after [SmartMutex.Mutable.unlock]
- */
-@OptIn(ExperimentalContracts::class)
-suspend inline fun <T> SmartMutex.Mutable.withLock(action: () -> T): T {
-    contract {
-        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
-    }
-
-    lock()
-    try {
-        return action()
-    } finally {
-        unlock()
-    }
-}
-
-/**
- * Will wait until the [SmartMutex.lockStateFlow] of [this] instance will be false.
- *
- * Anyway, after the end of this block there are no any guaranties that [SmartMutex.isLocked] == false due to the fact
- * that some other parties may lock it again
- */
-suspend fun SmartMutex.waitUnlock() = lockStateFlow.first { !it }

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

@@ -1,28 +0,0 @@
-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/ImagePreloading.kt

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

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

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

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

@@ -1,9 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-fun <T> launchInCurrentThread(block: suspend CoroutineScope.() -> T): T {
-    val scope = CoroutineScope(Dispatchers.Unconfined)
-    return scope.launchSynchronously(block)
-}

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

@@ -6,7 +6,7 @@ fun <T> CoroutineScope.launchSynchronously(block: suspend CoroutineScope.() -> T
     var result: Result<T>? = null
     val objectToSynchronize = Object()
     synchronized(objectToSynchronize) {
-        launch(start = CoroutineStart.UNDISPATCHED) {
+        launch {
             result = safelyWithResult(block)
         }.invokeOnCompletion {
             synchronized(objectToSynchronize) {

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

@@ -1,47 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.withContext
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class LaunchInCurrentThreadTests {
-    @Test
-    fun simpleTestThatLaunchInCurrentThreadWorks() {
-        val expectedResult = 10
-        val result = launchInCurrentThread {
-            expectedResult
-        }
-        assertEquals(expectedResult, result)
-    }
-    @Test
-    fun simpleTestThatSeveralLaunchInCurrentThreadWorks() {
-        val testData = 0 until 100
-
-        testData.forEach {
-            val result = launchInCurrentThread {
-                it
-            }
-            assertEquals(it, result)
-        }
-    }
-    @Test
-    fun simpleTestThatLaunchInCurrentThreadWillCorrectlyHandleSuspensionsWorks() {
-        val testData = 0 until 100
-
-        suspend fun test(data: Any): Any {
-            return withContext(Dispatchers.Default) {
-                delay(1)
-                data
-            }
-        }
-
-        testData.forEach {
-            val result = launchInCurrentThread {
-                test(it)
-            }
-            assertEquals(it, result)
-        }
-    }
-}

coroutines/src/main/kotlin/FlowOnHierarchyChangeListener.kt

@@ -1,50 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import android.view.View
-import android.view.ViewGroup
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.asSharedFlow
-
-/**
- * [kotlinx.coroutines.flow.Flow]-based [android.view.ViewGroup.OnHierarchyChangeListener]
- *
- * @param recursive If set, any call of [onChildViewAdded] will check if child [View] is [ViewGroup] and subscribe to this
- * [ViewGroup] too
- * @param [_onChildViewAdded] Internal [MutableSharedFlow] which will be used to pass data to [onChildViewAdded] flow
- * @param [_onChildViewRemoved] Internal [MutableSharedFlow] which will be used to pass data to [onChildViewRemoved] flow
- */
-class FlowOnHierarchyChangeListener(
-    private val recursive: Boolean = false,
-    private val _onChildViewAdded: MutableSharedFlow<Pair<View, View>> = MutableSharedFlow(extraBufferCapacity = Int.MAX_VALUE),
-    private val _onChildViewRemoved: MutableSharedFlow<Pair<View, View>> = MutableSharedFlow(extraBufferCapacity = Int.MAX_VALUE)
-) : ViewGroup.OnHierarchyChangeListener {
-    val onChildViewAdded = _onChildViewAdded.asSharedFlow()
-    val onChildViewRemoved = _onChildViewRemoved.asSharedFlow()
-
-    /**
-     * Will emit data into [onChildViewAdded] flow. If [recursive] is true and [child] is [ViewGroup] will also
-     * subscribe to [child] hierarchy changes.
-     *
-     * Due to the fact that this method is not suspendable, [FlowOnHierarchyChangeListener] will use
-     * [MutableSharedFlow.tryEmit] to send data into [_onChildViewAdded]. That is why its default extraBufferCapacity is
-     * [Int.MAX_VALUE]
-     */
-    override fun onChildViewAdded(parent: View, child: View) {
-        _onChildViewAdded.tryEmit(parent to child)
-
-        if (recursive && child is ViewGroup) {
-            child.setOnHierarchyChangeListener(this)
-        }
-    }
-
-    /**
-     * Just emit data into [onChildViewRemoved]
-     *
-     * Due to the fact that this method is not suspendable, [FlowOnHierarchyChangeListener] will use
-     * [MutableSharedFlow.tryEmit] to send data into [_onChildViewRemoved]. That is why its default extraBufferCapacity is
-     * [Int.MAX_VALUE]
-     */
-    override fun onChildViewRemoved(parent: View, child: View) {
-        _onChildViewRemoved.tryEmit(parent to child)
-    }
-}

coroutines/src/main/kotlin/RecursiveHierarchySubscriber.kt

@@ -1,17 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import android.view.ViewGroup
-import android.view.ViewGroup.OnHierarchyChangeListener
-
-/**
- * Use [ViewGroup.setOnHierarchyChangeListener] recursively for all available [ViewGroup]s starting with [this].
- * This extension DO NOT guarantee that recursive subscription will happen after this method call
- */
-fun ViewGroup.setOnHierarchyChangeListenerRecursively(
-    listener: OnHierarchyChangeListener
-) {
-    setOnHierarchyChangeListener(listener)
-    (0 until childCount).forEach {
-        (getChildAt(it) as? ViewGroup) ?.setOnHierarchyChangeListenerRecursively(listener)
-    }
-}

crypto/build.gradle

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

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

@@ -1,15 +0,0 @@
-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/commonMain/kotlin/dev/inmo/micro_utils/crypto/MD5.kt

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

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

@@ -1,15 +0,0 @@
-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
-        )
-    }
-}

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

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

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

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

defaultAndroidSettings.gradle

@@ -1,12 +1,37 @@
 apply plugin: 'com.getkeepsafe.dexcount'
 
+ext {
+    jvmKotlinFolderFile = {
+        String sep = File.separator
+        return new File("${project.projectDir}${sep}src${sep}jvmMain${sep}kotlin")
+    }
+
+    enableIncludingJvmCodeInAndroidPart = {
+        File jvmKotlinFolder = jvmKotlinFolderFile()
+        if (jvmKotlinFolder.exists()) {
+            android.sourceSets.main.java.srcDirs += jvmKotlinFolder.path
+        }
+    }
+
+    disableIncludingJvmCodeInAndroidPart = {
+        File jvmKotlinFolder = jvmKotlinFolderFile()
+        String[] oldDirs = android.sourceSets.main.java.srcDirs
+        android.sourceSets.main.java.srcDirs = []
+        for (oldDir in oldDirs) {
+            if (oldDir != jvmKotlinFolder.path) {
+                android.sourceSets.main.java.srcDirs += oldDir
+            }
+        }
+    }
+}
+
 android {
-    compileSdkVersion libs.versions.android.props.compileSdk.get().toInteger()
-    buildToolsVersion libs.versions.android.props.buildTools.get()
+    compileSdkVersion "$android_compileSdkVersion".toInteger()
+    buildToolsVersion "$android_buildToolsVersion"
 
     defaultConfig {
-        minSdkVersion libs.versions.android.props.minSdk.get().toInteger()
-        targetSdkVersion libs.versions.android.props.compileSdk.get().toInteger()
+        minSdkVersion "$android_minSdkVersion".toInteger()
+        targetSdkVersion "$android_compileSdkVersion".toInteger()
         versionCode "${android_code_version}".toInteger()
         versionName "$version"
     }
@@ -33,4 +58,10 @@ android {
     kotlinOptions {
         jvmTarget = JavaVersion.VERSION_1_8.toString()
     }
+
+    sourceSets {
+        String sep = File.separator
+        main.java.srcDirs += "src${sep}main${sep}kotlin"
+        enableIncludingJvmCodeInAndroidPart()
+    }
 }

dokka/build.gradle

@@ -121,11 +121,11 @@ tasks.dokkaHtml {
 //        }
 
         named("jvmMain") {
-            sourceRoots.setFrom(findSourcesWithName("jvmMain"))
+            sourceRoots.setFrom(findSourcesWithName("jvmMain", "commonMain"))
         }
 
         named("androidMain") {
-            sourceRoots.setFrom(findSourcesWithName("androidMain"))
+            sourceRoots.setFrom(findSourcesWithName("androidMain", "commonMain"))
         }
     }
 }

extensions.gradle

@@ -21,14 +21,12 @@ 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"
-        mppJvmJsLinuxMingwProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJvmJsLinuxMingwProject.gradle"
         mppAndroidProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppAndroidProject.gradle"
 
         defaultAndroidSettingsPresetPath = "${rootProject.projectDir.absolutePath}/defaultAndroidSettings.gradle"
 
         publishGradlePath = "${rootProject.projectDir.absolutePath}/publish.gradle"
-        publishJvmOnlyPath = "${rootProject.projectDir.absolutePath}/jvm.publish.gradle"
+        publishMavenPath = "${rootProject.projectDir.absolutePath}/maven.publish.gradle"
     }
 }

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

@@ -47,11 +47,24 @@ 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

@@ -3,10 +3,7 @@ package dev.inmo.micro_utils.fsm.common
 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
 
@@ -16,24 +13,13 @@ import kotlinx.coroutines.sync.withLock
  * 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 launchStateHandling(state, handlers, defaultStateHandlingErrorHandler())
+        return handlers.firstOrNull { it.checkHandleable(state) } ?.run {
+            handleState(state)
+        }
     }
 
     /**
@@ -52,9 +38,8 @@ interface StatesMachine<T : State> : StatesHandler<T, T> {
          */
         operator fun <T: State> invoke(
             statesManager: StatesManager<T>,
-            handlers: List<CheckableHandlerHolder<in T, T>>,
-            onStateHandlingErrorHandler: StateHandlingErrorHandler<T> = defaultStateHandlingErrorHandler()
-        ) = DefaultStatesMachine(statesManager, handlers, onStateHandlingErrorHandler)
+            handlers: List<CheckableHandlerHolder<in T, T>>
+        ) = DefaultStatesMachine(statesManager, handlers)
     }
 }
 
@@ -67,17 +52,12 @@ interface StatesMachine<T : State> : StatesHandler<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
      */
@@ -86,10 +66,10 @@ open class DefaultStatesMachine <T: State>(
 
     protected open suspend fun performUpdate(state: T) {
         val newState = launchStateHandling(state, handlers)
-        if (newState == null) {
-            statesManager.endChain(state)
-        } else {
+        if (newState != null) {
             statesManager.update(state, newState)
+        } else {
+            statesManager.endChain(state)
         }
     }
 
@@ -119,21 +99,15 @@ open class DefaultStatesMachine <T: State>(
      * [StatesManager.endChain].
      */
     override fun start(scope: CoroutineScope): Job = scope.launchSafelyWithoutExceptions {
-        (statesManager.getActiveStates().asFlow() + statesManager.onStartChain).subscribeSafelyWithoutExceptions(this) {
+        statesManager.onStartChain.subscribeSafelyWithoutExceptions(this) {
             launch { performStateUpdate(Optional.absent(), it, scope.LinkedSupervisorScope()) }
         }
         statesManager.onChainStateUpdated.subscribeSafelyWithoutExceptions(this) {
             launch { performStateUpdate(Optional.presented(it.first), it.second, scope.LinkedSupervisorScope()) }
         }
-        statesManager.onEndChain.subscribeSafelyWithoutExceptions(this) { removedState ->
-            launch {
-                statesJobsMutex.withLock {
-                    val stateInMap = statesJobs.keys.firstOrNull { stateInMap -> stateInMap == removedState }
-                    if (stateInMap === removedState) {
-                        statesJobs[stateInMap] ?.cancel()
-                    }
-                }
-            }
+
+        statesManager.getActiveStates().forEach {
+            launch { performStateUpdate(Optional.absent(), it, scope.LinkedSupervisorScope()) }
         }
     }
 

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

@@ -1,8 +1,6 @@
 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
 
@@ -22,23 +20,15 @@ interface UpdatableStatesMachine<T : State> : StatesMachine<T> {
 open class DefaultUpdatableStatesMachine<T : State>(
     statesManager: StatesManager<T>,
     handlers: List<CheckableHandlerHolder<in T, T>>,
-    onStateHandlingErrorHandler: StateHandlingErrorHandler<T> = defaultStateHandlingErrorHandler()
 ) : DefaultStatesMachine<T>(
     statesManager,
-    handlers,
-    onStateHandlingErrorHandler
+    handlers
 ), 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)) {
+            if (compare(previousState, actualState)) {
                 statesJobs[actualState] ?.cancel()
             }
             val job = previousState.mapOnPresented {
@@ -52,7 +42,6 @@ open class DefaultUpdatableStatesMachine<T : State>(
                             statesJobs.remove(
                                 jobsStates[job] ?: return@withLock
                             )
-                            jobsStates.remove(job)
                         }
                     }
                 }
@@ -63,10 +52,7 @@ open class DefaultUpdatableStatesMachine<T : State>(
         }
     }
 
-    /**
-     * 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
+    protected open suspend fun compare(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/managers/DefaultStatesManager.kt

@@ -37,49 +37,36 @@ 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 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]
+ * @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
  */
-open class DefaultStatesManager<T : State>(
-    protected val repo: DefaultStatesManagerRepo<T> = InMemoryDefaultStatesManagerRepo(),
-    protected val onStartContextsConflictResolver: suspend (current: T, new: T) -> Boolean = { _, _ -> false },
-    protected val onUpdateContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean = { _, _, _ -> false }
+class DefaultStatesManager<T : State>(
+    private val repo: DefaultStatesManagerRepo<T> = InMemoryDefaultStatesManagerRepo(),
+    private val onContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean = { _, _, _ -> true }
 ) : StatesManager<T> {
-    protected val _onChainStateUpdated = MutableSharedFlow<Pair<T, T>>(0)
+    private val _onChainStateUpdated = MutableSharedFlow<Pair<T, T>>(0)
     override val onChainStateUpdated: Flow<Pair<T, T>> = _onChainStateUpdated.asSharedFlow()
-    protected val _onStartChain = MutableSharedFlow<T>(0)
+    private val _onStartChain = MutableSharedFlow<T>(0)
     override val onStartChain: Flow<T> = _onStartChain.asSharedFlow()
-    protected val _onEndChain = MutableSharedFlow<T>(0)
+    private val _onEndChain = MutableSharedFlow<T>(0)
     override val onEndChain: Flow<T> = _onEndChain.asSharedFlow()
 
-    protected val mapMutex = Mutex()
-
-    constructor(
-        repo: DefaultStatesManagerRepo<T>,
-        onContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean
-    ) : this (
-        repo,
-        onUpdateContextsConflictResolver = onContextsConflictResolver
-    )
+    private val mapMutex = Mutex()
 
     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 || onUpdateContextsConflictResolver(old, new, stateOnNewOneContext)) {
+                if (stateOnNewOneContext == null || onContextsConflictResolver(old, new, stateOnNewOneContext)) {
                     stateOnNewOneContext ?.let { endChainWithoutLock(it) }
                     repo.removeState(old)
                     repo.set(new)
@@ -90,17 +77,13 @@ open class DefaultStatesManager<T : State>(
     }
 
     override suspend fun startChain(state: T) = mapMutex.withLock {
-        val stateOnContext = repo.getContextState(state.context)
-        if (stateOnContext == null || onStartContextsConflictResolver(stateOnContext, state)) {
-            stateOnContext ?.let {
-                endChainWithoutLock(it)
-            }
+        if (!repo.contains(state.context)) {
             repo.set(state)
             _onStartChain.emit(state)
         }
     }
 
-    protected open suspend fun endChainWithoutLock(state: T) {
+    private 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

@@ -0,0 +1,16 @@
+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

@@ -1,6 +0,0 @@
-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,6 +1,7 @@
 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 "v${project.version}"
+        tagName "${project.version}"
         releaseName "${project.version}"
         targetCommitish "${project.version}"
 

gradle.properties

@@ -7,12 +7,43 @@ android.useAndroidX=true
 android.enableJetifier=true
 org.gradle.jvmargs=-Xmx2g
 
+kotlin_version=1.6.10
+kotlin_coroutines_version=1.6.0
+kotlin_serialisation_core_version=1.3.2
+kotlin_exposed_version=0.37.2
+
+ktor_version=1.6.7
+
+klockVersion=2.4.13
+
+github_release_plugin_version=2.2.12
+
+uuidVersion=0.4.0
+
+# ANDROID
+
+core_ktx_version=1.7.0
+androidx_recycler_version=1.2.1
+appcompat_version=1.4.0
+
+android_minSdkVersion=19
+android_compileSdkVersion=32
+android_buildToolsVersion=32.0.0
+dexcount_version=3.0.1
+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.6.10
+
 # Project data
 
 group=dev.inmo
-version=0.18.1
-android_code_version=192
+version=0.9.7
+android_code_version=97

gradle/libs.versions.toml

@@ -1,111 +0,0 @@
-[versions]
-
-kt = "1.8.20"
-kt-serialization = "1.5.0"
-kt-coroutines = "1.6.4"
-
-kslog = "1.1.1"
-
-jb-compose = "1.4.0"
-jb-exposed = "0.41.1"
-jb-dokka = "1.8.10"
-
-korlibs = "3.4.0"
-uuid = "0.7.0"
-
-ktor = "2.3.0"
-
-gh-release = "2.4.1"
-
-koin = "3.4.0"
-
-okio = "3.3.0"
-
-ksp = "1.8.20-1.0.11"
-kotlin-poet = "1.13.0"
-
-android-gradle = "7.4.2"
-dexcount = "4.0.0"
-
-android-coreKtx = "1.10.0"
-android-recyclerView = "1.3.0"
-android-appCompat = "1.6.1"
-android-fragment = "1.5.7"
-android-espresso = "3.5.1"
-android-test = "1.1.5"
-
-android-props-minSdk = "21"
-android-props-compileSdk = "33"
-android-props-buildTools = "33.0.2"
-
-[libraries]
-
-kt-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kt" }
-kt-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", 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" }
-
-kslog = { module = "dev.inmo:kslog", version.ref = "kslog" }
-
-klock = { module = "com.soywiz.korlibs.klock:klock", version.ref = "korlibs" }
-krypto = { module = "com.soywiz.korlibs.krypto:krypto", version.ref = "korlibs" }
-uuid = { module = "com.benasher44:uuid", version.ref = "uuid" }
-koin = { module = "io.insert-koin:koin-core", version.ref = "koin" }
-
-
-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-fragment = { module = "androidx.fragment:fragment", version.ref = "android-fragment" }
-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" }
-
-# ksp dependencies
-
-kotlin-poet = { module = "com.squareup:kotlinpoet-ksp", version.ref = "kotlin-poet" }
-ksp = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp" }
-
-okio = { module = "com.squareup.okio:okio", version.ref = "okio" }
-
-# Buildscript
-
-buildscript-kt-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kt" }
-buildscript-kt-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kt" }
-buildscript-kt-ksp = { module = "com.google.devtools.ksp:symbol-processing-gradle-plugin", version.ref = "ksp" }
-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.6.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

jvm.publish.gradle

@@ -1,118 +0,0 @@
-apply plugin: 'maven-publish'
-
-task javadocJar(type: Jar) {
-    from javadoc
-    classifier = 'javadoc'
-}
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    classifier = 'sources'
-}
-
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from components.java
-
-            artifact javadocJar
-            artifact sourcesJar
-
-            pom {
-                resolveStrategy = Closure.DELEGATE_FIRST
-
-                description = "It is set of projects with micro tools for avoiding of routines coding"
-                name = "${project.name}"
-                url = "https://github.com/InsanusMokrassar/MicroUtils/"
-
-                scm {
-                    developerConnection = "scm:git:[fetch=]https://github.com/InsanusMokrassar/MicroUtils.git[push=]https://github.com/InsanusMokrassar/MicroUtils.git"
-                    url = "https://github.com/InsanusMokrassar/MicroUtils.git"
-                }
-
-                developers {
-                    
-                        developer {
-                            id = "InsanusMokrassar"
-                            name = "Aleksei Ovsiannikov"
-                            email = "ovsyannikov.alexey95@gmail.com"
-                        }
-                    
-
-                        developer {
-                            id = "000Sanya"
-                            name = "Syrov Aleksandr"
-                            email = "000sanya.000sanya@gmail.com"
-                        }
-                    
-                }
-
-                licenses {
-                    
-                        license {
-                            name = "Apache Software License 2.0"
-                            url = "https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"
-                        }
-                    
-                }
-            }
-            repositories {
-                if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
-                    maven {
-                        name = "GithubPackages"
-                        url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
-                
-                        credentials {
-                            username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
-                            password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
-                        }
-                
-                    }
-                }
-                if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
-                    maven {
-                        name = "Gitea"
-                        url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
-                
-                        credentials(HttpHeaderCredentials) {
-                            name = "Authorization"
-                            value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
-                        }
-                
-                        authentication {
-                            header(HttpHeaderAuthentication)
-                        }
-                
-                    }
-                }
-                if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
-                    maven {
-                        name = "sonatype"
-                        url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
-                
-                        credentials {
-                            username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
-                            password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
-                        }
-                
-                    }
-                }
-            }
-        }
-    }
-}
-
-if (project.hasProperty("signing.gnupg.keyName")) {
-    apply plugin: 'signing'
-    
-    signing {
-        useGpgCmd()
-    
-        sign publishing.publications
-    }
-    
-    task signAll {
-        tasks.withType(Sign).forEach {
-            dependsOn(it)
-        }
-    }
-}

jvm.publish.kpsb

@@ -1 +0,0 @@
-{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"It is set of projects with micro tools for avoiding of routines coding","url":"https://github.com/InsanusMokrassar/MicroUtils/","vcsUrl":"https://github.com/InsanusMokrassar/MicroUtils.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"},{"id":"000Sanya","name":"Syrov Aleksandr","eMail":"000sanya.000sanya@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/MicroUtils"},{"name":"Gitea","url":"https://git.inmo.dev/api/packages/InsanusMokrassar/maven","credsType":{"type":"dev.inmo.kmppscriptbuilder.core.models.MavenPublishingRepository.CredentialsType.HttpHeaderCredentials","headerName":"Authorization","headerValueProperty":"GITEA_TOKEN"}},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}},"type":"JVM"}

koin/build.gradle

@@ -1,28 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.multiplatform"
-    id "org.jetbrains.kotlin.plugin.serialization"
-    id "com.android.library"
-}
-
-apply from: "$mppProjectWithSerializationPresetPath"
-
-kotlin {
-    sourceSets {
-        commonMain {
-            dependencies {
-                api libs.koin
-                api libs.uuid
-            }
-        }
-        jvmMain {
-            dependencies {
-                api libs.kt.reflect
-            }
-        }
-        androidMain {
-            dependencies {
-                api libs.kt.reflect
-            }
-        }
-    }
-}

koin/generator/README.md

@@ -1,100 +0,0 @@
-# Koin generator
-
-It is Kotlin Symbol Processing generator for `Koin` module in `MicroUtils`.
-
-1. [What may do this generator](#what-may-do-this-generator)
-2. [How to add generator](#how-to-add-generator)
-
-## What may do this generator
-
-Let's imagine you want to have shortcuts in koin, to get something easily:
-
-```kotlin
-val koin: Koin// some initialization
-
-val someUrl = koin.serverUrl
-```
-
-So, in that case you may mark containing file with next annotation (in the beginning of file):
-
-```kotlin
-@file:GenerateKoinDefinition("serverUrl", String::class, nullable = false)
-```
-
-If file is called like `Sample.kt`, will be generated file `GeneratedDefinitionsSample.kt` with next content:
-
-```kotlin
-public val Scope.serverUrl: String
-  get() = get(named("serverUrl"))
-
-public val Koin.serverUrl: String
-  get() = get(named("serverUrl"))
-
-public fun Module.serverUrlSingle(createdAtStart: Boolean = false,
-    definition: Definition<String>): KoinDefinition<String> =
-    single(named("serverUrl"), createdAtStart = createdAtStart, definition = definition)
-
-public fun Module.serverUrlFactory(definition: Definition<String>):
-    KoinDefinition<String> = factory(named("serverUrl"), definition = definition)
-```
-
-Besides, you may use the generics:
-
-```kotlin
-@file:GenerateKoinDefinition("sampleInfo", Sample::class, G1::class, G2::class, nullable = false)
-```
-
-Will generate:
-
-```kotlin
-public val Scope.sampleInfo: Sample<G1, G2>
-  get() = get(named("sampleInfo"))
-
-public val Koin.sampleInfo: Sample<G1, G2>
-  get() = get(named("sampleInfo"))
-
-public fun Module.sampleInfoSingle(createdAtStart: Boolean = false,
-    definition: Definition<Sample<G1, G2>>): KoinDefinition<Sample<G1, G2>> =
-    single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
-
-public fun Module.sampleInfoFactory(definition: Definition<Sample<G1, G2>>):
-    KoinDefinition<Sample<G1, G2>> = factory(named("sampleInfo"), definition = definition)
-```
-
-In case you wish not to generate single:
-
-```kotlin
-@file:GenerateKoinDefinition("sampleInfo", Sample::class, G1::class, G2::class, nullable = false, generateSingle = false)
-```
-
-And you will take next code:
-
-```kotlin
-public val Scope.sampleInfo: Sample<G1, G2>
-  get() = get(named("sampleInfo"))
-
-public val Koin.sampleInfo: Sample<G1, G2>
-  get() = get(named("sampleInfo"))
-
-public fun Module.sampleInfoFactory(definition: Definition<Sample<G1, G2>>):
-    KoinDefinition<Sample<G1, G2>> = factory(named("sampleInfo"), definition = definition)
-```
-
-## How to add generator
-
-**Note: $ksp_version in the samples above is equal to supported `ksp` version presented in `/gradle/libs.versions.toml` of project**
-
-**Note: $microutils_version in the version of MicroUtils library in your project**
-
-1. Add `classpath` in `build.gradle` (`classpath "com.google.devtools.ksp:symbol-processing-gradle-plugin:$ksp_version"`)
-2. Add plugin to the plugins list of your module: `id "com.google.devtools.ksp"`
-3. In `dependencies` block add to the required target/compile the dependency `dev.inmo:micro_utils.koin.generator:$microutils_version`:
-   ```groovy
-    dependencies {
-        add("kspCommonMainMetadata", "dev.inmo:micro_utils.koin.generator:$microutils_version") // will work in commonMain of your multiplatform module
-        add("kspJvm", "dev.inmo:micro_utils.koin.generator:$microutils_version") // will work in main of your JVM module
-    }
-    
-    ksp { // this generator do not require any arguments and we should left `ksp` empty
-    }
-    ```

koin/generator/build.gradle

@@ -1,15 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.jvm"
-}
-
-apply from: "$publishJvmOnlyPath"
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    api project(":micro_utils.koin")
-    api libs.kotlin.poet
-    api libs.ksp
-}

koin/generator/src/main/kotlin/Processor.kt

@@ -1,178 +0,0 @@
-package dev.inmo.micro_utils.koin.generator
-
-import com.google.devtools.ksp.KSTypeNotPresentException
-import com.google.devtools.ksp.KSTypesNotPresentException
-import com.google.devtools.ksp.KspExperimental
-import com.google.devtools.ksp.getAnnotationsByType
-import com.google.devtools.ksp.processing.CodeGenerator
-import com.google.devtools.ksp.processing.Resolver
-import com.google.devtools.ksp.processing.SymbolProcessor
-import com.google.devtools.ksp.symbol.KSAnnotated
-import com.google.devtools.ksp.symbol.KSFile
-import com.squareup.kotlinpoet.ClassName
-import com.squareup.kotlinpoet.FileSpec
-import com.squareup.kotlinpoet.FunSpec
-import com.squareup.kotlinpoet.ParameterSpec
-import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
-import com.squareup.kotlinpoet.PropertySpec
-import com.squareup.kotlinpoet.asTypeName
-import com.squareup.kotlinpoet.ksp.toClassName
-import com.squareup.kotlinpoet.ksp.toTypeName
-import com.squareup.kotlinpoet.ksp.writeTo
-import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition
-import org.koin.core.Koin
-import org.koin.core.module.Module
-import org.koin.core.scope.Scope
-import java.io.File
-import kotlin.reflect.KClass
-
-class Processor(
-    private val codeGenerator: CodeGenerator
-) : SymbolProcessor {
-    private val definitionClassName = ClassName("org.koin.core.definition", "Definition")
-    private val koinDefinitionClassName = ClassName("org.koin.core.definition", "KoinDefinition")
-
-    @OptIn(KspExperimental::class)
-    override fun process(resolver: Resolver): List<KSAnnotated> {
-        resolver.getSymbolsWithAnnotation(
-            GenerateKoinDefinition::class.qualifiedName!!
-        ).filterIsInstance<KSFile>().forEach { ksFile ->
-            FileSpec.builder(
-                ksFile.packageName.asString(),
-                "GeneratedDefinitions${ksFile.fileName.removeSuffix(".kt")}"
-            ).apply {
-                addFileComment(
-                    """
-                        THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
-                        TO REGENERATE IT JUST DELETE FILE
-                        ORIGINAL FILE: ${ksFile.fileName}
-                    """.trimIndent()
-                )
-                ksFile.getAnnotationsByType(GenerateKoinDefinition::class).forEach {
-                    val type = runCatching {
-                        it.type.asTypeName()
-                    }.getOrElse { e ->
-                        if (e is KSTypeNotPresentException) {
-                            e.ksType.toClassName()
-                        } else {
-                            throw e
-                        }
-                    }
-                    val targetType = runCatching {
-                        type.parameterizedBy(*(it.typeArgs.takeIf { it.isNotEmpty() } ?.map { it.asTypeName() } ?.toTypedArray() ?: return@runCatching type))
-                    }.getOrElse { e ->
-                        when (e) {
-                            is KSTypeNotPresentException -> e.ksType.toClassName()
-                        }
-                        if (e is KSTypesNotPresentException) {
-                            type.parameterizedBy(*e.ksTypes.map { it.toTypeName() }.toTypedArray())
-                        } else {
-                            throw e
-                        }
-                    }.copy(
-                        nullable = it.nullable
-                    )
-                    fun addGetterProperty(
-                        receiver: KClass<*>
-                    ) {
-                        addProperty(
-                            PropertySpec.builder(
-                                it.name,
-                                targetType,
-                            ).apply {
-                                addKdoc(
-                                    """
-                                        @return Definition by key "${it.name}"
-                                    """.trimIndent()
-                                )
-                                getter(
-                                    FunSpec.getterBuilder().apply {
-                                        addCode(
-                                            "return " + (if (it.nullable) {
-                                                "getOrNull"
-                                            } else {
-                                                "get"
-                                            }) + "(named(\"${it.name}\"))"
-                                        )
-                                    }.build()
-                                )
-                                receiver(receiver)
-                            }.build()
-                        )
-                    }
-
-                    addGetterProperty(Scope::class)
-                    addGetterProperty(Koin::class)
-
-                    if (it.generateSingle) {
-                        addFunction(
-                            FunSpec.builder("${it.name}Single").apply {
-                                addKdoc(
-                                    """
-                                        Will register [definition] with [org.koin.core.module.Module.single] and key "${it.name}"
-                                    """.trimIndent()
-                                )
-                                receiver(Module::class)
-                                addParameter(
-                                    ParameterSpec.builder(
-                                        "createdAtStart",
-                                        Boolean::class
-                                    ).apply {
-                                        defaultValue("false")
-                                    }.build()
-                                )
-                                addParameter(
-                                    ParameterSpec.builder(
-                                        "definition",
-                                        definitionClassName.parameterizedBy(targetType.copy(nullable = false))
-                                    ).build()
-                                )
-                                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
-                                addCode(
-                                    "return single(named(\"${it.name}\"), createdAtStart = createdAtStart, definition = definition)"
-                                )
-                            }.build()
-                        )
-                    }
-
-                    if (it.generateFactory) {
-                        addFunction(
-                            FunSpec.builder("${it.name}Factory").apply {
-                                addKdoc(
-                                    """
-                                        Will register [definition] with [org.koin.core.module.Module.factory] and key "${it.name}"
-                                    """.trimIndent()
-                                )
-                                receiver(Module::class)
-                                addParameter(
-                                    ParameterSpec.builder(
-                                        "definition",
-                                        definitionClassName.parameterizedBy(targetType.copy(nullable = false))
-                                    ).build()
-                                )
-                                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
-                                addCode(
-                                    "return factory(named(\"${it.name}\"), definition = definition)"
-                                )
-                            }.build()
-                        )
-                    }
-                    addImport("org.koin.core.qualifier", "named")
-                }
-            }.build().let {
-                File(
-                    File(ksFile.filePath).parent,
-                    "GeneratedDefinitions${ksFile.fileName}"
-                ).takeIf { !it.exists() } ?.apply {
-                    parentFile.mkdirs()
-
-                    writer().use { writer ->
-                        it.writeTo(writer)
-                    }
-                }
-            }
-        }
-
-        return emptyList()
-    }
-}

koin/generator/src/main/kotlin/Provider.kt

@@ -1,11 +0,0 @@
-package dev.inmo.micro_utils.koin.generator
-
-import com.google.devtools.ksp.processing.SymbolProcessor
-import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
-import com.google.devtools.ksp.processing.SymbolProcessorProvider
-
-class Provider : SymbolProcessorProvider {
-    override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor = Processor(
-        environment.codeGenerator
-    )
-}

koin/generator/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

@@ -1 +0,0 @@
-dev.inmo.micro_utils.koin.generator.Provider

koin/generator/test/build.gradle

@@ -1,27 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.multiplatform"
-    id "org.jetbrains.kotlin.plugin.serialization"
-    id "com.android.library"
-    id "com.google.devtools.ksp"
-}
-
-apply from: "$mppProjectWithSerializationPresetPath"
-
-
-kotlin {
-    sourceSets {
-        commonMain {
-            dependencies {
-                api project(":micro_utils.koin")
-            }
-        }
-    }
-}
-
-
-dependencies {
-    add("kspCommonMainMetadata", project(":micro_utils.koin.generator"))
-}
-
-ksp {
-}