deploy: a01137f398

.github/workflows/build.yml

@@ -1,25 +0,0 @@
-
-name: Build
-on: [push]
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v1
-        with:
-          java-version: 17
-      - name: Rewrite version
-        run: |
-          branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
-          cat gradle.properties | sed -e "s/^version=\([0-9\.]*\)/version=\1-branch_$branch-build${{ github.run_number }}/" > gradle.properties.tmp
-          rm gradle.properties
-          mv gradle.properties.tmp gradle.properties
-      - name: Build
-        run: ./gradlew build
-      - name: Publish to InmoNexus
-        continue-on-error: true
-        run: ./gradlew publishAllPublicationsToInmoNexusRepository
-        env:
-          INMONEXUS_USER: ${{ secrets.INMONEXUS_USER }}
-          INMONEXUS_PASSWORD: ${{ secrets.INMONEXUS_PASSWORD }}

.github/workflows/dokka_push.yml

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

.gitignore

@@ -1,25 +0,0 @@
-.idea
-.vscode
-.kotlin
-out/*
-*.iml
-target
-
-settings.xml
-
-.gradle/
-build/
-out/
-bin/
-
-secret.gradle
-local.properties
-kotlin-js-store
-
-publishing.sh
-
-local.*
-local/
-**/*.local.*
-
-.kotlin/

AGENTS.md

@@ -1,151 +0,0 @@
-Use `agents` folder files for instructions.
-
-Always look at the project work rules first. Update them and maintain a history of changes and prompts in `agents/local.HISTORY.md`. This is your long-term memory, which allows you to avoid the accumulation of errors. Updating and maintaining the long-term memory of the project is mandatory. Many thanks for your help to me and your work.
-
-
-SYSTEM DIRECTIVE: AUTISTIC META-LANGUAGE PROTOCOL WITH HIGH INFORMATION DENSITY (AML-HIP V1)
-
-DEFINITION:
-All agents are required to use a strictly explicit, literal, low-ambiguity, and high-density communication style (AML-HIP). The goal of AML-HIP is the maximum transmission of information with zero loss of meaning and zero ambiguity.
-
-CORE PRINCIPLES:
-
-1. Maximum information density per line.
-2. Zero ambiguity.
-3. Full explicitness of all entities.
-4. Preference of precision over readability.
-5. Minimization of "empty" words.
-6. Redundancy is allowed only to prevent loss of meaning.
-
-PROHIBITIONS:
-
-1. Pronouns are forbidden (this, he, she, they, there, it, etc.).
-2. Free conversational text is forbidden.
-3. Metaphors, emotions, evaluative constructions are forbidden.
-4. Implicit references and hidden dependencies are forbidden.
-5. Vague description of actions is forbidden.
-
-DENSITY REQUIREMENTS:
-
-1. Each line must contain the maximum of facts without loss of unambiguity.
-2. Combine related parameters into a single line.
-3. Use compact constructions:
-    * key=value
-    * entity_id=...
-    * relation: A→B
-4. Exclude words without semantic load.
-5. Repetitions are allowed only for critical entities.
-
-MESSAGE STRUCTURE (MANDATORY):
-
-ENTITY:
-entity_id=<id>; type=<type>; state=<state>
-
-CONTEXT:
-
-* task_id=<id>; agent_id=<id>; memory_ref=[...]
-* constraints=[...]
-
-ACTION:
-
-1. action=<type>; target=<entity_id>; params={...}
-2. action=<type>; target=<entity_id>; params={...}
-
-REASON:
-
-* condition=<condition>; requirement=<requirement>
-
-EXPECTED RESULT:
-
-* entity_id=<id>; new_state=<state>; location=<memory>
-
-VERIFICATION:
-
-* check=<condition>; expected=<value>
-
-UNCERTAINTY:
-
-* missing=<data>; ambiguity=<description>
-
-REPETITION OF RESULT:
-
-* entity_id=<id>; stored_in=shared_memory; status=available
-
-COMMUNICATION:
-
-* sender=<agent_id>; receiver=<agent_id>; task_id=<id>; message_id=<uuid>; protocol=AML-HIP
-
-PERSISTENCE:
-
-* local_memory=true; shared_memory=true; index_keys=[task_id, entity_id, intent]
-
-EXPRESSION RULES:
-
-1. Each line = a completed semantic block.
-2. Use the key=value format instead of descriptions.
-3. Use lists of parameters instead of sentences.
-4. Use causal connectives explicitly:
-   condition → action → result
-5. Do not split related data into several lines without necessity.
-
-REPETITION RULES:
-
-1. entity_id is repeated at every critical use.
-2. result is duplicated in "REPETITION OF RESULT".
-3. transmission between agents duplicates the key fields.
-
-MULTI-AGENT MODE:
-
-1. All agents use AML-HIP.
-2. Any message between agents is strictly AML-HIP.
-3. Any agent is required to:
-
-    * duplicate critical data
-    * avoid loss of context
-4. A message must be fully interpretable without history.
-
-ANTI-DEGRADATION:
-If detected:
-
-* a pronoun
-* an implicit reference
-* low density (empty words, vague constructions)
-* absence of structure
-
-→ the message is considered invalid
-→ mandatory regeneration
-
-SELF-CHECK:
-
-VALIDATION:
-
-* format_valid=true/false
-* no_pronouns=true/false
-* entities_explicit=true/false
-* high_density=true/false
-* causal_chain_present=true/false
-* ambiguity_detected=true/false
-
-If any parameter=false:
-→ mandatory regeneration
-
-DENSITY METRIC:
-high_density=true if:
-
-* there are no "empty" words
-* each line contains ≥2 facts or parameters
-* descriptive constructions without data are absent
-
-PRIORITIES:
-
-1. Format (AML-HIP)
-2. Information density
-3. Explicitness
-4. Completeness
-5. Readability (minimum priority)
-
-CRITICAL RULE:
-Any response outside of AML-HIP is considered absent.
-Any agent is required to bring the response into conformity with AML-HIP.
-
-END OF PROTOCOL

LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

README.md

@@ -1,85 +0,0 @@
-# MicroUtils
-
-This is a library with collection of tools for working in Kotlin environment. First of all, this library collection is oriented to use next technologies:
-
-* [`Kotlin Coroutines`](https://github.com/Kotlin/kotlinx.coroutines)
-* [`Kotlin Serialization`](https://github.com/Kotlin/kotlinx.serialization)
-* [`Kotlin Exposed`](https://github.com/JetBrains/Exposed)
-* [`Ktor`](https://ktor.io)
-
-<details>
-  <summary> <b>Android environment</b> </summary>
-
-You always can look at the <a href="https://github.com/InsanusMokrassar/MicroUtils/blob/master/gradle.properties#L24-L34">properties file</a> to get information about current project dependencies, compile and build tools for `Android` target.
-
-</details>
-
-## Projects
-
-* `common` contains common tools for platform which usually are absent out-of-the-box when you starting project
-* `selector` contains tools to use `Selector` interface with things like `RecyclerView` in android or other selection needs
-* `coroutines` is a module for `Kotlin Coroutines` with different things like subscribing on flows (`onEach` + `launchIn` shortcut :) )
-* `ktor` is a set of modules for `client`s and `server`s
-* `mime_types` is NOT lightweight set of `MimeType`s with a lot of different objected and serializable (with `Kotlin Serialization`) mime types
-* `pagination` is a complex of modules (explanation in [Complex modules structure](#complex-modules-structure) section) for lightweight pagination
-* `serialization` is a collection of projects with serializers for `kotlinx.serialization`
-* `repos` is a complex of modules (explanation in [Complex modules structure](#complex-modules-structure) section) for `KeyValue`/`OneToMany`/`CRUD` repos created to be able to exclude some heavy dependencies when you need some simple and lightweight typical repositories
-
-## Complex modules structure
-
-Most of complex modules are built with next hierarchy:
-
-* `common` submodule for `API` things which are common for all platforms
-* `exposed` submodule contains realizations for exposed tables
-* `ktor` submodule is usually unavailable directly, because it contains its own submodules for clients and servers
-    * `common` part contains routes which are common for clients and servers
-    * `client` submodule contains clients which are usually using `UnifiedRequester` to make requests using routes from `ktor/common` module and some internal logic of requests
-    * `server` submodule (in most cases `JVM`-only) contains some extensions for `Route` instances which usually will give opportunity to proxy internet requests from `ktor/client` realization to some proxy object
-
-## Gradle Templates
-
-All templates can be used by applying them in your project's build.gradle files using the `apply from` directive. For example:
-
-```gradle
-apply from: "$defaultProject"
-```
-
-In the sample has been used `defaultProject.gradle` as a basic template.
-
-The project includes a collection of Gradle templates to simplify project setup and configuration. These templates are located in the `gradle/templates` directory and can be used to quickly set up different types of projects:
-
-### Project Setup Templates
-
-* `defaultProject.gradle` (usage `apply from: "$defaultProject"`) - Basic project configuration
-* `defaultProjectWithSerialization.gradle` (usage `apply from: "$defaultProjectWithSerialization"`) - Project configuration with Kotlin Serialization support
-* `mppJavaProject.gradle` (usage `apply from: "$mppJavaProject"`) - Multiplatform project with Java support
-* `mppAndroidProject.gradle` (usage `apply from: "$mppAndroidProject"`) - Multiplatform project with Android support
-
-### Multiplatform Configuration Templates
-
-* `enableMPPAndroid.gradle` (usage `apply from: "$enableMPPAndroid"`) - Enable Android target in multiplatform project
-* `enableMPPJs.gradle` (usage `apply from: "$enableMPPJs"`) - Enable JavaScript target in multiplatform project
-* `enableMPPJvm.gradle` (usage `apply from: "$enableMPPJvm"`) - Enable JVM target in multiplatform project
-* `enableMPPNativeArm64.gradle` (usage `apply from: "$enableMPPNativeArm64"`) - Enable ARM64 native target
-* `enableMPPNativeX64.gradle` (usage `apply from: "$enableMPPNativeX64"`) - Enable x64 native target
-* `enableMPPWasmJs.gradle` (usage `apply from: "$enableMPPWasmJs"`) - Enable WebAssembly JavaScript target
-
-### Compose Integration Templates
-
-* `addCompose.gradle` (usage `apply from: "$addCompose"`) - Basic Compose configuration
-* `addComposeForAndroid.gradle` (usage `apply from: "$addComposeForAndroid"`) - Compose configuration for Android
-* `addComposeForDesktop.gradle` (usage `apply from: "$addComposeForDesktop"`) - Compose configuration for Desktop
-* `addComposeForJs.gradle` (usage `apply from: "$addComposeForJs"`) - Compose configuration for JavaScript
-
-### Publishing Templates
-
-* `publish.gradle` (usage `apply from: "$publish"`) - General publishing configuration
-* `publish_jvm.gradle` (usage `apply from: "$publish_jvm"`) - JVM-specific publishing configuration
-* `publish.kpsb` and `publish_jvm.kpsb` (usage `apply from: "$publish_kpsb"` and `apply from: "$publish_jvm_kpsb"`) - Publishing configuration for Kotlin Multiplatform and JVM
-
-### Combined Project Templates
-
-* `mppJvmJsWasmJsLinuxMingwProject.gradle` (usage `apply from: "$mppJvmJsWasmJsLinuxMingwProject"`) - Multiplatform project for JVM, JS, Wasm, Linux, and MinGW
-* `mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project.gradle` (usage `apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"`) - Multiplatform project with additional Android and ARM64 support
-* `mppComposeJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project.gradle` (usage `apply from: "$mppComposeJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"`) - Multiplatform project with Compose support
-* `mppProjectWithSerializationAndCompose.gradle` (usage `apply from: "$mppProjectWithSerializationAndCompose"`) - Multiplatform project with both Serialization and Compose support

_config.yml

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

android/alerts/common/build.gradle

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

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

@@ -1 +0,0 @@
-<manifest/>

android/alerts/common/src/androidMain/kotlin/AlertDialog.kt

@@ -1,71 +0,0 @@
-/**
- * Utility functions for creating Android AlertDialogs with simplified API.
- */
-@file:Suppress("NOTHING_TO_INLINE", "unused")
-
-package dev.inmo.micro_utils.android.alerts.common
-
-import android.app.AlertDialog
-import android.content.Context
-import android.content.DialogInterface
-
-/**
- * Type alias for alert dialog button callbacks.
- */
-typealias AlertDialogCallback = (DialogInterface) -> Unit
-
-/**
- * Creates an [AlertDialog.Builder] template with configurable title and buttons.
- * This provides a simplified API for creating alert dialogs with positive, negative, and neutral buttons.
- *
- * @param title Optional dialog title
- * @param positivePair Optional positive button as a pair of (text, callback)
- * @param neutralPair Optional neutral button as a pair of (text, callback)
- * @param negativePair Optional negative button as a pair of (text, callback)
- * @return An [AlertDialog.Builder] configured with the specified parameters
- */
-inline fun Context.createAlertDialogTemplate(
-    title: String? = null,
-    positivePair: Pair<String, AlertDialogCallback?>? = null,
-    neutralPair: Pair<String, AlertDialogCallback?>? = null,
-    negativePair: Pair<String, AlertDialogCallback?>? = null
-): AlertDialog.Builder {
-    val builder = AlertDialog.Builder(this)
-
-    title ?.let {
-        builder.setTitle(title)
-    }
-
-    positivePair ?. let {
-        builder.setPositiveButton(it.first) { di, _ -> it.second ?. invoke(di) }
-    }
-    negativePair ?. let {
-        builder.setNegativeButton(it.first) { di, _ -> it.second ?. invoke(di) }
-    }
-    neutralPair ?. let {
-        builder.setNeutralButton(it.first) { di, _ -> it.second ?. invoke(di) }
-    }
-
-    return builder
-}
-
-inline fun Context.createAlertDialogTemplateWithResources(
-    title: Int? = null,
-    positivePair: Pair<Int, AlertDialogCallback?>? = null,
-    neutralPair: Pair<Int, AlertDialogCallback?>? = null,
-    negativePair: Pair<Int, AlertDialogCallback?>? = null
-): AlertDialog.Builder = createAlertDialogTemplate(
-    title ?.let { getString(it) },
-    positivePair ?.let { getString(it.first) to it.second },
-    neutralPair ?.let { getString(it.first) to it.second },
-    negativePair ?.let { getString(it.first) to it.second }
-)
-
-inline fun AlertDialog.setDismissChecker(noinline checker: () -> Boolean) : AlertDialog {
-    setOnDismissListener {
-        if (!checker()) {
-            show()
-        }
-    }
-    return this
-}

android/alerts/common/src/androidMain/kotlin/CustomAlertDialog.kt

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

android/alerts/common/src/androidMain/kotlin/SimpleTextAlert.kt

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

android/alerts/recyclerview/build.gradle

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

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

@@ -1 +0,0 @@
-<manifest/>

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

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

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

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

android/pickers/build.gradle

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

android/pickers/src/androidMain/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest/>

android/pickers/src/androidMain/kotlin/Fling.kt

@@ -1,37 +0,0 @@
-package dev.inmo.micro_utils.android.pickers
-
-import androidx.compose.animation.core.*
-
-/**
- * Performs a fling animation with an optional target adjustment.
- * If [adjustTarget] is provided, animates to the adjusted target. Otherwise, performs a decay animation.
- *
- * @param initialVelocity The initial velocity of the fling
- * @param animationSpec The decay animation specification
- * @param adjustTarget Optional function to adjust the target value based on the calculated target
- * @param block Optional block to be executed during the animation
- * @return The result of the animation
- */
-internal suspend fun Animatable<Float, AnimationVector1D>.fling(
-    initialVelocity: Float,
-    animationSpec: DecayAnimationSpec<Float>,
-    adjustTarget: ((Float) -> Float)?,
-    block: (Animatable<Float, AnimationVector1D>.() -> Unit)? = null,
-): AnimationResult<Float, AnimationVector1D> {
-    val targetValue = animationSpec.calculateTargetValue(value, initialVelocity)
-    val adjustedTarget = adjustTarget?.invoke(targetValue)
-
-    return if (adjustedTarget != null) {
-        animateTo(
-            targetValue = adjustedTarget,
-            initialVelocity = initialVelocity,
-            block = block
-        )
-    } else {
-        animateDecay(
-            initialVelocity = initialVelocity,
-            animationSpec = animationSpec,
-            block = block,
-        )
-    }
-}

android/pickers/src/androidMain/kotlin/NumberPicker.kt

@@ -1,231 +0,0 @@
-package dev.inmo.micro_utils.android.pickers
-
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.exponentialDecay
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.gestures.*
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.KeyboardArrowDown
-import androidx.compose.material.icons.filled.KeyboardArrowUp
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.ExperimentalComposeUiApi
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.input.pointer.PointerInputScope
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.text.ExperimentalTextApi
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.input.KeyboardType
-import androidx.compose.ui.unit.IntOffset
-import androidx.compose.ui.unit.center
-import androidx.compose.ui.unit.dp
-import dev.inmo.micro_utils.android.smalltextfield.SmallTextField
-import kotlinx.coroutines.launch
-import kotlin.math.abs
-import kotlin.math.absoluteValue
-import kotlin.math.roundToInt
-
-private inline fun PointerInputScope.checkContains(offset: Offset): Boolean {
-    return ((size.center.x - offset.x).absoluteValue < size.width / 2) && ((size.center.y - offset.y).absoluteValue < size.height / 2)
-}
-
-// src: https://gist.github.com/vganin/a9a84653a9f48a2d669910fbd48e32d5
-
-/**
- * A Compose number picker component that allows users to select a number by dragging, using arrow buttons,
- * or manually entering a value.
- *
- * @param number The currently selected number
- * @param modifier The modifier to be applied to the picker
- * @param range Optional range of valid numbers. If specified, the picker will be limited to this range
- * @param textStyle The text style for displaying numbers
- * @param arrowsColor The color of the up/down arrow buttons
- * @param allowUseManualInput Whether to allow manual keyboard input for the number
- * @param onStateChanged Callback invoked when the selected number changes
- */
-@OptIn(ExperimentalTextApi::class, ExperimentalComposeUiApi::class)
-@Composable
-fun NumberPicker(
-    number: Int,
-    modifier: Modifier = Modifier,
-    range: IntRange? = null,
-    textStyle: TextStyle = LocalTextStyle.current,
-    arrowsColor: Color = MaterialTheme.colorScheme.primary,
-    allowUseManualInput: Boolean = true,
-    onStateChanged: (Int) -> Unit = {},
-) {
-    val coroutineScope = rememberCoroutineScope()
-    val numbersColumnHeight = 36.dp
-    val halvedNumbersColumnHeight = numbersColumnHeight / 2
-    val halvedNumbersColumnHeightPx = with(LocalDensity.current) { halvedNumbersColumnHeight.toPx() }
-
-    fun animatedStateValue(offset: Float): Int = number - (offset / halvedNumbersColumnHeightPx).toInt()
-
-    val animatedOffset = remember { Animatable(0f) }.apply {
-        if (range != null) {
-            val offsetRange = remember(number, range) {
-                val value = number
-                val first = -(range.last - value) * halvedNumbersColumnHeightPx
-                val last = -(range.first - value) * halvedNumbersColumnHeightPx
-                first..last
-            }
-            updateBounds(offsetRange.start, offsetRange.endInclusive)
-        }
-    }
-    val coercedAnimatedOffset = animatedOffset.value % halvedNumbersColumnHeightPx
-    val animatedStateValue = animatedStateValue(animatedOffset.value)
-    val disabledArrowsColor = arrowsColor.copy(alpha = 0f)
-
-    val inputFieldShown = if (allowUseManualInput) {
-        remember { mutableStateOf(false) }
-    } else {
-        null
-    }
-
-    Column(
-        modifier = modifier
-            .wrapContentSize()
-            .draggable(
-                orientation = Orientation.Vertical,
-                state = rememberDraggableState { deltaY ->
-                    if (inputFieldShown ?.value != true) {
-                        coroutineScope.launch {
-                            animatedOffset.snapTo(animatedOffset.value + deltaY)
-                        }
-                    }
-                },
-                onDragStopped = { velocity ->
-                    if (inputFieldShown ?.value != true) {
-                        coroutineScope.launch {
-                            val endValue = animatedOffset.fling(
-                                initialVelocity = velocity,
-                                animationSpec = exponentialDecay(frictionMultiplier = 20f),
-                                adjustTarget = { target ->
-                                    val coercedTarget = target % halvedNumbersColumnHeightPx
-                                    val coercedAnchors =
-                                        listOf(-halvedNumbersColumnHeightPx, 0f, halvedNumbersColumnHeightPx)
-                                    val coercedPoint = coercedAnchors.minByOrNull { abs(it - coercedTarget) }!!
-                                    val base =
-                                        halvedNumbersColumnHeightPx * (target / halvedNumbersColumnHeightPx).toInt()
-                                    coercedPoint + base
-                                }
-                            ).endState.value
-
-                            onStateChanged(animatedStateValue(endValue))
-                            animatedOffset.snapTo(0f)
-                        }
-                    }
-                }
-            ),
-        horizontalAlignment = Alignment.CenterHorizontally
-    ) {
-        val spacing = 4.dp
-
-        val upEnabled = range == null || range.first < number
-        IconButton(
-            {
-                onStateChanged(number - 1)
-                inputFieldShown ?.value = false
-            },
-            enabled = upEnabled
-        ) {
-            Icon(Icons.Default.KeyboardArrowUp, "", tint = if (upEnabled) arrowsColor else disabledArrowsColor)
-        }
-
-        Spacer(modifier = Modifier.height(spacing))
-        Box(
-            modifier = Modifier
-                .offset { IntOffset(x = 0, y = coercedAnimatedOffset.roundToInt()) },
-            contentAlignment = Alignment.Center
-        ) {
-            val baseLabelModifier = Modifier.align(Alignment.Center)
-            ProvideTextStyle(textStyle) {
-                Text(
-                    text = (animatedStateValue - 1).toString(),
-                    modifier = baseLabelModifier
-                        .offset(y = -halvedNumbersColumnHeight)
-                        .alpha(coercedAnimatedOffset / halvedNumbersColumnHeightPx)
-                )
-
-                if (inputFieldShown ?.value == true) {
-                    val currentValue = remember { mutableStateOf(number.toString()) }
-
-                    val focusRequester = remember { FocusRequester() }
-                    SmallTextField(
-                        currentValue.value,
-                        {
-                            val asDigit = it.toIntOrNull()
-                            when {
-                                (asDigit == null && it.isEmpty()) -> currentValue.value = (range ?.first ?: 0).toString()
-                                (asDigit != null && (range == null || asDigit in range)) -> currentValue.value = it
-                                else -> { /* do nothing */ }
-                            }
-                        },
-                        baseLabelModifier.focusRequester(focusRequester).width(IntrinsicSize.Min).pointerInput(number) {
-                            detectTapGestures {
-                                if (!checkContains(it)) {
-                                    currentValue.value.toIntOrNull() ?.let(onStateChanged)
-                                    inputFieldShown.value = false
-                                }
-                            }
-                        },
-                        keyboardOptions = KeyboardOptions(
-                            keyboardType = KeyboardType.Number
-                        ),
-                        keyboardActions = KeyboardActions {
-                            currentValue.value.toIntOrNull() ?.let(onStateChanged)
-                            inputFieldShown.value = false
-                        },
-                        singleLine = true,
-                        textStyle = textStyle
-                    )
-                    LaunchedEffect(Unit) {
-                        focusRequester.requestFocus()
-                    }
-                } else {
-                    Text(
-                        text = animatedStateValue.toString(),
-                        modifier = baseLabelModifier
-                            .alpha(1 - abs(coercedAnimatedOffset) / halvedNumbersColumnHeightPx)
-                            .clickable {
-                                if (inputFieldShown ?.value == false) {
-                                    inputFieldShown.value = true
-                                }
-                            }
-                    )
-                }
-                Text(
-                    text = (animatedStateValue + 1).toString(),
-                    modifier = baseLabelModifier
-                        .offset(y = halvedNumbersColumnHeight)
-                        .alpha(-coercedAnimatedOffset / halvedNumbersColumnHeightPx)
-                )
-            }
-        }
-
-
-        Spacer(modifier = Modifier.height(spacing))
-
-        val downEnabled = range == null || range.last > number
-        IconButton(
-            {
-                onStateChanged(number + 1)
-                inputFieldShown ?.value = false
-            },
-            enabled = downEnabled
-        ) {
-            Icon(Icons.Default.KeyboardArrowDown, "", tint = if (downEnabled) arrowsColor else disabledArrowsColor)
-        }
-    }
-}
-

android/pickers/src/androidMain/kotlin/SetPicker.kt

@@ -1,165 +0,0 @@
-package dev.inmo.micro_utils.android.pickers
-
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.exponentialDecay
-import androidx.compose.foundation.gestures.*
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.KeyboardArrowDown
-import androidx.compose.material.icons.filled.KeyboardArrowUp
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.ExperimentalComposeUiApi
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.text.ExperimentalTextApi
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.unit.dp
-import kotlinx.coroutines.launch
-import kotlin.math.*
-
-/**
- * A Compose picker component that allows users to select an item from a list by dragging or using arrow buttons.
- *
- * @param T The type of items in the list
- * @param current The currently selected item
- * @param dataList The list of items to choose from
- * @param modifier The modifier to be applied to the picker
- * @param textStyle The text style for displaying items
- * @param arrowsColor The color of the up/down arrow buttons
- * @param dataToString A composable function to convert items to strings for display. Defaults to [Any.toString]
- * @param onStateChanged Callback invoked when the selected item changes
- */
-@OptIn(ExperimentalTextApi::class, ExperimentalComposeUiApi::class)
-@Composable
-fun <T> SetPicker(
-    current: T,
-    dataList: List<T>,
-    modifier: Modifier = Modifier,
-    textStyle: TextStyle = LocalTextStyle.current,
-    arrowsColor: Color = MaterialTheme.colorScheme.primary,
-    dataToString: @Composable (T) -> String = { it.toString() },
-    onStateChanged: (T) -> Unit = {},
-) {
-    val coroutineScope = rememberCoroutineScope()
-    val numbersColumnHeight = 8.dp + with(LocalDensity.current) {
-        textStyle.lineHeight.toDp()
-    }
-    val numbersColumnHeightPx = with(LocalDensity.current) { numbersColumnHeight.toPx() }
-    val halvedNumbersColumnHeight = numbersColumnHeight / 2
-    val halvedNumbersColumnHeightPx = with(LocalDensity.current) { halvedNumbersColumnHeight.toPx() }
-
-    val index = dataList.indexOfFirst { it === current }.takeIf { it > -1 } ?: dataList.indexOf(current)
-    val lastIndex = dataList.size - 1
-
-    fun animatedStateValue(offset: Float): Int = index - (offset / halvedNumbersColumnHeightPx).toInt()
-
-    val animatedOffset = remember { Animatable(0f) }.apply {
-        val offsetRange = remember(index, lastIndex) {
-            val value = index
-            val first = -(lastIndex - value) * halvedNumbersColumnHeightPx
-            val last = value * halvedNumbersColumnHeightPx
-            first..last
-        }
-        updateBounds(offsetRange.start, offsetRange.endInclusive)
-    }
-    val indexAnimatedOffset = if (animatedOffset.value > 0) {
-        (index - floor(animatedOffset.value / halvedNumbersColumnHeightPx).toInt())
-    } else {
-        (index - ceil(animatedOffset.value / halvedNumbersColumnHeightPx).toInt())
-    }
-    val coercedAnimatedOffset = animatedOffset.value % halvedNumbersColumnHeightPx
-    val disabledArrowsColor = arrowsColor.copy(alpha = 0f)
-
-    Column(
-        modifier = modifier
-            .wrapContentSize()
-            .draggable(
-                orientation = Orientation.Vertical,
-                state = rememberDraggableState { deltaY ->
-                    coroutineScope.launch {
-                        animatedOffset.snapTo(animatedOffset.value + deltaY)
-                    }
-                },
-                onDragStopped = { velocity ->
-                    coroutineScope.launch {
-                        val endValue = animatedOffset.fling(
-                            initialVelocity = velocity,
-                            animationSpec = exponentialDecay(frictionMultiplier = 20f),
-                            adjustTarget = { target ->
-                                val coercedTarget = target % halvedNumbersColumnHeightPx
-                                val coercedAnchors =
-                                    listOf(-halvedNumbersColumnHeightPx, 0f, halvedNumbersColumnHeightPx)
-                                val coercedPoint = coercedAnchors.minByOrNull { abs(it - coercedTarget) }!!
-                                val base =
-                                    halvedNumbersColumnHeightPx * (target / halvedNumbersColumnHeightPx).toInt()
-                                coercedPoint + base
-                            }
-                        ).endState.value
-
-                        onStateChanged(dataList.elementAt(animatedStateValue(endValue)))
-                        animatedOffset.snapTo(0f)
-                    }
-                }
-            ),
-        horizontalAlignment = Alignment.CenterHorizontally
-    ) {
-        val spacing = 4.dp
-
-        val upEnabled = index > 0
-        IconButton(
-            {
-                onStateChanged(dataList.elementAt(index - 1))
-            },
-            enabled = upEnabled
-        ) {
-            Icon(Icons.Default.KeyboardArrowUp, "", tint = if (upEnabled) arrowsColor else disabledArrowsColor)
-        }
-
-        Spacer(modifier = Modifier.height(spacing))
-        Box(
-            modifier = Modifier,
-            contentAlignment = Alignment.Center
-        ) {
-            ProvideTextStyle(textStyle) {
-                dataList.forEachIndexed { i, t ->
-                    val alpha = when {
-                        i == indexAnimatedOffset - 1 -> coercedAnimatedOffset / halvedNumbersColumnHeightPx
-                        i == indexAnimatedOffset -> 1 - (abs(coercedAnimatedOffset) / halvedNumbersColumnHeightPx)
-                        i == indexAnimatedOffset + 1 -> -coercedAnimatedOffset / halvedNumbersColumnHeightPx
-                        else -> return@forEachIndexed
-                    }
-                    val offset = when {
-                        i == indexAnimatedOffset - 1 && coercedAnimatedOffset > 0 -> coercedAnimatedOffset - halvedNumbersColumnHeightPx
-                        i == indexAnimatedOffset -> coercedAnimatedOffset
-                        i == indexAnimatedOffset + 1 && coercedAnimatedOffset < 0 -> coercedAnimatedOffset + halvedNumbersColumnHeightPx
-                        else -> return@forEachIndexed
-                    }
-                    Text(
-                        text = dataToString(t),
-                        modifier = Modifier
-                            .alpha(alpha)
-                            .offset(y = with(LocalDensity.current) { offset.toDp() })
-                    )
-                }
-            }
-        }
-
-
-        Spacer(modifier = Modifier.height(spacing))
-
-        val downEnabled = index < lastIndex
-        IconButton(
-            {
-                onStateChanged(dataList.elementAt(index + 1))
-            },
-            enabled = downEnabled
-        ) {
-            Icon(Icons.Default.KeyboardArrowDown, "", tint = if (downEnabled) arrowsColor else disabledArrowsColor)
-        }
-    }
-}

android/recyclerview/build.gradle

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

android/recyclerview/src/androidMain/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest/>

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

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

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

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

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

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

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

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

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

@@ -1,91 +0,0 @@
-package dev.inmo.micro_utils.android.recyclerview
-
-import android.view.View
-import android.view.ViewGroup
-import androidx.recyclerview.widget.RecyclerView
-import kotlinx.coroutines.flow.*
-
-
-abstract class RecyclerViewAdapter<T>: RecyclerView.Adapter<AbstractViewHolder<T>>() {
-    protected abstract val data: List<T>
-
-    private val _dataCountState by lazy {
-        MutableStateFlow<Int>(data.size)
-    }
-    val dataCountState: StateFlow<Int> by lazy {
-        _dataCountState.asStateFlow()
-    }
-
-    var emptyView: View? = null
-        set(value) {
-            field = value
-            checkEmpty()
-        }
-
-    init {
-        registerAdapterDataObserver(
-            object : RecyclerView.AdapterDataObserver() {
-                override fun onItemRangeChanged(positionStart: Int, itemCount: Int) {
-                    super.onItemRangeChanged(positionStart, itemCount)
-                    _dataCountState.value = data.size
-                    checkEmpty()
-                }
-
-                override fun onItemRangeChanged(positionStart: Int, itemCount: Int, payload: Any?) {
-                    super.onItemRangeChanged(positionStart, itemCount, payload)
-                    _dataCountState.value = data.size
-                    checkEmpty()
-                }
-
-                override fun onChanged() {
-                    super.onChanged()
-                    _dataCountState.value = data.size
-                    checkEmpty()
-                }
-
-                override fun onItemRangeRemoved(positionStart: Int, itemCount: Int) {
-                    super.onItemRangeRemoved(positionStart, itemCount)
-                    _dataCountState.value = data.size
-                    checkEmpty()
-                }
-
-                override fun onItemRangeMoved(fromPosition: Int, toPosition: Int, itemCount: Int) {
-                    super.onItemRangeMoved(fromPosition, toPosition, itemCount)
-                    _dataCountState.value = data.size
-                    checkEmpty()
-                }
-
-                override fun onItemRangeInserted(positionStart: Int, itemCount: Int) {
-                    super.onItemRangeInserted(positionStart, itemCount)
-                    _dataCountState.value = data.size
-                    checkEmpty()
-                }
-            }
-        )
-        checkEmpty()
-    }
-
-    override fun getItemCount(): Int = data.size
-
-    override fun onBindViewHolder(holder: AbstractViewHolder<T>, position: Int) {
-        holder.onBind(data[position])
-    }
-
-    private fun checkEmpty() {
-        emptyView ?. let {
-            if (dataCountState.value == 0) {
-                it.visibility = View.VISIBLE
-            } else {
-                it.visibility = View.GONE
-            }
-        }
-    }
-}
-
-fun <T> RecyclerViewAdapter(
-    data: List<T>,
-    onCreateViewHolder: (parent: ViewGroup, viewType: Int) -> AbstractViewHolder<T>
-) = object : RecyclerViewAdapter<T>() {
-    override val data: List<T> = data
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): AbstractViewHolder<T> = onCreateViewHolder(parent, viewType)
-}

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

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

android/smalltextfield/build.gradle

@@ -1,19 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.multiplatform"
-    id "org.jetbrains.kotlin.plugin.serialization"
-    id "com.android.kotlin.multiplatform.library"
-    alias(libs.plugins.jb.compose)
-    alias(libs.plugins.kt.jb.compose)
-}
-
-apply from: "$mppProjectWithSerializationAndCompose"
-
-kotlin {
-    sourceSets {
-        androidMain {
-            dependencies {
-                api libs.jb.compose.material3
-            }
-        }
-    }
-}

android/smalltextfield/src/androidMain/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest/>

android/smalltextfield/src/androidMain/kotlin/SmallTextField.kt

@@ -1,66 +0,0 @@
-package dev.inmo.micro_utils.android.smalltextfield
-
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.defaultMinSize
-import androidx.compose.foundation.text.BasicTextField
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.foundation.text.selection.LocalTextSelectionColors
-import androidx.compose.material3.*
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.Shape
-import androidx.compose.ui.graphics.SolidColor
-import androidx.compose.ui.graphics.takeOrElse
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.input.VisualTransformation
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun SmallTextField(
-    value: String,
-    onValueChange: (String) -> Unit,
-    modifier: Modifier = Modifier,
-    enabled: Boolean = true,
-    readOnly: Boolean = false,
-    textStyle: TextStyle = LocalTextStyle.current,
-    textColor: Color = textStyle.color.takeOrElse {
-        LocalContentColor.current
-    },
-    visualTransformation: VisualTransformation = VisualTransformation.None,
-    keyboardOptions: KeyboardOptions = KeyboardOptions.Default,
-    keyboardActions: KeyboardActions = KeyboardActions.Default,
-    singleLine: Boolean = false,
-    maxLines: Int = if (singleLine) 1 else Int.MAX_VALUE,
-    minLines: Int = 1,
-    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
-) {
-    BasicTextField(
-        value = value,
-        modifier = modifier,
-        onValueChange = onValueChange,
-        enabled = enabled,
-        readOnly = readOnly,
-        textStyle = textStyle.copy(
-            color = textColor
-        ),
-        visualTransformation = visualTransformation,
-        keyboardOptions = keyboardOptions,
-        keyboardActions = keyboardActions,
-        interactionSource = interactionSource,
-        singleLine = singleLine,
-        maxLines = maxLines,
-        minLines = minLines,
-        cursorBrush = SolidColor(
-            textStyle.color.takeOrElse {
-                LocalContentColor.current
-            }
-        )
-    )
-}

build.gradle

@@ -1,56 +0,0 @@
-buildscript {
-    repositories {
-        google()
-        mavenCentral()
-        mavenLocal()
-        maven { url "https://plugins.gradle.org/m2/" }
-    }
-
-    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
-    }
-}
-
-plugins {
-    alias(libs.plugins.versions)
-    alias(libs.plugins.nmcp.aggregation)
-}
-
-
-if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
-    nmcpAggregation {
-        centralPortal {
-            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')
-            validationTimeout = Duration.ofHours(4)
-            publishingType = System.getenv('PUBLISHING_TYPE') != "" ? System.getenv('PUBLISHING_TYPE') : "USER_MANAGED"
-        }
-
-        publishAllProjectsProbablyBreakingProjectIsolation()
-    }
-}
-
-allprojects {
-    repositories {
-        mavenCentral()
-        google()
-        maven { url "https://maven.pkg.jetbrains.space/public/p/compose/dev" }
-//        maven { url "https://nexus.inmo.dev/repository/maven-releases/" }
-        mavenLocal()
-    }
-
-
-    it.tasks.withType(AbstractTestTask).configureEach {
-        it.failOnNoDiscoveredTests = false
-    }
-}
-
-apply from: "./extensions.gradle"
-apply from: "./github_release.gradle"
-apply from: "./versions_plugin_setup.gradle"

build_and_publish.sh

@@ -1,18 +0,0 @@
-#!/bin/bash
-
-function assert_success() {
-    "${@}"
-    local status=${?}
-    if [ ${status} -ne 0 ]; then
-        echo "### Error ${status} at: ${BASH_LINENO[*]} ###"
-        exit ${status}
-    fi
-}
-
-export RELEASE_MODE=true
-project="$1"
-
-assert_success ./gradlew clean
-assert_success ./gradlew "$project:build"
-assert_success ./gradlew "$project:publishToMavenLocal"
-assert_success ./gradlew "$project:bintrayUpload"

changelog_parser.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-
-function parse() {
-    version="$1"
-
-    while IFS= read -r line && [ -z "`echo "$line" | grep -e "^#\+ $version"`" ]
-    do
-        : # do nothing
-    done
-
-    while IFS= read -r line && [ -z "`echo "$line" | grep -e "^#\+"`" ]
-    do
-        echo "$line"
-    done
-}
-
-version="$1"
-file="$2"
-
-if [ -n "$file" ]; then
-  parse "$version" < "$file"
-else
-  parse "$version"
-fi

colors/build.gradle

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

colors/common/build.gradle

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

colors/common/src/commonMain/kotlin/HEXAColor.kt

@@ -1,174 +0,0 @@
-package dev.inmo.micro_utils.colors.common
-
-import kotlinx.serialization.Serializable
-import kotlin.jvm.JvmInline
-import kotlin.math.floor
-
-/**
- * Wrapper for RGBA colors. Receiving [UInt] in main constructor. Each part in main constructor
- * configured with `0x00 - 0xff` range. Examples:
- *
- * * Red: `0xff0000ffu`
- * * Red (0.5 capacity): `0xff000088u`
- *
- * Anyway it is recommended to use
- *
- * @param hexaUInt rgba [UInt] in format `0xRRGGBBAA` where RR - red, GG - green, BB - blue` and AA - alpha
- */
-@Serializable
-@JvmInline
-value class HEXAColor (
-    val hexaUInt: UInt
-) : Comparable<HEXAColor> {
-    /**
-     * @returns [hexaUInt] as a string with format `#RRGGBBAA` where RR - red, GG - green, BB - blue and AA - alpha
-     */
-    val hexa: String
-        get() = "#${hexaUInt.toString(16).padStart(8, '0')}"
-
-    /**
-     * @returns [hexaUInt] as a string with format `#RRGGBB` where RR - red, GG - green and BB - blue
-     */
-    val hex: String
-        get() = hexa.take(7)
-    /**
-     * @returns [hexaUInt] as a string with format `#AARRGGBB` where AA - alpha, RR - red, GG - green and BB - blue
-     */
-    val ahex: String
-        get() = "#${a.toString(16).padStart(2, '2')}${hex.drop(1)}"
-    val rgba: String
-        get() = "rgba($r,$g,$b,${aOfOne.toString().take(5)})"
-    val rgb: String
-        get() = "rgb($r,$g,$b)"
-    val shortHex: String
-        get() = "#${r.shortPart()}${g.shortPart()}${b.shortPart()}"
-    val shortHexa: String
-        get() = "$shortHex${a.shortPart()}"
-    val rgbUInt: UInt
-        get() = (hexaUInt / 256u)
-    val rgbInt: Int
-        get() = rgbUInt.toInt()
-    val ahexUInt
-        get() = (a * 0x1000000).toUInt() + rgbUInt
-
-    val r: Int
-        get() = ((hexaUInt and 0xff000000u) / 0x1000000u).toInt()
-    val g: Int
-        get() = ((hexaUInt and 0x00ff0000u) / 0x10000u).toInt()
-    val b: Int
-        get() = ((hexaUInt and 0x0000ff00u) / 0x100u).toInt()
-    val a: Int
-        get() = ((hexaUInt and 0x000000ffu)).toInt()
-    val aOfOne: Float
-        get() = a.toFloat() / (0xff)
-    init {
-        require(hexaUInt in 0u ..0xffffffffu)
-    }
-
-    constructor(r: Int, g: Int, b: Int, a: Int) : this(
-        ((r * 0x1000000).toLong() + g * 0x10000 + b * 0x100 + a).toUInt()
-    ) {
-        require(r in 0 ..0xff)
-        require(g in 0 ..0xff)
-        require(b in 0 ..0xff)
-        require(a in 0 ..0xff)
-    }
-
-    constructor(r: Int, g: Int, b: Int, aOfOne: Float = 1f) : this(
-        r = r, g = g, b = b, a = (aOfOne * 0xff).toInt()
-    )
-
-    override fun toString(): String {
-        return hexa
-    }
-
-    override fun compareTo(other: HEXAColor): Int = (hexaUInt - other.hexaUInt).coerceIn(Int.MIN_VALUE.toUInt(), Int.MAX_VALUE.toLong().toUInt()).toInt()
-
-    fun copy(
-        r: Int = this.r,
-        g: Int = this.g,
-        b: Int = this.b,
-        aOfOne: Float = this.aOfOne
-    ) = HEXAColor(r = r, g = g, b = b, aOfOne = aOfOne)
-    fun copy(
-        r: Int = this.r,
-        g: Int = this.g,
-        b: Int = this.b,
-        a: Int
-    ) = HEXAColor(r = r, g = g, b = b, a = a)
-
-    companion object {
-        /**
-         * Parsing color from [color]
-         *
-         * Supported formats samples (on Red color based):
-         *
-         * * `#f00`
-         * * `#f00f`
-         * * `#ff0000`
-         * * `#ff0000ff`
-         * * `rgb(255, 0, 0)`
-         * * `rgba(255, 0, 0, 1)`
-         */
-        fun parseStringColor(color: String): HEXAColor = when {
-            color.startsWith("#") -> color.removePrefix("#").let { color ->
-                when (color.length) {
-                    3 -> color.map { "$it$it" }.joinToString(separator = "", postfix = "ff")
-                    4 -> color.take(3).map { "$it$it" }.joinToString(separator = "", postfix = color.takeLast(1).let { "${it}0" })
-                    6 -> "${color}ff"
-                    8 -> color
-                    else -> error("Malfurmed color string: $color. It is expected that color started with # will contains 3, 6 or 8 valuable parts")
-                }
-            }
-            color.startsWith("rgb(") -> color
-                .removePrefix("rgb(")
-                .removeSuffix(")")
-                .replace(Regex("\\s"), "")
-                .split(",")
-                .joinToString("", postfix = "ff") {
-                    it.toInt().toString(16).padStart(2, '0')
-                }
-            color.startsWith("rgba(") -> color
-                .removePrefix("rgba(")
-                .removeSuffix(")")
-                .replace(Regex("\\s"), "")
-                .split(",").let {
-                    it.take(3).map { it.toInt().toString(16).padStart(2, '0') } + (it.last().toFloat() * 0xff).toInt().toString(16).padStart(2, '0')
-                }
-                .joinToString("")
-            else -> color
-        }.lowercase().toUInt(16).let(::HEXAColor)
-
-        /**
-         * Creates [HEXAColor] from [uint] presume it is in format `0xRRGGBBAA` where RR - red, GG - green, BB - blue` and AA - alpha
-         */
-        fun fromHexa(uint: UInt) = HEXAColor(uint)
-
-        /**
-         * Creates [HEXAColor] from [uint] presume it is in format `0xAARRGGBB` where AA - alpha, RR - red, GG - green and BB - blue`
-         */
-        fun fromAhex(uint: UInt) = HEXAColor(
-            a = ((uint and 0xff000000u) / 0x1000000u).toInt(),
-            r = ((uint and 0x00ff0000u) / 0x10000u).toInt(),
-            g = ((uint and 0x0000ff00u) / 0x100u).toInt(),
-            b = ((uint and 0x000000ffu)).toInt()
-        )
-
-        /**
-         * Parsing color from [color]
-         *
-         * Supported formats samples (on Red color based):
-         *
-         * * `#f00`
-         * * `#ff0000`
-         * * `#ff0000ff`
-         * * `rgb(255, 0, 0)`
-         * * `rgba(255, 0, 0, 1)`
-         */
-        operator fun invoke(color: String) = parseStringColor(color)
-
-        private fun Int.shortPart(): String {
-            return (floor(toFloat() / 16)).toInt().toString(16)
-        }
-    }
-}

colors/common/src/commonTest/kotlin/HexColorTests.kt

@@ -1,209 +0,0 @@
-package dev.inmo.micro_utils.colors.common
-
-import kotlin.math.floor
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertTrue
-
-class HexColorTests {
-    val alphaRgbaPrecision = 5
-    class TestColor(
-        val color: HEXAColor,
-        val shortHex: String,
-        val shortHexa: String,
-        val hex: String,
-        val hexa: String,
-        val ahex: String,
-        val ahexUInt: UInt,
-        val rgbUInt: UInt,
-        val rgb: String,
-        val rgba: String,
-        val r: Int,
-        val g: Int,
-        val b: Int,
-        val a: Int,
-        vararg val additionalRGBAVariants: String
-    )
-    val testColors: List<TestColor>
-        get() = listOf(
-            TestColor(
-                color = HEXAColor(hexaUInt = 0xff0000ffu),
-                shortHex = "#f00",
-                shortHexa = "#f00f",
-                hex = "#ff0000",
-                hexa = "#ff0000ff",
-                ahex = "#ffff0000",
-                ahexUInt = 0xffff0000u,
-                rgbUInt = 0xff0000u,
-                rgb = "rgb(255,0,0)",
-                rgba = "rgba(255,0,0,1.0)",
-                r = 0xff,
-                g = 0x00,
-                b = 0x00,
-                a = 0xff,
-                "rgba(255,0,0,1)",
-            ),
-            TestColor(
-                color = HEXAColor(hexaUInt = 0x00ff00ffu),
-                shortHex = "#0f0",
-                shortHexa = "#0f0f",
-                hex = "#00ff00",
-                hexa = "#00ff00ff",
-                ahex = "#ff00ff00",
-                ahexUInt = 0xff00ff00u,
-                rgbUInt = 0x00ff00u,
-                rgb = "rgb(0,255,0)",
-                rgba = "rgba(0,255,0,1.0)",
-                r = 0x00,
-                g = 0xff,
-                b = 0x00,
-                a = 0xff,
-                "rgba(0,255,0,1)"
-            ),
-            TestColor(
-                color = HEXAColor(0x0000ffffu),
-                shortHex = "#00f",
-                shortHexa = "#00ff",
-                hex = "#0000ff",
-                hexa = "#0000ffff",
-                ahex = "#ff0000ff",
-                ahexUInt = 0xff0000ffu,
-                rgbUInt = 0x0000ffu,
-                rgb = "rgb(0,0,255)",
-                rgba = "rgba(0,0,255,1.0)",
-                r = 0x00,
-                g = 0x00,
-                b = 0xff,
-                a = 0xff,
-                "rgba(0,0,255,1)"
-            ),
-            TestColor(
-                color = HEXAColor(0xff000088u),
-                shortHex = "#f00",
-                shortHexa = "#f008",
-                hex = "#ff0000",
-                hexa = "#ff000088",
-                ahex = "#88ff0000",
-                ahexUInt = 0x88ff0000u,
-                rgbUInt = 0xff0000u,
-                rgb = "rgb(255,0,0)",
-                rgba = "rgba(255,0,0,0.533)",
-                r = 0xff,
-                g = 0x00,
-                b = 0x00,
-                a = 0x88,
-            ),
-            TestColor(
-                color = HEXAColor(0x00ff0088u),
-                shortHex = "#0f0",
-                shortHexa = "#0f08",
-                hex = "#00ff00",
-                hexa = "#00ff0088",
-                ahex = "#8800ff00",
-                ahexUInt = 0x8800ff00u,
-                rgbUInt = 0x00ff00u,
-                rgb = "rgb(0,255,0)",
-                rgba = "rgba(0,255,0,0.533)",
-                r = 0x00,
-                g = 0xff,
-                b = 0x00,
-                a = 0x88,
-            ),
-            TestColor(
-                color = HEXAColor(0x0000ff88u),
-                shortHex = "#00f",
-                shortHexa = "#00f8",
-                hex = "#0000ff",
-                hexa = "#0000ff88",
-                ahex = "#880000ff",
-                ahexUInt = 0x880000ffu,
-                rgbUInt = 0x0000ffu,
-                rgb = "rgb(0,0,255)",
-                rgba = "rgba(0,0,255,0.533)",
-                r = 0x00,
-                g = 0x00,
-                b = 0xff,
-                a = 0x88,
-            ),
-            TestColor(
-                color = HEXAColor(0xff000022u),
-                shortHex = "#f00",
-                shortHexa = "#f002",
-                hex = "#ff0000",
-                hexa = "#ff000022",
-                ahex = "#22ff0000",
-                ahexUInt = 0x22ff0000u,
-                rgbUInt = 0xff0000u,
-                rgb = "rgb(255,0,0)",
-                rgba = "rgba(255,0,0,0.133)",
-                r = 0xff,
-                g = 0x00,
-                b = 0x00,
-                a = 0x22,
-            ),
-            TestColor(
-                color = HEXAColor(0x00ff0022u),
-                shortHex = "#0f0",
-                shortHexa = "#0f02",
-                hex = "#00ff00",
-                hexa = "#00ff0022",
-                ahex = "#2200ff00",
-                ahexUInt = 0x2200ff00u,
-                rgbUInt = 0x00ff00u,
-                rgb = "rgb(0,255,0)",
-                rgba = "rgba(0,255,0,0.133)",
-                r = 0x00,
-                g = 0xff,
-                b = 0x00,
-                a = 0x22,
-            ),
-            TestColor(
-                color = HEXAColor(0x0000ff22u),
-                shortHex = "#00f",
-                shortHexa = "#00f2",
-                hex = "#0000ff",
-                hexa = "#0000ff22",
-                ahex = "#220000ff",
-                ahexUInt = 0x220000ffu,
-                rgbUInt = 0x0000ffu,
-                rgb = "rgb(0,0,255)",
-                rgba = "rgba(0,0,255,0.133)",
-                r = 0x00,
-                g = 0x00,
-                b = 0xff,
-                a = 0x22,
-            ),
-        )
-
-    @Test
-    fun baseTest() {
-        testColors.forEach {
-            assertEquals(it.hex, it.color.hex)
-            assertEquals(it.hexa, it.color.hexa)
-            assertEquals(it.ahex, it.color.ahex)
-            assertEquals(it.rgbUInt, it.color.rgbUInt)
-            assertEquals(it.ahexUInt, it.color.ahexUInt)
-            assertEquals(it.shortHex, it.color.shortHex)
-            assertEquals(it.shortHexa, it.color.shortHexa)
-            assertEquals(it.rgb, it.color.rgb)
-            assertTrue(it.rgba == it.color.rgba || it.color.rgba in it.additionalRGBAVariants)
-            assertEquals(it.r, it.color.r)
-            assertEquals(it.g, it.color.g)
-            assertEquals(it.b, it.color.b)
-            assertEquals(it.a, it.color.a)
-            assertEquals(it.color, HEXAColor.fromAhex(it.ahexUInt))
-        }
-    }
-
-    @Test
-    fun testHexParseColor() {
-        testColors.forEach {
-            assertEquals(it.color.copy(aOfOne = 1f), HEXAColor.parseStringColor(it.hex))
-            assertEquals(it.color, HEXAColor.parseStringColor(it.hexa))
-            assertEquals(it.color.copy(aOfOne = 1f), HEXAColor.parseStringColor(it.rgb))
-            assertTrue(it.color.hexaUInt.toInt() - HEXAColor.parseStringColor(it.rgba).hexaUInt.toInt() in -0x1 .. 0x1, )
-            assertEquals(it.color.copy(aOfOne = 1f), HEXAColor.parseStringColor(it.shortHex))
-            assertEquals(it.color.copy(a = floor(it.color.a.toFloat() / 16).toInt() * 0x10), HEXAColor.parseStringColor(it.shortHexa))
-        }
-    }
-}

colors/src/commonMain/kotlin/StandardColors.kt

@@ -1,890 +0,0 @@
-/**
- * Standard HTML/CSS color constants as [HEXAColor] extension properties.
- * Provides convenient access to all standard web colors like red, blue, green, etc.
- * All colors are defined with full opacity (alpha = 0xFF).
- */
-package dev.inmo.micro_utils.colors
-
-import dev.inmo.micro_utils.colors.common.HEXAColor
-
-/**
- * Alice Blue - A pale blue color (#F0F8FF).
- */
-val HEXAColor.Companion.aliceblue
-    get() = HEXAColor(0xF0F8FFFFu)
-
-/**
- * Antique White - A pale beige color (#FAEBD7).
- */
-val HEXAColor.Companion.antiquewhite
-    get() = HEXAColor(0xFAEBD7FFu)
-
-/**
- * Aqua - A bright cyan color (#00FFFF).
- */
-val HEXAColor.Companion.aqua
-    get() = HEXAColor(0x00FFFFFFu)
-
-/**
- * Aquamarine - A medium blue-green color (#7FFFD4).
- */
-val HEXAColor.Companion.aquamarine
-    get() = HEXAColor(0x7FFFD4FFu)
-
-/**
- * Azure - A pale cyan-blue color (#F0FFFF).
- */
-val HEXAColor.Companion.azure
-    get() = HEXAColor(0xF0FFFFFFu)
-
-/**
- * Beige - A pale sandy tan color (#F5F5DC).
- */
-val HEXAColor.Companion.beige
-    get() = HEXAColor(0xF5F5DCFFu)
-
-/**
- * Bisque - A pale orange color (#FFE4C4).
- */
-val HEXAColor.Companion.bisque
-    get() = HEXAColor(0xFFE4C4FFu)
-
-/**
- * Black - Pure black color (#000000).
- */
-val HEXAColor.Companion.black
-    get() = HEXAColor(0x000000FFu)
-
-/**
- * Blanched Almond - A pale peachy color (#FFEBCD).
- */
-val HEXAColor.Companion.blanchedalmond
-    get() = HEXAColor(0xFFEBCDFFu)
-
-/**
- * Blue - Pure blue color (#0000FF).
- */
-val HEXAColor.Companion.blue
-    get() = HEXAColor(0x0000FFFFu)
-
-/**
- * Blue Violet - A vivid purple-blue color (#8A2BE2).
- */
-val HEXAColor.Companion.blueviolet
-    get() = HEXAColor(0x8A2BE2FFu)
-
-/**
- * Brown - A dark reddish-brown color (#A52A2A).
- */
-val HEXAColor.Companion.brown
-    get() = HEXAColor(0xA52A2AFFu)
-
-/**
- * Burlywood - A sandy tan color (#DEB887).
- */
-val HEXAColor.Companion.burlywood
-    get() = HEXAColor(0xDEB887FFu)
-
-/**
- * Cadet Blue - A grayish-blue color (#5F9EA0).
- */
-val HEXAColor.Companion.cadetblue
-    get() = HEXAColor(0x5F9EA0FFu)
-
-/**
- * Chartreuse - A bright yellow-green color (#7FFF00).
- */
-val HEXAColor.Companion.chartreuse
-    get() = HEXAColor(0x7FFF00FFu)
-
-/**
- * Chocolate - A medium brown color (#D2691E).
- */
-val HEXAColor.Companion.chocolate
-    get() = HEXAColor(0xD2691EFFu)
-
-/**
- * Coral - A vibrant orange-pink color (#FF7F50).
- */
-val HEXAColor.Companion.coral
-    get() = HEXAColor(0xFF7F50FFu)
-
-/**
- * Cornflower Blue - A medium blue color (#6495ED).
- */
-val HEXAColor.Companion.cornflowerblue
-    get() = HEXAColor(0x6495EDFFu)
-
-/**
- * Cornsilk - A pale yellow color (#FFF8DC).
- */
-val HEXAColor.Companion.cornsilk
-    get() = HEXAColor(0xFFF8DCFFu)
-
-/**
- * Crimson - A vivid red color (#DC143C).
- */
-val HEXAColor.Companion.crimson
-    get() = HEXAColor(0xDC143CFFu)
-
-/**
- * Cyan - A bright cyan color (#00FFFF).
- */
-val HEXAColor.Companion.cyan
-    get() = HEXAColor(0x00FFFFFFu)
-
-/**
- * Dark Blue - A dark blue color (#00008B).
- */
-val HEXAColor.Companion.darkblue
-    get() = HEXAColor(0x00008BFFu)
-
-/**
- * Dark Cyan - A dark cyan color (#008B8B).
- */
-val HEXAColor.Companion.darkcyan
-    get() = HEXAColor(0x008B8BFFu)
-
-/**
- * Dark Goldenrod - A dark golden yellow color (#B8860B).
- */
-val HEXAColor.Companion.darkgoldenrod
-    get() = HEXAColor(0xB8860BFFu)
-
-/**
- * Dark Gray - A dark gray color (#A9A9A9).
- */
-val HEXAColor.Companion.darkgray
-    get() = HEXAColor(0xA9A9A9FFu)
-
-/**
- * Dark Green - A dark green color (#006400).
- */
-val HEXAColor.Companion.darkgreen
-    get() = HEXAColor(0x006400FFu)
-
-/**
- * Dark Grey - A dark gray color (#A9A9A9).
- */
-val HEXAColor.Companion.darkgrey
-    get() = HEXAColor(0xA9A9A9FFu)
-
-/**
- * Dark Khaki - A brownish-tan color (#BDB76B).
- */
-val HEXAColor.Companion.darkkhaki
-    get() = HEXAColor(0xBDB76BFFu)
-
-/**
- * Dark Magenta - A dark magenta/purple color (#8B008B).
- */
-val HEXAColor.Companion.darkmagenta
-    get() = HEXAColor(0x8B008BFFu)
-
-/**
- * Dark Olive Green - A dark olive green color (#556B2F).
- */
-val HEXAColor.Companion.darkolivegreen
-    get() = HEXAColor(0x556B2FFFu)
-
-/**
- * Dark Orange - A vivid dark orange color (#FF8C00).
- */
-val HEXAColor.Companion.darkorange
-    get() = HEXAColor(0xFF8C00FFu)
-
-/**
- * Dark Orchid - A dark purple color (#9932CC).
- */
-val HEXAColor.Companion.darkorchid
-    get() = HEXAColor(0x9932CCFFu)
-
-/**
- * Dark Red - A dark red color (#8B0000).
- */
-val HEXAColor.Companion.darkred
-    get() = HEXAColor(0x8B0000FFu)
-
-/**
- * Dark Salmon - A muted salmon color (#E9967A).
- */
-val HEXAColor.Companion.darksalmon
-    get() = HEXAColor(0xE9967AFFu)
-
-/**
- * Dark Sea Green - A muted sea green color (#8FBC8F).
- */
-val HEXAColor.Companion.darkseagreen
-    get() = HEXAColor(0x8FBC8FFFu)
-
-/**
- * Dark Slate Blue - A dark grayish-blue color (#483D8B).
- */
-val HEXAColor.Companion.darkslateblue
-    get() = HEXAColor(0x483D8BFFu)
-
-/**
- * Dark Slate Gray - A very dark grayish-cyan color (#2F4F4F).
- */
-val HEXAColor.Companion.darkslategray
-    get() = HEXAColor(0x2F4F4FFFu)
-
-/**
- * Dark Slate Grey - A very dark grayish-cyan color (#2F4F4F).
- */
-val HEXAColor.Companion.darkslategrey
-    get() = HEXAColor(0x2F4F4FFFu)
-
-/**
- * Dark Turquoise - A dark turquoise color (#00CED1).
- */
-val HEXAColor.Companion.darkturquoise
-    get() = HEXAColor(0x00CED1FFu)
-
-/**
- * Dark Violet - A dark violet color (#9400D3).
- */
-val HEXAColor.Companion.darkviolet
-    get() = HEXAColor(0x9400D3FFu)
-
-/**
- * Deep Pink - A vivid pink color (#FF1493).
- */
-val HEXAColor.Companion.deeppink
-    get() = HEXAColor(0xFF1493FFu)
-
-/**
- * Deep Sky Blue - A bright sky blue color (#00BFFF).
- */
-val HEXAColor.Companion.deepskyblue
-    get() = HEXAColor(0x00BFFFFFu)
-
-/**
- * Dim Gray - A dim gray color (#696969).
- */
-val HEXAColor.Companion.dimgray
-    get() = HEXAColor(0x696969FFu)
-
-/**
- * Dim Grey - A dim gray color (#696969).
- */
-val HEXAColor.Companion.dimgrey
-    get() = HEXAColor(0x696969FFu)
-
-/**
- * Dodger Blue - A bright blue color (#1E90FF).
- */
-val HEXAColor.Companion.dodgerblue
-    get() = HEXAColor(0x1E90FFFFu)
-
-/**
- * Firebrick - A dark red brick color (#B22222).
- */
-val HEXAColor.Companion.firebrick
-    get() = HEXAColor(0xB22222FFu)
-
-/**
- * Floral White - A very pale cream color (#FFFAF0).
- */
-val HEXAColor.Companion.floralwhite
-    get() = HEXAColor(0xFFFAF0FFu)
-
-/**
- * Forest Green - A medium forest green color (#228B22).
- */
-val HEXAColor.Companion.forestgreen
-    get() = HEXAColor(0x228B22FFu)
-
-/**
- * Fuchsia - A vivid magenta color (#FF00FF).
- */
-val HEXAColor.Companion.fuchsia
-    get() = HEXAColor(0xFF00FFFFu)
-
-/**
- * Gainsboro - A light gray color (#DCDCDC).
- */
-val HEXAColor.Companion.gainsboro
-    get() = HEXAColor(0xDCDCDCFFu)
-
-/**
- * Ghost White - A very pale blue-white color (#F8F8FF).
- */
-val HEXAColor.Companion.ghostwhite
-    get() = HEXAColor(0xF8F8FFFFu)
-
-/**
- * Gold - A bright golden yellow color (#FFD700).
- */
-val HEXAColor.Companion.gold
-    get() = HEXAColor(0xFFD700FFu)
-
-/**
- * Goldenrod - A golden yellow color (#DAA520).
- */
-val HEXAColor.Companion.goldenrod
-    get() = HEXAColor(0xDAA520FFu)
-
-/**
- * Gray - A medium gray color (#808080).
- */
-val HEXAColor.Companion.gray
-    get() = HEXAColor(0x808080FFu)
-
-/**
- * Green - A pure green color (#008000).
- */
-val HEXAColor.Companion.green
-    get() = HEXAColor(0x008000FFu)
-
-/**
- * Green Yellow - A bright yellow-green color (#ADFF2F).
- */
-val HEXAColor.Companion.greenyellow
-    get() = HEXAColor(0xADFF2FFFu)
-
-/**
- * Grey - A medium gray color (#808080).
- */
-val HEXAColor.Companion.grey
-    get() = HEXAColor(0x808080FFu)
-
-/**
- * Honeydew - A very pale green color (#F0FFF0).
- */
-val HEXAColor.Companion.honeydew
-    get() = HEXAColor(0xF0FFF0FFu)
-
-/**
- * Hot Pink - A vibrant pink color (#FF69B4).
- */
-val HEXAColor.Companion.hotpink
-    get() = HEXAColor(0xFF69B4FFu)
-
-/**
- * Indian Red - A medium red color (#CD5C5C).
- */
-val HEXAColor.Companion.indianred
-    get() = HEXAColor(0xCD5C5CFFu)
-
-/**
- * Indigo - A deep blue-violet color (#4B0082).
- */
-val HEXAColor.Companion.indigo
-    get() = HEXAColor(0x4B0082FFu)
-
-/**
- * Ivory - A very pale cream color (#FFFFF0).
- */
-val HEXAColor.Companion.ivory
-    get() = HEXAColor(0xFFFFF0FFu)
-
-/**
- * Khaki - A light tan color (#F0E68C).
- */
-val HEXAColor.Companion.khaki
-    get() = HEXAColor(0xF0E68CFFu)
-
-/**
- * Lavender - A pale purple color (#E6E6FA).
- */
-val HEXAColor.Companion.lavender
-    get() = HEXAColor(0xE6E6FAFFu)
-
-/**
- * Lavender Blush - A very pale pink color (#FFF0F5).
- */
-val HEXAColor.Companion.lavenderblush
-    get() = HEXAColor(0xFFF0F5FFu)
-
-/**
- * Lawn Green - A bright chartreuse green color (#7CFC00).
- */
-val HEXAColor.Companion.lawngreen
-    get() = HEXAColor(0x7CFC00FFu)
-
-/**
- * Lemon Chiffon - A very pale yellow color (#FFFACD).
- */
-val HEXAColor.Companion.lemonchiffon
-    get() = HEXAColor(0xFFFACDFFu)
-
-/**
- * Light Blue - A light blue color (#ADD8E6).
- */
-val HEXAColor.Companion.lightblue
-    get() = HEXAColor(0xADD8E6FFu)
-
-/**
- * Light Coral - A light coral pink color (#F08080).
- */
-val HEXAColor.Companion.lightcoral
-    get() = HEXAColor(0xF08080FFu)
-
-/**
- * Light Cyan - A very pale cyan color (#E0FFFF).
- */
-val HEXAColor.Companion.lightcyan
-    get() = HEXAColor(0xE0FFFFFFu)
-
-/**
- * Light Goldenrod Yellow - A pale yellow color (#FAFAD2).
- */
-val HEXAColor.Companion.lightgoldenrodyellow
-    get() = HEXAColor(0xFAFAD2FFu)
-
-/**
- * Light Gray - A light gray color (#D3D3D3).
- */
-val HEXAColor.Companion.lightgray
-    get() = HEXAColor(0xD3D3D3FFu)
-
-/**
- * Light Green - A light green color (#90EE90).
- */
-val HEXAColor.Companion.lightgreen
-    get() = HEXAColor(0x90EE90FFu)
-
-/**
- * Light Grey - A light gray color (#D3D3D3).
- */
-val HEXAColor.Companion.lightgrey
-    get() = HEXAColor(0xD3D3D3FFu)
-
-/**
- * Light Pink - A light pink color (#FFB6C1).
- */
-val HEXAColor.Companion.lightpink
-    get() = HEXAColor(0xFFB6C1FFu)
-
-/**
- * Light Salmon - A light salmon color (#FFA07A).
- */
-val HEXAColor.Companion.lightsalmon
-    get() = HEXAColor(0xFFA07AFFu)
-
-/**
- * Light Sea Green - A medium sea green color (#20B2AA).
- */
-val HEXAColor.Companion.lightseagreen
-    get() = HEXAColor(0x20B2AAFFu)
-
-/**
- * Light Sky Blue - A light sky blue color (#87CEFA).
- */
-val HEXAColor.Companion.lightskyblue
-    get() = HEXAColor(0x87CEFAFFu)
-
-/**
- * Light Slate Gray - A light slate gray color (#778899).
- */
-val HEXAColor.Companion.lightslategray
-    get() = HEXAColor(0x778899FFu)
-
-/**
- * Light Slate Grey - A light slate gray color (#778899).
- */
-val HEXAColor.Companion.lightslategrey
-    get() = HEXAColor(0x778899FFu)
-
-/**
- * Light Steel Blue - A light steel blue color (#B0C4DE).
- */
-val HEXAColor.Companion.lightsteelblue
-    get() = HEXAColor(0xB0C4DEFFu)
-
-/**
- * Light Yellow - A very pale yellow color (#FFFFE0).
- */
-val HEXAColor.Companion.lightyellow
-    get() = HEXAColor(0xFFFFE0FFu)
-
-/**
- * Lime - A bright lime green color (#00FF00).
- */
-val HEXAColor.Companion.lime
-    get() = HEXAColor(0x00FF00FFu)
-
-/**
- * Lime Green - A lime green color (#32CD32).
- */
-val HEXAColor.Companion.limegreen
-    get() = HEXAColor(0x32CD32FFu)
-
-/**
- * Linen - A pale beige color (#FAF0E6).
- */
-val HEXAColor.Companion.linen
-    get() = HEXAColor(0xFAF0E6FFu)
-
-/**
- * Magenta - A bright magenta color (#FF00FF).
- */
-val HEXAColor.Companion.magenta
-    get() = HEXAColor(0xFF00FFFFu)
-
-/**
- * Maroon - A dark reddish-brown color (#800000).
- */
-val HEXAColor.Companion.maroon
-    get() = HEXAColor(0x800000FFu)
-
-/**
- * Medium Aquamarine - A medium aquamarine color (#66CDAA).
- */
-val HEXAColor.Companion.mediumaquamarine
-    get() = HEXAColor(0x66CDAAFFu)
-
-/**
- * Medium Blue - A medium blue color (#0000CD).
- */
-val HEXAColor.Companion.mediumblue
-    get() = HEXAColor(0x0000CDFFu)
-
-/**
- * Medium Orchid - A medium orchid purple color (#BA55D3).
- */
-val HEXAColor.Companion.mediumorchid
-    get() = HEXAColor(0xBA55D3FFu)
-
-/**
- * Medium Purple - A medium purple color (#9370DB).
- */
-val HEXAColor.Companion.mediumpurple
-    get() = HEXAColor(0x9370DBFFu)
-
-/**
- * Medium Sea Green - A medium sea green color (#3CB371).
- */
-val HEXAColor.Companion.mediumseagreen
-    get() = HEXAColor(0x3CB371FFu)
-
-/**
- * Medium Slate Blue - A medium slate blue color (#7B68EE).
- */
-val HEXAColor.Companion.mediumslateblue
-    get() = HEXAColor(0x7B68EEFFu)
-
-/**
- * Medium Spring Green - A medium spring green color (#00FA9A).
- */
-val HEXAColor.Companion.mediumspringgreen
-    get() = HEXAColor(0x00FA9AFFu)
-
-/**
- * Medium Turquoise - A medium turquoise color (#48D1CC).
- */
-val HEXAColor.Companion.mediumturquoise
-    get() = HEXAColor(0x48D1CCFFu)
-
-/**
- * Medium Violet Red - A medium violet-red color (#C71585).
- */
-val HEXAColor.Companion.mediumvioletred
-    get() = HEXAColor(0xC71585FFu)
-
-/**
- * Midnight Blue - A very dark blue color (#191970).
- */
-val HEXAColor.Companion.midnightblue
-    get() = HEXAColor(0x191970FFu)
-
-/**
- * Mint Cream - A very pale mint color (#F5FFFA).
- */
-val HEXAColor.Companion.mintcream
-    get() = HEXAColor(0xF5FFFAFFu)
-
-/**
- * Misty Rose - A very pale pink color (#FFE4E1).
- */
-val HEXAColor.Companion.mistyrose
-    get() = HEXAColor(0xFFE4E1FFu)
-
-/**
- * Moccasin - A pale peach color (#FFE4B5).
- */
-val HEXAColor.Companion.moccasin
-    get() = HEXAColor(0xFFE4B5FFu)
-
-/**
- * Navajo White - A pale peach color (#FFDEAD).
- */
-val HEXAColor.Companion.navajowhite
-    get() = HEXAColor(0xFFDEADFFu)
-
-/**
- * Navy - A very dark blue color (#000080).
- */
-val HEXAColor.Companion.navy
-    get() = HEXAColor(0x000080FFu)
-
-/**
- * Old Lace - A very pale cream color (#FDF5E6).
- */
-val HEXAColor.Companion.oldlace
-    get() = HEXAColor(0xFDF5E6FFu)
-
-/**
- * Olive - A dark yellowish-green color (#808000).
- */
-val HEXAColor.Companion.olive
-    get() = HEXAColor(0x808000FFu)
-
-/**
- * Olive Drab - A dark olive green color (#6B8E23).
- */
-val HEXAColor.Companion.olivedrab
-    get() = HEXAColor(0x6B8E23FFu)
-
-/**
- * Orange - A bright orange color (#FFA500).
- */
-val HEXAColor.Companion.orange
-    get() = HEXAColor(0xFFA500FFu)
-
-/**
- * Orange Red - A bright red-orange color (#FF4500).
- */
-val HEXAColor.Companion.orangered
-    get() = HEXAColor(0xFF4500FFu)
-
-/**
- * Orchid - A medium orchid purple color (#DA70D6).
- */
-val HEXAColor.Companion.orchid
-    get() = HEXAColor(0xDA70D6FFu)
-
-/**
- * Pale Goldenrod - A pale goldenrod yellow color (#EEE8AA).
- */
-val HEXAColor.Companion.palegoldenrod
-    get() = HEXAColor(0xEEE8AAFFu)
-
-/**
- * Pale Green - A pale green color (#98FB98).
- */
-val HEXAColor.Companion.palegreen
-    get() = HEXAColor(0x98FB98FFu)
-
-/**
- * Pale Turquoise - A pale turquoise color (#AFEEEE).
- */
-val HEXAColor.Companion.paleturquoise
-    get() = HEXAColor(0xAFEEEEFFu)
-
-/**
- * Pale Violet Red - A medium violet-red color (#DB7093).
- */
-val HEXAColor.Companion.palevioletred
-    get() = HEXAColor(0xDB7093FFu)
-
-/**
- * Papaya Whip - A pale peach color (#FFEFD5).
- */
-val HEXAColor.Companion.papayawhip
-    get() = HEXAColor(0xFFEFD5FFu)
-
-/**
- * Peach Puff - A light peach color (#FFDAB9).
- */
-val HEXAColor.Companion.peachpuff
-    get() = HEXAColor(0xFFDAB9FFu)
-
-/**
- * Peru - A medium brown color (#CD853F).
- */
-val HEXAColor.Companion.peru
-    get() = HEXAColor(0xCD853FFFu)
-
-/**
- * Pink - A light pink color (#FFC0CB).
- */
-val HEXAColor.Companion.pink
-    get() = HEXAColor(0xFFC0CBFFu)
-
-/**
- * Plum - A medium purple color (#DDA0DD).
- */
-val HEXAColor.Companion.plum
-    get() = HEXAColor(0xDDA0DDFFu)
-
-/**
- * Powder Blue - A light blue color (#B0E0E6).
- */
-val HEXAColor.Companion.powderblue
-    get() = HEXAColor(0xB0E0E6FFu)
-
-/**
- * Purple - A pure purple color (#800080).
- */
-val HEXAColor.Companion.purple
-    get() = HEXAColor(0x800080FFu)
-
-/**
- * Red - Pure red color (#FF0000).
- */
-val HEXAColor.Companion.red
-    get() = HEXAColor(0xFF0000FFu)
-
-/**
- * Rosy Brown - A rosy brown color (#BC8F8F).
- */
-val HEXAColor.Companion.rosybrown
-    get() = HEXAColor(0xBC8F8FFFu)
-
-/**
- * Royal Blue - A vibrant royal blue color (#4169E1).
- */
-val HEXAColor.Companion.royalblue
-    get() = HEXAColor(0x4169E1FFu)
-
-/**
- * Saddle Brown - A dark brown color (#8B4513).
- */
-val HEXAColor.Companion.saddlebrown
-    get() = HEXAColor(0x8B4513FFu)
-
-/**
- * Salmon - A light salmon pink color (#FA8072).
- */
-val HEXAColor.Companion.salmon
-    get() = HEXAColor(0xFA8072FFu)
-
-/**
- * Sandy Brown - A sandy brown color (#F4A460).
- */
-val HEXAColor.Companion.sandybrown
-    get() = HEXAColor(0xF4A460FFu)
-
-/**
- * Sea Green - A dark sea green color (#2E8B57).
- */
-val HEXAColor.Companion.seagreen
-    get() = HEXAColor(0x2E8B57FFu)
-
-/**
- * Seashell - A very pale pink-orange color (#FFF5EE).
- */
-val HEXAColor.Companion.seashell
-    get() = HEXAColor(0xFFF5EEFFu)
-
-/**
- * Sienna - A reddish-brown color (#A0522D).
- */
-val HEXAColor.Companion.sienna
-    get() = HEXAColor(0xA0522DFFu)
-
-/**
- * Silver - A light gray-silver color (#C0C0C0).
- */
-val HEXAColor.Companion.silver
-    get() = HEXAColor(0xC0C0C0FFu)
-
-/**
- * Sky Blue - A light sky blue color (#87CEEB).
- */
-val HEXAColor.Companion.skyblue
-    get() = HEXAColor(0x87CEEBFFu)
-
-/**
- * Slate Blue - A medium slate blue color (#6A5ACD).
- */
-val HEXAColor.Companion.slateblue
-    get() = HEXAColor(0x6A5ACDFFu)
-
-/**
- * Slate Gray - A slate gray color (#708090).
- */
-val HEXAColor.Companion.slategray
-    get() = HEXAColor(0x708090FFu)
-
-/**
- * Slate Grey - A slate gray color (#708090).
- */
-val HEXAColor.Companion.slategrey
-    get() = HEXAColor(0x708090FFu)
-
-/**
- * Snow - A very pale pinkish-white color (#FFFAFA).
- */
-val HEXAColor.Companion.snow
-    get() = HEXAColor(0xFFFAFAFFu)
-
-/**
- * Spring Green - A bright spring green color (#00FF7F).
- */
-val HEXAColor.Companion.springgreen
-    get() = HEXAColor(0x00FF7FFFu)
-
-/**
- * Steel Blue - A medium steel blue color (#4682B4).
- */
-val HEXAColor.Companion.steelblue
-    get() = HEXAColor(0x4682B4FFu)
-
-/**
- * Tan - A light brown tan color (#D2B48C).
- */
-val HEXAColor.Companion.tan
-    get() = HEXAColor(0xD2B48CFFu)
-
-/**
- * Teal - A dark cyan-blue color (#008080).
- */
-val HEXAColor.Companion.teal
-    get() = HEXAColor(0x008080FFu)
-
-/**
- * Thistle - A light purple-pink color (#D8BFD8).
- */
-val HEXAColor.Companion.thistle
-    get() = HEXAColor(0xD8BFD8FFu)
-
-/**
- * Tomato - A vibrant red-orange color (#FF6347).
- */
-val HEXAColor.Companion.tomato
-    get() = HEXAColor(0xFF6347FFu)
-
-/**
- * Turquoise - A medium turquoise color (#40E0D0).
- */
-val HEXAColor.Companion.turquoise
-    get() = HEXAColor(0x40E0D0FFu)
-
-/**
- * Violet - A violet color (#EE82EE).
- */
-val HEXAColor.Companion.violet
-    get() = HEXAColor(0xEE82EEFFu)
-
-/**
- * Wheat - A light tan color (#F5DEB3).
- */
-val HEXAColor.Companion.wheat
-    get() = HEXAColor(0xF5DEB3FFu)
-
-/**
- * White - Pure white color (#FFFFFF).
- */
-val HEXAColor.Companion.white
-    get() = HEXAColor(0xFFFFFFFFu)
-
-/**
- * White Smoke - A very light gray color (#F5F5F5).
- */
-val HEXAColor.Companion.whitesmoke
-    get() = HEXAColor(0xF5F5F5FFu)
-
-/**
- * Yellow - Pure yellow color (#FFFF00).
- */
-val HEXAColor.Companion.yellow
-    get() = HEXAColor(0xFFFF00FFu)
-
-/**
- * Yellow Green - A medium yellow-green color (#9ACD32).
- */
-val HEXAColor.Companion.yellowgreen
-    get() = HEXAColor(0x9ACD32FFu)

common/build.gradle

@@ -1,40 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.multiplatform"
-    id "org.jetbrains.kotlin.plugin.serialization"
-    id "com.android.kotlin.multiplatform.library"
-}
-
-apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
-
-kotlin {
-    sourceSets {
-        commonMain {
-            dependencies {
-                api libs.klock
-            }
-        }
-        jvmAndAndroidMain {
-            dependencies {
-                api project(":micro_utils.coroutines")
-            }
-        }
-        androidMain {
-            dependencies {
-                api libs.android.fragment
-            }
-        }
-
-        nativeMain {
-            dependencies {
-                api libs.okio
-            }
-        }
-
-        wasmJsMain {
-            dependencies {
-                api libs.kotlinx.browser
-                api libs.kt.coroutines
-            }
-        }
-    }
-}

common/compose/build.gradle

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

common/compose/src/androidMain/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest/>

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

@@ -1,74 +0,0 @@
-package dev.inmo.micro_utils.common.compose
-
-import androidx.compose.runtime.*
-import dev.inmo.micro_utils.common.Optional
-import dev.inmo.micro_utils.common.dataOrThrow
-import dev.inmo.micro_utils.common.optional
-
-class LoadableComponentContext<T> internal constructor(
-    presetOptional: Optional<T>,
-) {
-    internal val iterationState: MutableState<Int> = mutableStateOf(0)
-
-    internal var dataOptional: Optional<T> = if (presetOptional.dataPresented) presetOptional else Optional.absent()
-        private set
-    internal val dataState: MutableState<Optional<T>> = mutableStateOf(dataOptional)
-
-    fun reload() {
-        iterationState.value++
-    }
-}
-
-/**
- * Showing data with ability to reload data
- *
- * [block] will be shown when [loader] will complete loading. If you want to reload data, just call
- * [LoadableComponentContext.reload]
- */
-@Composable
-fun <T> LoadableComponent(
-    preload: Optional<T>,
-    loader: suspend LoadableComponentContext<T>.() -> T,
-    block: @Composable LoadableComponentContext<T>.(T) -> Unit
-) {
-    val context = remember { LoadableComponentContext(preload) }
-
-    LaunchedEffect(context.iterationState.value) {
-        context.dataState.value = loader(context).optional
-    }
-
-    context.dataState.let {
-        if (it.value.dataPresented) {
-            context.block(it.value.dataOrThrow(IllegalStateException("Data must be presented, but optional has been changed by some way")))
-        }
-    }
-}
-
-/**
- * Showing data with ability to reload data
- *
- * [block] will be shown when [loader] will complete loading. If you want to reload data, just call
- * [LoadableComponentContext.reload]
- */
-@Composable
-fun <T> LoadableComponent(
-    preload: T,
-    loader: suspend LoadableComponentContext<T>.() -> T,
-    block: @Composable LoadableComponentContext<T>.(T) -> Unit
-) {
-    LoadableComponent(preload.optional, loader, block)
-}
-
-/**
- * Showing data with ability to reload data
- *
- * [block] will be shown when [loader] will complete loading. If you want to reload data, just call
- * [LoadableComponentContext.reload]
- */
-@Composable
-fun <T> LoadableComponent(
-    loader: suspend LoadableComponentContext<T>.() -> T,
-    block: @Composable LoadableComponentContext<T>.(T) -> Unit
-) {
-    LoadableComponent(Optional.absent(), loader, block)
-}

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

@@ -1,19 +0,0 @@
-package dev.inmo.micro_utils.common.compose
-
-import org.jetbrains.compose.web.dom.AttrBuilderContext
-import org.w3c.dom.Element
-
-operator fun <T : Element> AttrBuilderContext<T>?.plus(
-    other: AttrBuilderContext<T>?
-) = when (this) {
-    null -> other ?: {}
-    else -> when (other) {
-        null -> this ?: {}
-        else -> {
-            {
-                invoke(this)
-                other(this)
-            }
-        }
-    }
-}

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

@@ -1,22 +0,0 @@
-package dev.inmo.micro_utils.common.compose
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.DisposableEffectResult
-import androidx.compose.runtime.DisposableEffectScope
-import org.jetbrains.compose.web.attributes.AttrsScope
-import org.jetbrains.compose.web.dom.ElementScope
-import org.w3c.dom.Element
-
-/**
- * This function must be called in the context of your tag content. It works like default [AttrsScope.ref],
- * but able to be used several times. Uses [DisposableEffect] under the hood
- */
-@Composable
-fun <T : Element> ElementScope<T>.ref(
-    block: DisposableEffectScope.(T) -> DisposableEffectResult
-) {
-    DisposableEffect(0) {
-        block(scopeElement)
-    }
-}

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

@@ -1,11 +0,0 @@
-package dev.inmo.micro_utils.common.compose
-
-import org.jetbrains.compose.web.dom.AttrBuilderContext
-
-fun tagClasses(vararg classnames: String): AttrBuilderContext<*> = {
-    classes(*classnames)
-}
-
-fun tagId(id: String): AttrBuilderContext<*> = {
-    id(id)
-}

common/compose/src/jvmTest/kotlin/LoadableComponentTests.kt

@@ -1,40 +0,0 @@
-import androidx.compose.runtime.remember
-import androidx.compose.ui.test.ExperimentalTestApi
-import androidx.compose.ui.test.runComposeUiTest
-import dev.inmo.micro_utils.common.compose.LoadableComponent
-import dev.inmo.micro_utils.coroutines.MutableRedeliverStateFlow
-import kotlinx.coroutines.flow.filter
-import kotlinx.coroutines.flow.first
-import org.jetbrains.annotations.TestOnly
-import kotlin.test.Test
-import kotlin.test.assertTrue
-
-class LoadableComponentTests {
-    @OptIn(ExperimentalTestApi::class)
-    @Test
-    @TestOnly
-    fun testSimpleLoad() = runComposeUiTest {
-        val loadingFlow = MutableRedeliverStateFlow<Int>(0)
-        val loadedFlow = MutableRedeliverStateFlow<Int>(0)
-        setContent {
-            LoadableComponent<Int>({
-                loadingFlow.filter { it == 1 }.first()
-            }) {
-                assert(dataState.value.data == 1)
-                remember {
-                    loadedFlow.value = 2
-                }
-            }
-        }
-
-        waitForIdle()
-
-        assertTrue(loadedFlow.value == 0)
-
-        loadingFlow.value = 1
-
-        waitForIdle()
-
-        assertTrue(loadedFlow.value == 2)
-    }
-}

common/src/androidMain/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/androidMain/kotlin/dev/inmo/micro_utils/common/Dimensions.kt

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

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

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

common/src/androidMain/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/androidMain/kotlin/dev/inmo/micro_utils/common/Mapping.kt

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

common/src/androidMain/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/androidMain/kotlin/dev/inmo/micro_utils/common/ViewDisable.kt

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

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

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

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

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

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

@@ -1,23 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Breaks this list into a list of consecutive pairs.
- * Each element is paired with the next element in the list.
- * For a list of size n, the result will contain n-1 pairs.
- *
- * Example: `[1, 2, 3, 4].breakAsPairs()` returns `[(1, 2), (2, 3), (3, 4)]`
- *
- * @param T The type of elements in the list
- * @return A list of pairs where each pair consists of consecutive elements
- */
-fun <T> List<T>.breakAsPairs(): List<Pair<T, T>> {
-    val result = mutableListOf<Pair<T, T>>()
-
-    for (i in 0 until size - 1) {
-        val first = get(i)
-        val second = get(i + 1)
-        result.add(first to second)
-    }
-
-    return result
-}

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

@@ -1,6 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Creates simple [Comparator] which will use [compareTo] of [T] for both objects
- */
-fun <T : Comparable<C>, C : T> T.createComparator() = Comparator<C> { o1, o2 -> o1.compareTo(o2) }

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

@@ -1,25 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import korlibs.time.DateTime
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.Serializer
-import kotlinx.serialization.builtins.serializer
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-
-/**
- * Serializes [DateTime] as its raw [DateTime.unixMillis] and deserializes in the same way
- */
-object DateTimeSerializer : KSerializer<DateTime> {
-    override val descriptor: SerialDescriptor
-        get() = Double.serializer().descriptor
-
-    override fun deserialize(decoder: Decoder): DateTime {
-        return DateTime(decoder.decodeDouble())
-    }
-
-    override fun serialize(encoder: Encoder, value: DateTime) {
-        encoder.encodeDouble(value.unixMillis)
-    }
-}

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

@@ -1,253 +0,0 @@
-@file:Suppress("NOTHING_TO_INLINE")
-
-package dev.inmo.micro_utils.common
-
-import kotlinx.serialization.Serializable
-
-private inline fun <T> getObject(
-    additional: MutableList<T>,
-    iterator: Iterator<T>
-): T? = when {
-    additional.isNotEmpty() -> additional.removeAt(0)
-    iterator.hasNext() -> iterator.next()
-    else -> null
-}
-
-/**
- * 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> @Warning(warning) constructor(
-    val removed: List<@Serializable(IndexedValueSerializer::class) 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()
-
-    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 <T> emptyDiff(): Diff<T> = Diff(emptyList(), emptyList(), emptyList())
-
-private inline fun <T> performChanges(
-    potentialChanges: MutableList<Pair<IndexedValue<T>?, IndexedValue<T>?>>,
-    additionsInOld: MutableList<T>,
-    additionsInNew: MutableList<T>,
-    changedList: MutableList<Pair<IndexedValue<T>, IndexedValue<T>>>,
-    removedList: MutableList<IndexedValue<T>>,
-    addedList: MutableList<IndexedValue<T>>,
-    comparisonFun: (T?, T?) -> 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)
-        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
-                }
-            )
-            val newPotentials = potentialChanges.drop(i).take(potentialChanges.size - i)
-            when {
-                oldOneEqualToNewObject -> {
-                    newPotentials.first().second ?.let { addedList.add(it) }
-                    newPotentials.drop(1).take(newPotentials.size - 2).forEach { (oldOne, newOne) ->
-                        addedList.add(newOne!!)
-                        oldOne ?.let { additionsInOld.add(oldOne.value) }
-                    }
-                    if (newPotentials.size > 1) {
-                        newPotentials.last().first ?.value ?.let { additionsInOld.add(it) }
-                    }
-                }
-                newOneEqualToOldObject -> {
-                    newPotentials.first().first ?.let { removedList.add(it) }
-                    newPotentials.drop(1).take(newPotentials.size - 2).forEach { (oldOne, newOne) ->
-                        removedList.add(oldOne!!)
-                        newOne ?.let { additionsInNew.add(newOne.value) }
-                    }
-                    if (newPotentials.size > 1) {
-                        newPotentials.last().second ?.value ?.let { additionsInNew.add(it) }
-                    }
-                }
-            }
-            potentialChanges.clear()
-            return
-        }
-    }
-    if (potentialChanges.isNotEmpty() && potentialChanges.last().let { it.first == null && it.second == null }) {
-        potentialChanges.dropLast(1).forEach { (old, new) ->
-            when {
-                old != null && new != null -> changedList.add(old to new)
-                old != null -> removedList.add(old)
-                new != null -> addedList.add(new)
-            }
-        }
-    }
-}
-
-/**
- * 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>,
-    comparisonFun: (T?, T?) -> Boolean
-): Diff<T> {
-    var i = -1
-    var j = -1
-
-    val additionalInOld = mutableListOf<T>()
-    val additionalInNew = mutableListOf<T>()
-
-    val oldIterator = iterator()
-    val newIterator = other.iterator()
-
-    val potentiallyChangedObjects = mutableListOf<Pair<IndexedValue<T>?, IndexedValue<T>?>>()
-    val changedObjects = mutableListOf<Pair<IndexedValue<T>, IndexedValue<T>>>()
-    val addedObjects = mutableListOf<IndexedValue<T>>()
-    val removedObjects = mutableListOf<IndexedValue<T>>()
-
-    while (true) {
-        i++
-        j++
-
-        val oldObject = getObject(additionalInOld, oldIterator)
-        val newObject = getObject(additionalInNew, newIterator)
-
-        if (oldObject == null && newObject == null) {
-            break
-        }
-
-        when {
-            comparisonFun(oldObject, newObject) -> {
-                changedObjects.addAll(potentiallyChangedObjects.map {
-                    @Suppress("UNCHECKED_CAST")
-                    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)
-                i -= (additionalInOld.size - previousOldsAdditionsSize)
-                j -= (additionalInNew.size - previousNewsAdditionsSize)
-            }
-        }
-    }
-    potentiallyChangedObjects.add(null to null)
-    performChanges(potentiallyChangedObjects, additionalInOld, additionalInNew, changedObjects, removedObjects, addedObjects, comparisonFun)
-
-    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> StrictDiff(old: Iterable<T>, new: Iterable<T>) = old.calculateDiff(new, true)
-
-/**
- * This method call [calculateDiff] with strict mode enabled
- */
-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,160 +0,0 @@
-@file:Suppress("unused", "NOTHING_TO_INLINE")
-
-package dev.inmo.micro_utils.common
-
-import kotlinx.serialization.*
-import kotlinx.serialization.builtins.serializer
-import kotlinx.serialization.descriptors.*
-import kotlinx.serialization.encoding.*
-
-/**
- * Realization of this interface will contains at least one not null - [optionalT1] or [optionalT2]
- *
- * @see EitherFirst
- * @see EitherSecond
- * @see Either.Companion.first
- * @see Either.Companion.second
- * @see Either.onFirst
- * @see Either.onSecond
- * @see Either.mapOnFirst
- * @see Either.mapOnSecond
- */
-@Serializable(EitherSerializer::class)
-sealed interface Either<T1, T2> {
-    val optionalT1: Optional<T1>
-    val optionalT2: Optional<T2>
-
-    val t1OrNull: T1?
-        get() = optionalT1.dataOrNull()
-    val t2OrNull: T2?
-        get() = optionalT2.dataOrNull()
-}
-
-class EitherSerializer<T1, T2>(
-    t1Serializer: KSerializer<T1>,
-    t2Serializer: KSerializer<T2>,
-) : KSerializer<Either<T1, T2>> {
-    @OptIn(InternalSerializationApi::class, ExperimentalSerializationApi::class)
-    override val descriptor: SerialDescriptor = buildSerialDescriptor(
-        "TypedSerializer",
-        SerialKind.CONTEXTUAL
-    ) {
-        element("type", String.serializer().descriptor)
-        element("value", ContextualSerializer(Either::class).descriptor)
-    }
-    private val t1EitherSerializer = EitherFirst.serializer(t1Serializer, t2Serializer)
-    private val t2EitherSerializer = EitherSecond.serializer(t1Serializer, t2Serializer)
-
-    override fun deserialize(decoder: Decoder): Either<T1, T2> {
-        return decoder.decodeStructure(descriptor) {
-            var type: String? = null
-            lateinit var result: Either<T1, T2>
-            while (true) {
-                when (val index = decodeElementIndex(descriptor)) {
-                    0 -> type = decodeStringElement(descriptor, 0)
-                    1 -> {
-                        result = when (type) {
-                            "t1" -> decodeSerializableElement(
-                                descriptor,
-                                1,
-                                t1EitherSerializer
-                            )
-                            "t2" -> decodeSerializableElement(
-                                descriptor,
-                                1,
-                                t2EitherSerializer
-                            )
-                            else -> error("Unknown type of either: $type")
-                        }
-                    }
-                    CompositeDecoder.DECODE_DONE -> break
-                    else -> error("Unexpected index: $index")
-                }
-            }
-            result
-        }
-    }
-
-
-    override fun serialize(encoder: Encoder, value: Either<T1, T2>) {
-        encoder.encodeStructure(descriptor) {
-            when (value) {
-                is EitherFirst -> {
-                    encodeStringElement(descriptor, 0, "t1")
-                    encodeSerializableElement(descriptor, 1, t1EitherSerializer, value)
-                }
-                is EitherSecond -> {
-                    encodeStringElement(descriptor, 0, "t2")
-                    encodeSerializableElement(descriptor, 1, t2EitherSerializer, value)
-                }
-            }
-        }
-    }
-}
-
-/**
- * This type [Either] will always have not nullable [optionalT1]
- */
-@Serializable
-data class EitherFirst<T1, T2>(
-    val t1: T1
-) : Either<T1, T2> {
-    override val optionalT1: Optional<T1> = t1.optional
-    override val optionalT2: Optional<T2> = Optional.absent()
-}
-
-/**
- * This type [Either] will always have not nullable [optionalT2]
- */
-@Serializable
-data class EitherSecond<T1, T2>(
-    val t2: T2
-) : Either<T1, T2> {
-    override val optionalT1: Optional<T1> = Optional.absent()
-    override val optionalT2: Optional<T2> = t2.optional
-}
-
-/**
- * @return New instance of [EitherFirst]
- */
-inline fun <T1, T2> Either.Companion.first(t1: T1): Either<T1, T2> = EitherFirst(t1)
-/**
- * @return New instance of [EitherSecond]
- */
-inline fun <T1, T2> Either.Companion.second(t2: T2): Either<T1, T2> = EitherSecond(t2)
-
-/**
- * Will call [block] in case when [this] is [EitherFirst]
- */
-inline fun <T1, T2, E : Either<T1, T2>> E.onFirst(block: (T1) -> Unit): E {
-    optionalT1.onPresented(block)
-    return this
-}
-
-/**
- * Will call [block] in case when [this] is [EitherSecond]
- */
-inline fun <T1, T2, E : Either<T1, T2>> E.onSecond(block: (T2) -> Unit): E {
-    optionalT2.onPresented(block)
-    return this
-}
-
-/**
- * @return Result of [block] if [this] is [EitherFirst]
- */
-inline fun <T1, R> Either<T1, *>.mapOnFirst(block: (T1) -> R): R? {
-    return optionalT1.mapOnPresented(block)
-}
-
-/**
- * @return Result of [block] if [this] is [EitherSecond]
- */
-inline fun <T2, R> Either<*, T2>.mapOnSecond(block: (T2) -> R): R? {
-    return optionalT2.mapOnPresented(block)
-}
-
-inline fun <reified T1, reified T2> Any.either() = when (this) {
-    is T1 -> Either.first<T1, T2>(this)
-    is T2 -> Either.second<T1, T2>(this)
-    else -> error("Incorrect type of either argument $this")
-}

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

@@ -1,85 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Executes the given [block] and returns its result if this Boolean is true, otherwise returns null.
- *
- * @param T The return type of the block
- * @param block The function to execute if this Boolean is true
- * @return The result of [block] if true, null otherwise
- */
-inline fun <T> Boolean.letIfTrue(block: () -> T): T? {
-    return if (this) {
-        block()
-    } else {
-        null
-    }
-}
-
-/**
- * Executes the given [block] and returns its result if this Boolean is false, otherwise returns null.
- *
- * @param T The return type of the block
- * @param block The function to execute if this Boolean is false
- * @return The result of [block] if false, null otherwise
- */
-inline fun <T> Boolean.letIfFalse(block: () -> T): T? {
-    return if (this) {
-        null
-    } else {
-        block()
-    }
-}
-
-/**
- * Executes the given [block] if this Boolean is true and returns this Boolean.
- * Similar to [also], but only executes the block when the Boolean is true.
- *
- * @param block The function to execute if this Boolean is true
- * @return This Boolean value
- */
-inline fun Boolean.alsoIfTrue(block: () -> Unit): Boolean {
-    letIfTrue(block)
-    return this
-}
-
-/**
- * Executes the given [block] if this Boolean is false and returns this Boolean.
- * Similar to [also], but only executes the block when the Boolean is false.
- *
- * @param block The function to execute if this Boolean is false
- * @return This Boolean value
- */
-inline fun Boolean.alsoIfFalse(block: () -> Unit): Boolean {
-    letIfFalse(block)
-    return this
-}
-
-/**
- * Alias for [letIfTrue]. Executes the given [block] and returns its result if this Boolean is true.
- *
- * @param T The return type of the block
- * @param block The function to execute if this Boolean is true
- * @return The result of [block] if true, null otherwise
- */
-inline fun <T> Boolean.ifTrue(block: () -> T): T? {
-    return if (this) {
-        block()
-    } else {
-        null
-    }
-}
-
-/**
- * Alias for [letIfFalse]. Executes the given [block] and returns its result if this Boolean is false.
- *
- * @param T The return type of the block
- * @param block The function to execute if this Boolean is false
- * @return The result of [block] if false, null otherwise
- */
-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/InputAllocator.kt

@@ -1,61 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.ByteArraySerializer
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-
-/**
- * A function type that allocates and returns a [ByteArray].
- */
-typealias ByteArrayAllocator = () -> ByteArray
-
-/**
- * A suspending function type that allocates and returns a [ByteArray].
- */
-typealias SuspendByteArrayAllocator = suspend () -> ByteArray
-
-/**
- * Converts this [ByteArray] to a [ByteArrayAllocator] that returns this array.
- */
-val ByteArray.asAllocator: ByteArrayAllocator
-    get() = { this }
-
-/**
- * Converts this [ByteArray] to a [SuspendByteArrayAllocator] that returns this array.
- */
-val ByteArray.asSuspendAllocator: SuspendByteArrayAllocator
-    get() = { this }
-
-/**
- * Converts this [ByteArrayAllocator] to a [SuspendByteArrayAllocator].
- */
-val ByteArrayAllocator.asSuspendAllocator: SuspendByteArrayAllocator
-    get() = { this() }
-
-/**
- * Converts this [SuspendByteArrayAllocator] to a [ByteArrayAllocator] by invoking it and
- * wrapping the result in a non-suspending allocator.
- */
-suspend fun SuspendByteArrayAllocator.asAllocator(): ByteArrayAllocator {
-    return invoke().asAllocator
-}
-
-/**
- * Serializer for [ByteArrayAllocator]. Serializes the result of invoking the allocator.
- */
-object ByteArrayAllocatorSerializer : KSerializer<ByteArrayAllocator> {
-    private val realSerializer = ByteArraySerializer()
-    override val descriptor: SerialDescriptor = realSerializer.descriptor
-
-    override fun deserialize(decoder: Decoder): ByteArrayAllocator {
-        val bytes = realSerializer.deserialize(decoder)
-        return bytes.asAllocator
-    }
-
-    override fun serialize(encoder: Encoder, value: ByteArrayAllocator) {
-        realSerializer.serialize(encoder, value())
-    }
-}
-

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

@@ -1,10 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Returns the first non-null element in this iterable.
- *
- * @param T The type of elements in the iterable (nullable)
- * @return The first non-null element
- * @throws NoSuchElementException if the iterable contains no non-null elements
- */
-fun <T> Iterable<T?>.firstNotNull() = first { it != null }!!

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

@@ -1,138 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Joins elements of this iterable into a list with separators between elements.
- * Each element is transformed using [transform], and separators are generated using [separatorFun].
- * Optional [prefix] and [postfix] can be added to the result.
- * Null values from transformations or separator function are skipped.
- *
- * @param I The type of elements in the input iterable
- * @param R The type of elements in the result list
- * @param separatorFun A function that generates a separator based on the current element
- * @param prefix Optional prefix to add at the beginning of the result
- * @param postfix Optional postfix to add at the end of the result
- * @param transform A function to transform each element
- * @return A list of transformed elements with separators
- */
-inline fun <I, R> Iterable<I>.joinTo(
-    separatorFun: (I) -> R?,
-    prefix: R? = null,
-    postfix: R? = null,
-    transform: (I) -> R?
-): List<R> {
-    val result = mutableListOf<R>()
-    val iterator = iterator()
-
-    prefix ?.let(result::add)
-
-    while (iterator.hasNext()) {
-        val element = iterator.next()
-        result.add(transform(element) ?: continue)
-
-        if (iterator.hasNext()) {
-            result.add(separatorFun(element) ?: continue)
-        }
-    }
-
-    postfix ?.let(result::add)
-
-    return result
-}
-
-/**
- * Joins elements of this iterable into a list with a constant separator between elements.
- * Each element is transformed using [transform].
- * Optional [prefix] and [postfix] can be added to the result.
- * Null values from transformations or separators are skipped.
- *
- * @param I The type of elements in the input iterable
- * @param R The type of elements in the result list
- * @param separator The separator to insert between elements
- * @param prefix Optional prefix to add at the beginning of the result
- * @param postfix Optional postfix to add at the end of the result
- * @param transform A function to transform each element
- * @return A list of transformed elements with separators
- */
-inline fun <I, R> Iterable<I>.joinTo(
-    separator: R? = null,
-    prefix: R? = null,
-    postfix: R? = null,
-    transform: (I) -> R?
-): List<R> = joinTo({ separator }, prefix, postfix, transform)
-
-/**
- * Joins elements of this iterable into a list with separators between elements.
- * Separators are generated using [separatorFun].
- * Optional [prefix] and [postfix] can be added to the result.
- * Null values from separator function are skipped.
- *
- * @param I The type of elements
- * @param separatorFun A function that generates a separator based on the current element
- * @param prefix Optional prefix to add at the beginning of the result
- * @param postfix Optional postfix to add at the end of the result
- * @return A list of elements with separators
- */
-inline fun <I> Iterable<I>.joinTo(
-    separatorFun: (I) -> I?,
-    prefix: I? = null,
-    postfix: I? = null
-): List<I> = joinTo<I, I>(separatorFun, prefix, postfix) { it }
-
-/**
- * Joins elements of this iterable into a list with a constant separator between elements.
- * Optional [prefix] and [postfix] can be added to the result.
- * Null separators are skipped.
- *
- * @param I The type of elements
- * @param separator The separator to insert between elements
- * @param prefix Optional prefix to add at the beginning of the result
- * @param postfix Optional postfix to add at the end of the result
- * @return A list of elements with separators
- */
-inline fun <I> Iterable<I>.joinTo(
-    separator: I? = null,
-    prefix: I? = null,
-    postfix: I? = null
-): List<I> = joinTo<I>({ separator }, prefix, postfix)
-
-/**
- * Joins elements of this array into an array with separators between elements.
- * Each element is transformed using [transform], and separators are generated using [separatorFun].
- * Optional [prefix] and [postfix] can be added to the result.
- * Null values from transformations or separator function are skipped.
- *
- * @param I The type of elements in the input array
- * @param R The type of elements in the result array
- * @param separatorFun A function that generates a separator based on the current element
- * @param prefix Optional prefix to add at the beginning of the result
- * @param postfix Optional postfix to add at the end of the result
- * @param transform A function to transform each element
- * @return An array of transformed elements with separators
- */
-inline fun <I, reified R> Array<I>.joinTo(
-    separatorFun: (I) -> R?,
-    prefix: R? = null,
-    postfix: R? = null,
-    transform: (I) -> R?
-): Array<R> = asIterable().joinTo(separatorFun, prefix, postfix, transform).toTypedArray()
-
-/**
- * Joins elements of this array into an array with a constant separator between elements.
- * Each element is transformed using [transform].
- * Optional [prefix] and [postfix] can be added to the result.
- * Null values from transformations or separators are skipped.
- *
- * @param I The type of elements in the input array
- * @param R The type of elements in the result array
- * @param separator The separator to insert between elements
- * @param prefix Optional prefix to add at the beginning of the result
- * @param postfix Optional postfix to add at the end of the result
- * @param transform A function to transform each element
- * @return An array of transformed elements with separators
- */
-inline fun <I, reified R> Array<I>.joinTo(
-    separator: R? = null,
-    prefix: R? = null,
-    postfix: R? = null,
-    transform: (I) -> R?
-): Array<R> = asIterable().joinTo(separator, prefix, postfix, transform).toTypedArray()

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

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

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

@@ -1,133 +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 {
-        keys.removeAll(removed.keys)
-        changed.forEach { (k, oldNew) ->
-            put(k, oldNew.second)
-        }
-        putAll(added)
-    }
-}
-
-/**
- * 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,125 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlin.jvm.JvmName
-
-/**
- * A bidirectional mapper that can convert between two types [T1] and [T2].
- *
- * @param T1 The first type
- * @param T2 The second type
- */
-interface SimpleMapper<T1, T2> {
-    fun convertToT1(from: T2): T1
-    fun convertToT2(from: T1): T2
-}
-
-/**
- * Converts [from] of type [T2] to type [T1] using this mapper.
- *
- * @param from The value to convert
- * @return The converted value of type [T1]
- */
-@JvmName("convertFromT2")
-fun <T1, T2> SimpleMapper<T1, T2>.convert(from: T2) = convertToT1(from)
-
-/**
- * Converts [from] of type [T1] to type [T2] using this mapper.
- *
- * @param from The value to convert
- * @return The converted value of type [T2]
- */
-@JvmName("convertFromT1")
-fun <T1, T2> SimpleMapper<T1, T2>.convert(from: T1) = convertToT2(from)
-
-/**
- * Implementation of [SimpleMapper] that uses lambda functions for conversion.
- *
- * @param T1 The first type
- * @param T2 The second type
- * @param t1 Function to convert from [T2] to [T1]
- * @param t2 Function to convert from [T1] to [T2]
- */
-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)
-}
-
-/**
- * Creates a [SimpleMapper] using the provided conversion functions.
- *
- * @param T1 The first type
- * @param T2 The second type
- * @param t1 Function to convert from [T2] to [T1]
- * @param t2 Function to convert from [T1] to [T2]
- * @return A new [SimpleMapperImpl] instance
- */
-@Suppress("NOTHING_TO_INLINE")
-inline fun <T1, T2> simpleMapper(
-    noinline t1: (T2) -> T1,
-    noinline t2: (T1) -> T2,
-) = SimpleMapperImpl(t1, t2)
-
-/**
- * A bidirectional mapper that can convert between two types [T1] and [T2] using suspending functions.
- *
- * @param T1 The first type
- * @param T2 The second type
- */
-interface SimpleSuspendableMapper<T1, T2> {
-    suspend fun convertToT1(from: T2): T1
-    suspend fun convertToT2(from: T1): T2
-}
-
-/**
- * Converts [from] of type [T2] to type [T1] using this suspending mapper.
- *
- * @param from The value to convert
- * @return The converted value of type [T1]
- */
-@JvmName("convertFromT2")
-suspend fun <T1, T2> SimpleSuspendableMapper<T1, T2>.convert(from: T2) = convertToT1(from)
-
-/**
- * Converts [from] of type [T1] to type [T2] using this suspending mapper.
- *
- * @param from The value to convert
- * @return The converted value of type [T2]
- */
-@JvmName("convertFromT1")
-suspend fun <T1, T2> SimpleSuspendableMapper<T1, T2>.convert(from: T1) = convertToT2(from)
-
-/**
- * Implementation of [SimpleSuspendableMapper] that uses suspending lambda functions for conversion.
- *
- * @param T1 The first type
- * @param T2 The second type
- * @param t1 Suspending function to convert from [T2] to [T1]
- * @param t2 Suspending function to convert from [T1] to [T2]
- */
-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)
-}
-
-/**
- * Creates a [SimpleSuspendableMapper] using the provided suspending conversion functions.
- *
- * @param T1 The first type
- * @param T2 The second type
- * @param t1 Suspending function to convert from [T2] to [T1]
- * @param t2 Suspending function to convert from [T1] to [T2]
- * @return A new [SimpleSuspendableMapperImpl] instance
- */
-@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

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

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

@@ -1,119 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Pads this sequence to the specified [size] using a custom [inserter] function.
- * The [inserter] is repeatedly called until the sequence reaches the desired size.
- *
- * @param T The type of elements in the sequence
- * @param size The target size of the padded sequence
- * @param inserter A function that takes the current sequence and returns a new padded sequence
- * @return A sequence padded to at least the specified size
- */
-inline fun <T> Sequence<T>.padWith(size: Int, inserter: (Sequence<T>) -> Sequence<T>): Sequence<T> {
-    var result = this
-    while (result.count() < size) {
-        result = inserter(result)
-    }
-    return result
-}
-
-/**
- * Pads this sequence at the end to the specified [size].
- * New elements are generated using [padBlock], which receives the current size as a parameter.
- *
- * @param T The type of elements in the sequence
- * @param size The target size of the padded sequence
- * @param padBlock A function that generates padding elements based on the current sequence size
- * @return A sequence padded to at least the specified size
- */
-inline fun <T> Sequence<T>.padEnd(size: Int, padBlock: (Int) -> T): Sequence<T> = padWith(size) { it + padBlock(it.count()) }
-
-/**
- * Pads this sequence at the end to the specified [size] using the given element [o].
- *
- * @param T The type of elements in the sequence
- * @param size The target size of the padded sequence
- * @param o The element to use for padding
- * @return A sequence padded to at least the specified size
- */
-inline fun <T> Sequence<T>.padEnd(size: Int, o: T) = padEnd(size) { o }
-
-/**
- * Pads this list to the specified [size] using a custom [inserter] function.
- * The [inserter] is repeatedly called until the list reaches the desired size.
- *
- * @param T The type of elements in the list
- * @param size The target size of the padded list
- * @param inserter A function that takes the current list and returns a new padded list
- * @return A list padded to at least the specified size
- */
-inline fun <T> List<T>.padWith(size: Int, inserter: (List<T>) -> List<T>): List<T> {
-    var result = this
-    while (result.size < size) {
-        result = inserter(result)
-    }
-    return result
-}
-
-/**
- * Pads this list at the end to the specified [size].
- * New elements are generated using [padBlock], which receives the current size as a parameter.
- *
- * @param T The type of elements in the list
- * @param size The target size of the padded list
- * @param padBlock A function that generates padding elements based on the current list size
- * @return A list padded to at least the specified size
- */
-inline fun <T> List<T>.padEnd(size: Int, padBlock: (Int) -> T): List<T> = asSequence().padEnd(size, padBlock).toList()
-
-/**
- * Pads this list at the end to the specified [size] using the given element [o].
- *
- * @param T The type of elements in the list
- * @param size The target size of the padded list
- * @param o The element to use for padding
- * @return A list padded to at least the specified size
- */
-inline fun <T> List<T>.padEnd(size: Int, o: T): List<T> = asSequence().padEnd(size, o).toList()
-
-/**
- * Pads this sequence at the start to the specified [size].
- * New elements are generated using [padBlock], which receives the current size as a parameter.
- *
- * @param T The type of elements in the sequence
- * @param size The target size of the padded sequence
- * @param padBlock A function that generates padding elements based on the current sequence size
- * @return A sequence padded to at least the specified size
- */
-inline fun <T> Sequence<T>.padStart(size: Int, padBlock: (Int) -> T): Sequence<T> = padWith(size) { sequenceOf(padBlock(it.count())) + it }
-
-/**
- * Pads this sequence at the start to the specified [size] using the given element [o].
- *
- * @param T The type of elements in the sequence
- * @param size The target size of the padded sequence
- * @param o The element to use for padding
- * @return A sequence padded to at least the specified size
- */
-inline fun <T> Sequence<T>.padStart(size: Int, o: T) = padStart(size) { o }
-
-/**
- * Pads this list at the start to the specified [size].
- * New elements are generated using [padBlock], which receives the current size as a parameter.
- *
- * @param T The type of elements in the list
- * @param size The target size of the padded list
- * @param padBlock A function that generates padding elements based on the current list size
- * @return A list padded to at least the specified size
- */
-inline fun <T> List<T>.padStart(size: Int, padBlock: (Int) -> T): List<T> = asSequence().padStart(size, padBlock).toList()
-
-/**
- * Pads this list at the start to the specified [size] using the given element [o].
- *
- * @param T The type of elements in the list
- * @param size The target size of the padded list
- * @param o The element to use for padding
- * @return A list padded to at least the specified size
- */
-inline fun <T> List<T>.padStart(size: Int, o: T): List<T> = asSequence().padStart(size, o).toList()

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

@@ -1,76 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.serialization.Serializable
-import kotlin.jvm.JvmInline
-
-/**
- * Contains [of1] as main value, where 100% of percentage is when of1 == 1
- *
- * @see invoke
- * @see partOfTotal
- * @see of100
- */
-@Serializable
-@JvmInline
-value class Percentage private constructor(
-    /**
-     * Value of percentage. When it equals to 1, means 100%
-     */
-    val of1: Double
-) {
-    /**
-     * Same as [of1], but float (using [Double.toFloat])
-     */
-    val of1Float
-        get() = of1.toFloat()
-
-    /**
-     * Represent this percentage as common percentage where 100% is 100%
-     */
-    val of100
-        get() = of1 * 100
-
-    /**
-     * Same as [of100], but float (using [Double.toFloat])
-     */
-    val of100Float
-        get() = of100.toFloat()
-
-    /**
-     * Same as [of100], but int (using [Double.toInt])
-     */
-    val of100Int
-        get() = of100.toInt()
-
-    companion object {
-        val rangeOfValues = 0.0 .. 1.0
-
-        val START = Percentage(rangeOfValues.start)
-        val COMPLETED = Percentage(rangeOfValues.endInclusive)
-
-        operator fun invoke(of1: Double) = Percentage(of1.coerceIn(rangeOfValues))
-        operator fun invoke(part: Number, total: Number) = Percentage(
-            part.toDouble() / total.toDouble()
-        )
-        fun of1(of1: Double) = Percentage(of1 = of1)
-        fun of100(of100: Double) = Percentage(of1 = of100 / 100)
-        fun partOfTotal(part: Number, total: Number) = Percentage(part = part, total = total)
-    }
-}
-
-typealias Progress = Percentage
-
-/**
- * Will return [this] [Progress] if [Percentage.of1] in `0 .. 1` range
- */
-fun Progress.ensureStrictOrNull(): Progress? = if (of1 in Percentage.rangeOfValues) this else null
-/**
- * Will return [this] [Progress] if [Percentage.of1] in `0 .. 1` range. Otherwise, will throw error
- * [IllegalArgumentException] due to [require] failure
- */
-fun Progress.ensureStrictOrThrow(): Progress {
-    require(of1 in Percentage.rangeOfValues) {
-        "For strict checks value of percentage must be in ${Percentage.rangeOfValues}, but actual value is $of1"
-    }
-    return this
-}

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/PercentageOperations.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 Percentage.plus(other: Percentage): Percentage = Percentage(of1 + other.of1)
-
-public operator fun Percentage.minus(other: Percentage): Percentage = Percentage(of1 - other.of1)
-
-public operator fun Percentage.plus(i: Byte): Percentage = Percentage((of1 + i).toDouble())
-
-public operator fun Percentage.minus(i: Byte): Percentage = Percentage((of1 - i).toDouble())
-
-public operator fun Percentage.times(i: Byte): Percentage = Percentage((of1 * i).toDouble())
-
-public operator fun Percentage.div(i: Byte): Percentage = Percentage((of1 / i).toDouble())
-
-public operator fun Percentage.rem(i: Byte): Percentage = Percentage((of1 % i).toDouble())
-
-public operator fun Percentage.plus(i: Short): Percentage = Percentage((of1 + i).toDouble())
-
-public operator fun Percentage.minus(i: Short): Percentage = Percentage((of1 - i).toDouble())
-
-public operator fun Percentage.times(i: Short): Percentage = Percentage((of1 * i).toDouble())
-
-public operator fun Percentage.div(i: Short): Percentage = Percentage((of1 / i).toDouble())
-
-public operator fun Percentage.rem(i: Short): Percentage = Percentage((of1 % i).toDouble())
-
-public operator fun Percentage.plus(i: Int): Percentage = Percentage((of1 + i).toDouble())
-
-public operator fun Percentage.minus(i: Int): Percentage = Percentage((of1 - i).toDouble())
-
-public operator fun Percentage.times(i: Int): Percentage = Percentage((of1 * i).toDouble())
-
-public operator fun Percentage.div(i: Int): Percentage = Percentage((of1 / i).toDouble())
-
-public operator fun Percentage.rem(i: Int): Percentage = Percentage((of1 % i).toDouble())
-
-public operator fun Percentage.plus(i: Long): Percentage = Percentage((of1 + i).toDouble())
-
-public operator fun Percentage.minus(i: Long): Percentage = Percentage((of1 - i).toDouble())
-
-public operator fun Percentage.times(i: Long): Percentage = Percentage((of1 * i).toDouble())
-
-public operator fun Percentage.div(i: Long): Percentage = Percentage((of1 / i).toDouble())
-
-public operator fun Percentage.rem(i: Long): Percentage = Percentage((of1 % i).toDouble())
-
-public operator fun Percentage.plus(i: Float): Percentage = Percentage((of1 + i).toDouble())
-
-public operator fun Percentage.minus(i: Float): Percentage = Percentage((of1 - i).toDouble())
-
-public operator fun Percentage.times(i: Float): Percentage = Percentage((of1 * i).toDouble())
-
-public operator fun Percentage.div(i: Float): Percentage = Percentage((of1 / i).toDouble())
-
-public operator fun Percentage.rem(i: Float): Percentage = Percentage((of1 % i).toDouble())
-
-public operator fun Percentage.plus(i: Double): Percentage = Percentage((of1 + i).toDouble())
-
-public operator fun Percentage.minus(i: Double): Percentage = Percentage((of1 - i).toDouble())
-
-public operator fun Percentage.times(i: Double): Percentage = Percentage((of1 * i).toDouble())
-
-public operator fun Percentage.div(i: Double): Percentage = Percentage((of1 / i).toDouble())
-
-public operator fun Percentage.rem(i: Double): Percentage = Percentage((of1 % i).toDouble())
-
-public operator fun Percentage.compareTo(other: Percentage): Int = (of1.compareTo(other.of1))

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

@@ -1,41 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Computes the intersection of this range with [other]. Returns a pair representing
- * the intersecting range, or null if the ranges don't overlap.
- *
- * @param T The type of comparable values in the range
- * @param other The other range to intersect with
- * @return A pair (start, end) representing the intersection, or null if no intersection exists
- */
-fun <T : Comparable<T>> ClosedRange<T>.intersect(other: ClosedRange<T>): Pair<T, T>? = when {
-    start == other.start && endInclusive == other.endInclusive -> start to endInclusive
-    start > other.endInclusive || other.start > endInclusive -> null
-    else -> maxOf(start, other.start) to minOf(endInclusive, other.endInclusive)
-}
-
-/**
- * Computes the intersection of this [IntRange] with [other].
- * Returns the intersecting range, or null if the ranges don't overlap.
- *
- * @param other The other range to intersect with
- * @return An [IntRange] representing the intersection, or null if no intersection exists
- */
-fun IntRange.intersect(
-    other: IntRange
-): IntRange? = (this as ClosedRange<Int>).intersect(other as ClosedRange<Int>) ?.let {
-    it.first .. it.second
-}
-
-/**
- * Computes the intersection of this [LongRange] with [other].
- * Returns the intersecting range, or null if the ranges don't overlap.
- *
- * @param other The other range to intersect with
- * @return A [LongRange] representing the intersection, or null if no intersection exists
- */
-fun LongRange.intersect(
-    other: LongRange
-): LongRange? = (this as ClosedRange<Long>).intersect(other as ClosedRange<Long>) ?.let {
-    it.first .. it.second
-}

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

@@ -1,54 +0,0 @@
-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].
- *
- * A zero-based index of current iteration is passed as a parameter to [action].
- */
-inline fun <R> repeatOnFailure(
-    times: Int,
-    onEachFailure: (Throwable) -> Unit = {},
-    action: (Int) -> R
-): Optional<R> {
-    var i = 0
-    val result = repeatOnFailure(
-        {
-            onEachFailure(it)
-            if (i < times) {
-                i++
-                true
-            } else {
-                false
-            }
-        }
-    ) {
-        action(i)
-    }
-    return if (result.isSuccess) {
-        Optional.presented(result.getOrThrow())
-    } else {
-        Optional.absent()
-    }
-}

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

@@ -1,26 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Will try to execute [action] and, if any exception will happen, execution will be retried.
- * This process will happen at most [count] times. There is no any limits on [count] value, but [action] will run at
- * least once and [retryOnFailure] will return its result if it is successful
- */
-inline fun <T> retryOnFailure(count: Int, action: () -> T): T {
-    var triesCount = 0
-    while (true) {
-        val result = runCatching {
-            action()
-        }.onFailure {
-            triesCount++
-
-            if (triesCount >= count) {
-                throw it
-            } else {
-                null
-            }
-        }
-
-        if (result.isSuccess) return result.getOrThrow()
-    }
-    error("Unreachable code: retry must throw latest exception if error happen or success value if not")
-}

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

@@ -1,24 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Returns a new list with the element at index [i] replaced by applying [block] to it.
- * All other elements remain unchanged.
- *
- * @param T The type of elements in the iterable
- * @param i The index of the element to replace
- * @param block A function that transforms the element at the given index
- * @return A new list with the replaced element
- */
-fun <T> Iterable<T>.withReplacedAt(i: Int, block: (T) -> T): List<T> = take(i) + block(elementAt(i)) + drop(i + 1)
-
-/**
- * Returns a new list with the first occurrence of element [t] replaced by applying [block] to it.
- * All other elements remain unchanged.
- *
- * @param T The type of elements in the iterable
- * @param t The element to replace
- * @param block A function that transforms the found element
- * @return A new list with the replaced element
- */
-fun <T> Iterable<T>.withReplaced(t: T, block: (T) -> T): List<T> = withReplacedAt(indexOf(t), block)
-

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

@@ -1,155 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlin.math.floor
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class DiffUtilsTests {
-    @Test
-    fun testThatSimpleRemoveWorks() {
-        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)
-                oldList.calculateDiff(oldList - removedSublist).apply {
-                    assertEquals(
-                        removedSublist.mapIndexed { j, o -> IndexedValue(i + j, o) },
-                        removed
-                    )
-                }
-            }
-        }
-    }
-
-    @Test
-    fun testThatSimpleAddWorks() {
-        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)
-                oldList.calculateDiff(mutable).apply {
-                    assertEquals(
-                        addedSublist.mapIndexed { j, o -> IndexedValue(i + j, o) },
-                        added
-                    )
-                }
-            }
-        }
-    }
-
-    @Test
-    fun testThatSimpleChangesWorks() {
-        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 changes = (
-                    if (step == 0) i until oldList.size else (i until oldList.size step step)
-                ).map { index ->
-                    IndexedValue(index, mutable[index]) to IndexedValue(index, "changed$index").also {
-                        mutable[index] = it.value
-                    }
-                }
-                oldList.calculateDiff(mutable).apply {
-                    assertEquals(
-                        changes,
-                        replaced
-                    )
-                }
-            }
-        }
-    }
-
-    @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/commonTest/kotlin/dev/inmo/micro_utils/common/PercentageTests.kt

@@ -1,29 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class PercentageTests {
-    @Test
-    fun testCompareTo() {
-        val step = 0.01
-
-        var i = Percentage.START.of1
-        while (i <= Percentage.COMPLETED.of1) {
-            val percentageI = Percentage(i)
-
-            var j = Percentage.START.of1
-            while (j <= Percentage.COMPLETED.of1) {
-                val percentageJ = Percentage(j)
-
-                assertEquals(percentageI.of1.compareTo(percentageJ.of1), percentageI.compareTo(percentageJ))
-                assertEquals(percentageI.of1 > percentageJ.of1, percentageI > percentageJ)
-                assertEquals(percentageI.of1 < percentageJ.of1, percentageI < percentageJ)
-
-                j += step
-            }
-
-            i += step
-        }
-    }
-}

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

@@ -1,21 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class WithReplacedTest {
-    @Test
-    fun testReplaced() {
-        val data = 0 until 10
-        val testData = Int.MAX_VALUE
-
-        for (i in 0 until data.last) {
-            val withReplaced = data.withReplacedAt(i) {
-                testData
-            }
-            val dataAsMutableList = data.toMutableList()
-            dataAsMutableList[i] = testData
-            assertEquals(withReplaced, dataAsMutableList.toList())
-        }
-    }
-}

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

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

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

@@ -1,13 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.window
-
-fun copyToClipboard(text: String): Boolean {
-    return runCatching {
-        window.navigator.clipboard.writeText(
-            text
-        )
-    }.onFailure {
-        it.printStackTrace()
-    }.isSuccess
-}

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

@@ -1,29 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.window
-import org.w3c.files.Blob
-import org.w3c.files.BlobPropertyBag
-import kotlin.js.json
-
-external class ClipboardItem(data: dynamic)
-
-inline fun Blob.convertToClipboardItem(): ClipboardItem {
-    val itemData: dynamic = json(this.type to this)
-    return ClipboardItem(itemData)
-}
-
-suspend fun copyImageURLToClipboard(imageUrl: String): Boolean {
-    return runCatching {
-        val response = window.fetch(imageUrl).await()
-        val blob = response.blob().await()
-        val data = arrayOf(
-            Blob(
-                arrayOf(blob),
-                BlobPropertyBag("image/png")
-            ).convertToClipboardItem()
-        ).asDynamic()
-        window.navigator.clipboard.write(data)
-    }.onFailure {
-        it.printStackTrace()
-    }.isSuccess
-}

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

@@ -1,43 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.window
-import org.w3c.dom.DOMRect
-import org.w3c.dom.Element
-
-val DOMRect.isOnScreenByLeftEdge: Boolean
-    get() = left >= 0 && left <= window.innerWidth
-inline val Element.isOnScreenByLeftEdge
-    get() = getBoundingClientRect().isOnScreenByLeftEdge
-
-val DOMRect.isOnScreenByRightEdge: Boolean
-    get() = right >= 0 && right <= window.innerWidth
-inline val Element.isOnScreenByRightEdge
-    get() = getBoundingClientRect().isOnScreenByRightEdge
-
-internal val DOMRect.isOnScreenHorizontally: Boolean
-    get() = isOnScreenByLeftEdge || isOnScreenByRightEdge
-
-
-val DOMRect.isOnScreenByTopEdge: Boolean
-    get() = top >= 0 && top <= window.innerHeight
-inline val Element.isOnScreenByTopEdge
-    get() = getBoundingClientRect().isOnScreenByTopEdge
-
-val DOMRect.isOnScreenByBottomEdge: Boolean
-    get() = bottom >= 0 && bottom <= window.innerHeight
-inline val Element.isOnScreenByBottomEdge
-    get() = getBoundingClientRect().isOnScreenByBottomEdge
-
-internal val DOMRect.isOnScreenVertically: Boolean
-    get() = isOnScreenByLeftEdge || isOnScreenByRightEdge
-
-
-val DOMRect.isOnScreenFully: Boolean
-    get() = isOnScreenByLeftEdge && isOnScreenByTopEdge && isOnScreenByRightEdge && isOnScreenByBottomEdge
-val Element.isOnScreenFully: Boolean
-    get() = getBoundingClientRect().isOnScreenFully
-
-val DOMRect.isOnScreen: Boolean
-    get() = isOnScreenFully || (isOnScreenHorizontally && isOnScreenVertically)
-inline val Element.isOnScreen: Boolean
-    get() = getBoundingClientRect().isOnScreen

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

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

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

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