update dependencies

0.20.36

.github/workflows/build.yml

@@ -8,7 +8,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 11
+          java-version: 17
       - name: Rewrite version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"

.github/workflows/dokka_push.yml

@@ -10,7 +10,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 11
+          java-version: 17
       - name: Build
         run: ./gradlew build && ./gradlew dokkaHtml
       - name: Publish KDocs

CHANGELOG.md

@@ -1,5 +1,252 @@
 # Changelog
 
+## 0.20.37
+
+* `Versions`:
+    * `Compose`: `1.5.12` -> `1.6.0`
+    * `Exposed`: `0.47.0` -> `0.48.0`
+
+## 0.20.36
+
+* `Versions`:
+    * `Serialization`: `1.6.2` -> `1.6.3`
+    * `Korlibs`: `5.3.1` -> `5.3.2`
+* `Repos`:
+    * `Cache`:
+        * Improve work and functionality of `actualizeAll` and subsequent functions
+        * All internal repos `invalidate`/`actualizeAll` now use common `actualizeAll` functions
+
+## 0.20.35
+
+* `Versions`:
+    * `Coroutines`: `1.7.3` -> `1.8.0`
+    * `Material3`: `1.1.2` -> `1.2.0`
+
+## 0.20.34
+
+* `Repos`:
+    * `Common`:
+        * Improve default `set` realization of `KeyValuesRepo`
+
+## 0.20.33
+
+* `Colors`
+    * `Common`:
+        * Add opportunity to use `HEXAColor` with `ahex` colors
+
+## 0.20.32
+
+* `Versions`:
+    * `Okio`: `3.7.0` -> `3.8.0`
+* `Resources`:
+    * Make `StringResource` serializable
+    * Add several variants of builder usages
+
+## 0.20.31
+
+* `Versions`:
+    * `Ktor`: `2.3.7` -> `2.3.8`
+
+## 0.20.30
+
+* `Versions`:
+    * `Exposed`: `0.46.0` -> `0.47.0`
+
+## 0.20.29
+
+* `Versions`:
+    * `Kotlin`: `1.9.21` -> `1.9.22`
+    * `Compose`: `1.5.11` -> `1.5.12`
+    * `Korlibs`: `5.3.0` -> `5.3.1`
+
+## 0.20.28
+
+* `Versions`:
+    * `Kotlin`: `1.9.22` -> `1.9.21` (downgrade)
+    * `Compose`: `1.6.0-dev13691` -> `1.5.11` (downgrade)
+
+## 0.20.27
+
+* `Versions`:
+    * `Kotlin`: `1.9.21` -> `1.9.22`
+    * `Compose`: `1.5.11` -> `1.6.0-dev13691`
+
+## 0.20.26
+
+* `Versions`:
+    * `Exposed`: `0.45.0` -> `0.46.0`. **This update brinds new api deprecations in exposed**
+* `Resources`:
+    * Add opportunity to get default translation by passing `null` as `IetfLang` argument
+    * Add several useful extensions to get translations in `JS` target
+
+## 0.20.25
+
+* `Colors`:
+    * `Common`:
+        * Module inited
+
+## 0.20.24
+
+**Since this version depdendencies of klock and krypto replaced with `com.soywiz.korge:korlibs-time` and `com.soywiz.korge:korlibs-crypto`**
+
+* `Versions`:
+    * `Klock` (since now `KorlibsTime`): `4.0.10` -> `5.3.0`
+    * `Krypto` (since now `KorlibsCrypto`): `4.0.10` -> `5.3.0`
+* `Serialization`:
+    * `Mapper`:
+        * `Mapper` pass decoder into callback of deserialization strategy
+        * `Mapper` pass encoder into callback of serialization strategy
+
+## 0.20.23
+
+* `Versions`:
+    * `Koin`: `3.5.0` -> `3.5.3`
+    * `Okio`: `3.6.0` -> `3.7.0`
+* `LanguageCodes`:
+    * Fixes in intermediate language codes (like `Chinese.Hans`)
+    * Rename `IetfLanguageCode` to `IetfLang`
+        * Rename all subsequent functions (including serializer)
+    * New lazy properties `knownLanguageCodesMap`, `knownLanguageCodesMapByLowerCasedKeys` and several others
+
+## 0.20.22
+
+* `Common`:
+    * Add opportunity to create own `Diff` with base constructor
+
+## 0.20.21
+
+* `Resources`:
+    * Inited
+
+## 0.20.20
+
+* `Repos`:
+    * `Exposed`:
+        * Add opportunity for setup flows in `AbstractExposedCRUDRepo`
+
+## 0.20.19
+
+* `Versions`:
+    * `Ktor`: `2.3.6` -> `2.3.7`
+
+## 0.20.18
+
+* `Coroutines`:
+    * `SpecialMutableStateFlow` now extends `MutableStateFlow`
+    * `Compose`:
+        * Deprecate `FlowState` due to its complexity in fixes
+
+## 0.20.17
+
+* `Versions`:
+    * `Serialization`: `1.6.1` -> `1.6.2`
+
+## 0.20.16
+
+* `Versions`:
+    * `Exposed`: `0.44.1` -> `0.45.0`
+* `Coroutines`:
+    * Add `SpecialMutableStateFlow`
+    * `Compose`:
+        * Add `FlowState`
+
+## 0.20.15
+
+* `Versions`:
+    * `Kotlin`: `1.9.20` -> `1.9.21`
+    * `KSLog`: `1.3.0` -> `1.3.1`
+    * `Compose`: `1.5.10` -> `1.5.11`
+
+## 0.20.14
+
+* `Versions`:
+    * `Serialization`: `1.6.0` -> `1.6.1`
+    * `KSLog`: `1.2.4` -> `1.3.0`
+
+## 0.20.13
+
+* `Versions`:
+    * `Ktor`: `2.3.5` -> `2.3.6`
+    * `UUID`: `0.8.1` -> `0.8.2`
+
+## 0.20.12
+
+**It is experimental migration onto new gradle version. Be careful in use of this version**
+
+**This update have JDK 17 in `compatibility` and `target` versions**
+
+## 0.20.11
+
+* `Versions`:
+    * `Kotlin`: `1.9.20-RC2` -> `1.9.20`
+    * `Exposed`: `0.44.0` -> `0.44.1`
+    * `Compose`: `1.5.10-rc02` -> `1.5.10`
+* `Coroutines`:
+    * `SmartRWLocker` now will wait first unlock of write mutex for acquiring read
+
+## 0.20.10
+
+* `Versions`:
+    * `Kotlin`: `1.9.20-RC` -> `1.9.20-RC1`
+    * `KSLog`: `1.2.1` -> `1.2.2`
+    * `Compose`: `1.5.10-rc01` -> `1.5.10-rc02`
+    * `RecyclerView`: `1.3.1` -> `1.3.2`
+
+## 0.20.9
+
+* Most of common modules now supports `linuxArm64` target
+
+## 0.20.8
+
+**THIS VERSION CONTAINS UPDATES OF DEPENDENCIES UP TO RC VERSIONS. USE WITH CAUTION**
+
+* `Versions`:
+    * `Kotlin`: `1.9.20-Beta2` -> `1.9.20-RC`
+    * `Compose`: `1.5.10-beta02` -> `1.5.10-rc01`
+
+## 0.20.7
+
+**THIS VERSION CONTAINS UPDATES OF DEPENDENCIES UP TO BETA VERSIONS. USE WITH CAUTION**
+
+* `Versions`:
+    * `Kotlin`: `1.9.10` -> `1.9.20-Beta2`
+    * `Compose`: `1.5.1` -> `1.5.10-beta02`
+    * `Exposed`: `0.43.0` -> `0.44.0`
+    * `Ktor`: `2.3.4` -> `2.3.5`
+    * `Koin`: `3.4.3` -> `3.5.0`
+    * `Okio`: `3.5.0` -> `3.6.0`
+    * `Android Core`: `1.10.1` -> `1.12.0`
+    * `Android Compose Material`: `1.1.1` -> `1.1.2`
+
+## 0.20.6
+
+* `Repos`:
+    * `Exposed`
+        * Fixes in exposed key-values repos
+
+## 0.20.5
+
+* `Coroutines`:
+    * Fixes in `SmartRWLocker`
+
+## 0.20.4
+
+* `Versions`:
+    * `Kotlin`: `1.9.0` -> `1.9.10`
+    * `KSLog`: `1.2.0` -> `1.2.1`
+    * `Compose`: `1.5.0` -> `1.5.1`
+    * `UUID`: `0.8.0` -> `0.8.1`
+
+## 0.20.3
+
+* `Versions`:
+    * `Compose`: `1.4.3` -> `1.5.0`
+    * `Exposed`: `0.42.1` -> `0.43.0`
+    * `Ktor`: `2.3.3` -> `2.3.4`
+* `Repos`:
+    * `Cache`:
+        * Fixes in locks of caches
+
 ## 0.20.2
 
 * All main repos uses `SmartRWLocker`

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

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

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

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

android/pickers/src/androidMain/AndroidManifest.xml

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

android/recyclerview/src/androidMain/AndroidManifest.xml

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

android/smalltextfield/src/androidMain/AndroidManifest.xml

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

build.gradle

@@ -27,7 +27,7 @@ allprojects {
         mavenCentral()
         google()
         maven { url "https://maven.pkg.jetbrains.space/public/p/compose/dev" }
-        maven { url "https://git.inmo.dev/api/packages/InsanusMokrassar/maven" }
+        maven { url "https://nexus.inmo.dev/repository/maven-releases/" }
     }
 
     // temporal crutch until legacy tests will be stabled or legacy target will be removed

colors/common/build.gradle

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

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

@@ -0,0 +1,174 @@
+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 `0xFFEEBBAA` where FF - red, EE - green, BB - blue` and AA - alpha
+ */
+@Serializable
+@JvmInline
+value class HEXAColor (
+    val hexaUInt: UInt
+) : Comparable<HEXAColor> {
+    /**
+     * @returns [hexaUInt] as a string with format `#FFEEBBAA` where FF - red, EE - green, BB - blue and AA - alpha
+     */
+    val hexa: String
+        get() = "#${hexaUInt.toString(16).padStart(8, '0')}"
+
+    /**
+     * @returns [hexaUInt] as a string with format `#FFEEBB` where FF - red, EE - green and BB - blue
+     */
+    val hex: String
+        get() = hexa.take(7)
+    /**
+     * @returns [hexaUInt] as a string with format `#AAFFEEBB` where AA - alpha, FF - red, EE - 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 `0xFFEEBBAA` where FF - red, EE - green, BB - blue` and AA - alpha
+         */
+        fun fromHexa(uint: UInt) = HEXAColor(uint)
+
+        /**
+         * Creates [HEXAColor] from [uint] presume it is in format `0xAAFFEEBB` where AA - alpha, FF - red, EE - 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

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

common/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {
@@ -31,5 +31,10 @@ kotlin {
                 api libs.okio
             }
         }
+        linuxArm64Main {
+            dependencies {
+                api libs.okio
+            }
+        }
     }
 }

common/compose/src/androidMain/AndroidManifest.xml

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

common/src/androidMain/AndroidManifest.xml

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

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

@@ -27,7 +27,7 @@ private inline fun <T> getObject(
  * @see calculateDiff
  */
 @Serializable
-data class Diff<T> internal constructor(
+data class Diff<T> @Warning(warning) constructor(
     val removed: List<@Serializable(IndexedValueSerializer::class) IndexedValue<T>>,
     /**
      * Old-New values pairs
@@ -36,6 +36,10 @@ data class Diff<T> internal constructor(
     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())

common/src/linuxArm64Main/kotlin/ActualMPPFile.kt

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

common/src/linuxArm64Main/kotlin/fixed.kt

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

coroutines/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {

coroutines/compose/src/androidMain/AndroidManifest.xml

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

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

@@ -0,0 +1,46 @@
+package dev.inmo.micro_utils.coroutines.compose
+
+import androidx.compose.runtime.MutableState
+import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+
+/**
+ * This type works like [MutableState], [kotlinx.coroutines.flow.StateFlow] and [kotlinx.coroutines.flow.MutableSharedFlow].
+ * Based on [SpecialMutableStateFlow]
+ */
+@Deprecated("Will be removed soon")
+class FlowState<T>(
+    initial: T,
+    internalScope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) : MutableState<T>,
+    SpecialMutableStateFlow<T>(initial, internalScope) {
+    private var internalValue: T = initial
+    override var value: T
+        get() = internalValue
+        set(value) {
+            internalValue = value
+            tryEmit(value)
+        }
+
+    override fun onChangeWithoutSync(value: T) {
+        internalValue = value
+        super.onChangeWithoutSync(value)
+    }
+
+    override fun component1(): T = value
+
+    override fun component2(): (T) -> Unit = { tryEmit(it) }
+
+    override fun tryEmit(value: T): Boolean {
+        internalValue = value
+        return super.tryEmit(value)
+    }
+
+    override suspend fun emit(value: T) {
+        internalValue = value
+        super.emit(value)
+    }
+}
+
+//fun <T> MutableState<T>.asFlowState(scope: CoroutineScope = CoroutineScope(Dispatchers.Main)) = FlowState(this, scope)

coroutines/src/androidMain/AndroidManifest.xml

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

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

@@ -23,9 +23,8 @@ class SmartRWLocker(private val readPermits: Int = Int.MAX_VALUE, writeIsLocked:
      * Do lock in [readSemaphore] inside of [writeMutex] locking
      */
     suspend fun acquireRead() {
-        _writeMutex.withLock {
-            _readSemaphore.acquire()
-        }
+        _writeMutex.waitUnlock()
+        _readSemaphore.acquire()
     }
 
     /**
@@ -40,14 +39,18 @@ class SmartRWLocker(private val readPermits: Int = Int.MAX_VALUE, writeIsLocked:
      */
     suspend fun lockWrite() {
         _writeMutex.lock()
-        readSemaphore.waitRelease(readPermits)
+        _readSemaphore.acquire(readPermits)
     }
 
     /**
      * Unlock [writeMutex]
      */
     suspend fun unlockWrite(): Boolean {
-        return _writeMutex.unlock()
+        return _writeMutex.unlock().also {
+            if (it) {
+                _readSemaphore.release(readPermits)
+            }
+        }
     }
 }
 

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

@@ -42,11 +42,11 @@ sealed interface SmartSemaphore {
      * Mutable variant of [SmartSemaphore]. With that variant you may [lock] and [unlock]. Besides, you may create
      * [Immutable] variant of [this] instance with [immutable] factory
      *
-     * @param locked Preset state of [freePermits] and its internal [_permitsStateFlow]
+     * @param locked Preset state of [freePermits] and its internal [_freePermitsStateFlow]
      */
     class Mutable(private val permits: Int, acquiredPermits: Int = 0) : SmartSemaphore {
-        private val _permitsStateFlow = MutableStateFlow<Int>(permits - acquiredPermits)
-        override val permitsStateFlow: StateFlow<Int> = _permitsStateFlow.asStateFlow()
+        private val _freePermitsStateFlow = MutableStateFlow<Int>(permits - acquiredPermits)
+        override val permitsStateFlow: StateFlow<Int> = _freePermitsStateFlow.asStateFlow()
 
         private val internalChangesMutex = Mutex(false)
 
@@ -54,19 +54,45 @@ sealed interface SmartSemaphore {
 
         private fun checkedPermits(permits: Int) = permits.coerceIn(1 .. this.permits)
 
+        /**
+         * Holds call until this [SmartSemaphore] will be re-locked. That means that current method will
+         */
+        suspend fun acquire(permits: Int = 1) {
+            var acquiredPermits = 0
+            val checkedPermits = checkedPermits(permits)
+            try {
+                do {
+                    val shouldContinue = internalChangesMutex.withLock {
+                        val requiredPermits = checkedPermits - acquiredPermits
+                        val acquiring = minOf(freePermits, requiredPermits).takeIf { it > 0 } ?: return@withLock true
+                        acquiredPermits += acquiring
+                        _freePermitsStateFlow.value -= acquiring
+
+                        acquiredPermits != checkedPermits
+                    }
+                    if (shouldContinue) {
+                        waitRelease()
+                    }
+                } while (shouldContinue && currentCoroutineContext().isActive)
+            } catch (e: Throwable) {
+                release(acquiredPermits)
+                throw e
+            }
+        }
+
         /**
          * Holds call until this [SmartSemaphore] will be re-locked. That means that while [freePermits] == true, [holds] will
          * wait for [freePermits] == false and then try to lock
          */
-        suspend fun acquire(permits: Int = 1) {
+        suspend fun acquireByOne(permits: Int = 1) {
+            val checkedPermits = checkedPermits(permits)
             do {
-                val checkedPermits = checkedPermits(permits)
                 waitRelease(checkedPermits)
                 val shouldContinue = internalChangesMutex.withLock {
-                    if (_permitsStateFlow.value < checkedPermits) {
+                    if (_freePermitsStateFlow.value < checkedPermits) {
                         true
                     } else {
-                        _permitsStateFlow.value -= checkedPermits
+                        _freePermitsStateFlow.value -= checkedPermits
                         false
                     }
                 }
@@ -80,10 +106,10 @@ sealed interface SmartSemaphore {
          */
         suspend fun tryAcquire(permits: Int = 1): Boolean {
             val checkedPermits = checkedPermits(permits)
-            return if (_permitsStateFlow.value < checkedPermits) {
+            return if (_freePermitsStateFlow.value < checkedPermits) {
                 internalChangesMutex.withLock {
-                    if (_permitsStateFlow.value < checkedPermits) {
-                        _permitsStateFlow.value -= checkedPermits
+                    if (_freePermitsStateFlow.value < checkedPermits) {
+                        _freePermitsStateFlow.value -= checkedPermits
                         true
                     } else {
                         false
@@ -100,10 +126,10 @@ sealed interface SmartSemaphore {
          */
         suspend fun release(permits: Int = 1): Boolean {
             val checkedPermits = checkedPermits(permits)
-            return if (_permitsStateFlow.value < this.permits) {
+            return if (_freePermitsStateFlow.value < this.permits) {
                 internalChangesMutex.withLock {
-                    if (_permitsStateFlow.value < this.permits) {
-                        _permitsStateFlow.value = minOf(_permitsStateFlow.value + checkedPermits, this.permits)
+                    if (_freePermitsStateFlow.value < this.permits) {
+                        _freePermitsStateFlow.value = minOf(_freePermitsStateFlow.value + checkedPermits, this.permits)
                         true
                     } else {
                         false

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

@@ -0,0 +1,86 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.InternalCoroutinesApi
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.internal.SynchronizedObject
+import kotlinx.coroutines.internal.synchronized
+
+/**
+ * Works like [StateFlow], but guarantee that latest value update will always be delivered to
+ * each active subscriber
+ */
+open class SpecialMutableStateFlow<T>(
+    initialValue: T,
+    internalScope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) : MutableStateFlow<T>, FlowCollector<T>, MutableSharedFlow<T> {
+    @OptIn(InternalCoroutinesApi::class)
+    private val syncObject = SynchronizedObject()
+    protected val internalSharedFlow: MutableSharedFlow<T> = MutableSharedFlow(
+        replay = 0,
+        extraBufferCapacity = 2,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST
+    )
+    protected val publicSharedFlow: MutableSharedFlow<T> = MutableSharedFlow(
+        replay = 1,
+        extraBufferCapacity = 1,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST
+    )
+
+    protected var _value: T = initialValue
+    override var value: T
+        get() = _value
+        set(value) {
+            doOnChangeAction(value)
+        }
+    protected val job = internalSharedFlow.subscribe(internalScope) {
+        doOnChangeAction(it)
+    }
+
+    override val replayCache: List<T>
+        get() = publicSharedFlow.replayCache
+    override val subscriptionCount: StateFlow<Int>
+        get() = publicSharedFlow.subscriptionCount
+
+    @OptIn(InternalCoroutinesApi::class)
+    override fun compareAndSet(expect: T, update: T): Boolean {
+        return synchronized(syncObject) {
+            if (expect == _value && update != _value) {
+                doOnChangeAction(update)
+            }
+            expect == _value
+        }
+    }
+
+    protected open fun onChangeWithoutSync(value: T) {
+        _value = value
+        publicSharedFlow.tryEmit(value)
+    }
+    @OptIn(InternalCoroutinesApi::class)
+    protected open fun doOnChangeAction(value: T) {
+        synchronized(syncObject) {
+            if (_value != value) {
+                onChangeWithoutSync(value)
+            }
+        }
+    }
+
+    @ExperimentalCoroutinesApi
+    override fun resetReplayCache() = publicSharedFlow.resetReplayCache()
+
+    override fun tryEmit(value: T): Boolean {
+        return internalSharedFlow.tryEmit(value)
+    }
+
+    override suspend fun emit(value: T) {
+        internalSharedFlow.emit(value)
+    }
+
+    override suspend fun collect(collector: FlowCollector<T>) = publicSharedFlow.collect(collector)
+}

coroutines/src/commonTest/kotlin/SmartRWLockerTests.kt

@@ -1,10 +1,6 @@
-import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.withReadAcquire
-import dev.inmo.micro_utils.coroutines.withWriteLock
-import kotlinx.coroutines.CoroutineStart
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.joinAll
-import kotlinx.coroutines.launch
+import dev.inmo.micro_utils.coroutines.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.test.runTest
@@ -57,4 +53,99 @@ class SmartRWLockerTests {
             assertEquals(expected = readAndWriteWorkers, actual = doneWrites)
         }
     }
+
+    @Test
+    fun simpleWithWriteLockTest() {
+        val locker = SmartRWLocker()
+
+        runTest {
+            locker.withWriteLock {
+                assertEquals(0, locker.readSemaphore.freePermits)
+                assertEquals(true, locker.writeMutex.isLocked)
+            }
+            assertEquals(Int.MAX_VALUE, locker.readSemaphore.freePermits)
+            assertEquals(false, locker.writeMutex.isLocked)
+        }
+    }
+
+    @Test
+    fun failureWithWriteLockTest() {
+        val locker = SmartRWLocker()
+
+        val exception = IllegalArgumentException()
+        try {
+            runTest {
+                val subscope = kotlinx.coroutines.CoroutineScope(this.coroutineContext)
+                var happenException: Throwable? = null
+                try {
+                    locker.withWriteLock {
+                        val checkFunction = fun (): Deferred<Unit> {
+                            return subscope.async {
+                                assertEquals(0, locker.readSemaphore.freePermits)
+                                assertEquals(true, locker.writeMutex.isLocked)
+                                throw exception
+                            }
+                        }
+                        doInDefault {
+                            assertEquals(0, locker.readSemaphore.freePermits)
+                            assertEquals(true, locker.writeMutex.isLocked)
+                            checkFunction().await()
+                        }
+                    }
+                } catch (e: Exception) {
+                    happenException = e
+                }
+                if (exception != happenException) {
+                    assertEquals(exception, happenException ?.cause)
+                }
+                assertEquals(Int.MAX_VALUE, locker.readSemaphore.freePermits)
+                assertEquals(false, locker.writeMutex.isLocked)
+            }
+        } catch (e: Exception) {
+            assertEquals(exception, e)
+        }
+    }
+
+    @Test
+    fun simpleWithReadAcquireTest() {
+        val locker = SmartRWLocker()
+
+        runTest {
+            locker.withReadAcquire {
+                assertEquals(Int.MAX_VALUE - 1, locker.readSemaphore.freePermits)
+                assertEquals(false, locker.writeMutex.isLocked)
+                locker.withReadAcquire {
+                    assertEquals(Int.MAX_VALUE - 2, locker.readSemaphore.freePermits)
+                    assertEquals(false, locker.writeMutex.isLocked)
+                }
+            }
+            assertEquals(Int.MAX_VALUE, locker.readSemaphore.freePermits)
+            assertEquals(false, locker.writeMutex.isLocked)
+        }
+    }
+
+    @Test
+    fun simple2WithWriteLockTest() {
+        val locker = SmartRWLocker()
+
+        val unlockDelay = 1000L // 1 sec
+        var unlocked: Boolean = false
+        runTest {
+            launch {
+                locker.withReadAcquire {
+                    delay(unlockDelay)
+                }
+                unlocked = true
+            }
+            locker.readSemaphore.permitsStateFlow.first { it == Int.MAX_VALUE - 1 }
+            assertEquals(false, unlocked)
+            locker.withWriteLock {
+                assertEquals(true, unlocked)
+                assertEquals(0, locker.readSemaphore.freePermits)
+                assertEquals(true, locker.writeMutex.isLocked)
+            }
+            assertEquals(Int.MAX_VALUE, locker.readSemaphore.freePermits)
+            assertEquals(false, locker.writeMutex.isLocked)
+        }
+    }
 }

crypto/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {

crypto/src/androidMain/AndroidManifest.xml

@@ -1 +1 @@
-<manifest package="dev.inmo.micro_utils.crypto"/>
+<manifest/>

defaultAndroidSettings.gradle

@@ -9,6 +9,7 @@ android {
         targetSdkVersion libs.versions.android.props.compileSdk.get().toInteger()
         versionCode "${android_code_version}".toInteger()
         versionName "$version"
+        namespace "${project.group}.${project.name}"
     }
     buildTypes {
         release {
@@ -26,7 +27,7 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
     }
 }

dokka/build.gradle

@@ -106,7 +106,7 @@ tasks.dokkaHtml {
             skipDeprecated.set(true)
 
             sourceLink {
-                localDirectory.set(file("./"))
+                localDirectory.set(file("../"))
                 remoteUrl.set(new URL("https://github.com/InsanusMokrassar/MicroUtils/blob/master/"))
                 remoteLineSuffix.set("#L")
             }

dokka/src/androidMain/AndroidManifest.xml

@@ -1 +1 @@
-<manifest package="dev.inmo.dokka"/>
+<manifest/>

extensions.gradle

@@ -19,11 +19,19 @@ allprojects {
         }
 
         releaseMode = (project.hasProperty('RELEASE_MODE') && project.property('RELEASE_MODE') == "true") || System.getenv('RELEASE_MODE') == "true"
+//        String compilerPluginVersionFromProperties = (String) project.properties["compose.kotlinCompilerPluginVersion"]
+//        String compilerPluginVersionFromLibrariesVersions = libs.versions.compose.kotlin.get()
+//        composePluginKotlinVersion = compilerPluginVersionFromProperties
+//        if (compilerPluginVersionFromProperties == null) {
+//            composePluginKotlinVersion = compilerPluginVersionFromLibrariesVersions
+//        }
 
-        mppProjectWithSerializationPresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerialization.gradle"
+        mppProjectWithSerializationPresetPath = "${rootProject.projectDir.absolutePath}/mppJvmJsAndroidProject.gradle"
         mppProjectWithSerializationAndComposePresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerializationAndCompose.gradle"
         mppJavaProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJavaProject.gradle"
         mppJvmJsLinuxMingwProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJvmJsLinuxMingwProject.gradle"
+        mppJvmJsLinuxMingwLinuxArm64ProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJvmJsLinuxMingwLinuxArm64Project.gradle"
+        mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJvmJsAndroidLinuxMingwLinuxArm64Project.gradle"
         mppAndroidProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppAndroidProject.gradle"
 
         defaultAndroidSettingsPresetPath = "${rootProject.projectDir.absolutePath}/defaultAndroidSettings.gradle"

fsm/common/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {

fsm/common/src/androidMain/AndroidManifest.xml

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

fsm/repos/common/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {

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

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

github_release.gradle

@@ -18,13 +18,13 @@ if (new File(projectDir, "secret.gradle").exists()) {
     githubRelease {
         token "${project.property('GITHUB_RELEASE_TOKEN')}"
 
-        owner "InsanusMokrassar"
-        repo "MicroUtils"
+        owner = "InsanusMokrassar"
+        repo = "MicroUtils"
 
-        tagName "v${project.version}"
-        releaseName "${project.version}"
-        targetCommitish "${project.version}"
+        tagName = "v${project.version}"
+        releaseName = "${project.version}"
+        targetCommitish = "${project.version}"
 
-        body getCurrentVersionChangelog()
+        body = getCurrentVersionChangelog()
     }
 }

gradle.properties

@@ -6,7 +6,7 @@ kotlin.incremental.js=true
 #kotlin.experimental.tryK2=true
 android.useAndroidX=true
 android.enableJetifier=true
-org.gradle.jvmargs=-Xmx2g
+org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=2g
 
 # JS NPM
 
@@ -15,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.20.2
-android_code_version=208
+version=0.20.37
+android_code_version=243

gradle/libs.versions.toml

@@ -1,41 +1,41 @@
 [versions]
 
-kt = "1.9.0"
-kt-serialization = "1.6.0"
-kt-coroutines = "1.7.3"
+kt = "1.9.22"
+kt-serialization = "1.6.3"
+kt-coroutines = "1.8.0"
 
-kslog = "1.2.0"
+kslog = "1.3.2"
 
-jb-compose = "1.4.3"
-jb-exposed = "0.42.1"
-jb-dokka = "1.8.20"
+jb-compose = "1.6.0"
+jb-exposed = "0.48.0"
+jb-dokka = "1.9.10"
 
-korlibs = "4.0.10"
-uuid = "0.8.0"
+korlibs = "5.3.2"
+uuid = "0.8.2"
 
-ktor = "2.3.3"
+ktor = "2.3.8"
 
-gh-release = "2.4.1"
+gh-release = "2.5.2"
 
-koin = "3.4.3"
+koin = "3.5.3"
 
-okio = "3.5.0"
+okio = "3.8.0"
 
-ksp = "1.9.0-1.0.13"
-kotlin-poet = "1.14.2"
+ksp = "1.9.22-1.0.18"
+kotlin-poet = "1.16.0"
 
-versions = "0.47.0"
+versions = "0.51.0"
 
-android-gradle = "7.4.2"
+android-gradle = "8.3.0"
 dexcount = "4.0.0"
 
-android-coreKtx = "1.10.1"
-android-recyclerView = "1.3.1"
+android-coreKtx = "1.12.0"
+android-recyclerView = "1.3.2"
 android-appCompat = "1.6.1"
-android-fragment = "1.6.1"
+android-fragment = "1.6.2"
 android-espresso = "3.5.1"
 android-test = "1.1.5"
-android-compose-material3 = "1.1.1"
+android-compose-material3 = "1.2.0"
 
 android-props-minSdk = "21"
 android-props-compileSdk = "34"
@@ -72,8 +72,8 @@ ktor-server-content-negotiation = { module = "io.ktor:ktor-server-content-negoti
 
 kslog = { module = "dev.inmo:kslog", version.ref = "kslog" }
 
-klock = { module = "com.soywiz.korlibs.klock:klock", version.ref = "korlibs" }
-krypto = { module = "com.soywiz.korlibs.krypto:krypto", version.ref = "korlibs" }
+klock = { module = "com.soywiz.korge:korlibs-time", version.ref = "korlibs" }
+krypto = { module = "com.soywiz.korge:korlibs-crypto", version.ref = "korlibs" }
 uuid = { module = "com.benasher44:uuid", version.ref = "uuid" }
 koin = { module = "io.insert-koin:koin-core", version.ref = "koin" }
 

gradle/wrapper/gradle-wrapper.properties

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

jvm.publish.gradle

@@ -2,11 +2,11 @@ apply plugin: 'maven-publish'
 
 task javadocJar(type: Jar) {
     from javadoc
-    classifier = 'javadoc'
+    archiveClassifier = 'javadoc'
 }
 task sourcesJar(type: Jar) {
     from sourceSets.main.allSource
-    classifier = 'sources'
+    archiveClassifier = 'sources'
 }
 
 publishing {
@@ -68,18 +68,14 @@ publishing {
                 
                     }
                 }
-                if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
+                if ((project.hasProperty('INMONEXUS_USER') || System.getenv('INMONEXUS_USER') != null) && (project.hasProperty('INMONEXUS_PASSWORD') || System.getenv('INMONEXUS_PASSWORD') != null)) {
                     maven {
-                        name = "Gitea"
-                        url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
+                        name = "InmoNexus"
+                        url = uri("https://nexus.inmo.dev/repository/maven-releases/")
                 
-                        credentials(HttpHeaderCredentials) {
-                            name = "Authorization"
-                            value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
-                        }
-                
-                        authentication {
-                            header(HttpHeaderAuthentication)
+                        credentials {
+                            username = project.hasProperty('INMONEXUS_USER') ? project.property('INMONEXUS_USER') : System.getenv('INMONEXUS_USER')
+                            password = project.hasProperty('INMONEXUS_PASSWORD') ? project.property('INMONEXUS_PASSWORD') : System.getenv('INMONEXUS_PASSWORD')
                         }
                 
                     }
@@ -115,4 +111,27 @@ if (project.hasProperty("signing.gnupg.keyName")) {
             dependsOn(it)
         }
     }
+
+    // Workaround to make android sign operations depend on signing tasks
+    project.getTasks().withType(AbstractPublishToMaven.class).configureEach {
+        def signingTasks = project.getTasks().withType(Sign.class)
+        mustRunAfter(signingTasks)
+    }
+    // Workaround to make test tasks use sign
+    project.getTasks().withType(Sign.class).configureEach { signTask ->
+        def withoutSign = (signTask.name.startsWith("sign") ? signTask.name.minus("sign") : signTask.name)
+        def pubName = withoutSign.endsWith("Publication") ? withoutSign.substring(0, withoutSign.length() - "Publication".length()) : withoutSign
+        // These tasks only exist for native targets, hence findByName() to avoid trying to find them for other targets
+
+        // Task ':linkDebugTest<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def debugTestTask = tasks.findByName("linkDebugTest$pubName")
+        if (debugTestTask != null) {
+            signTask.mustRunAfter(debugTestTask)
+        }
+        // Task ':compileTestKotlin<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def testTask = tasks.findByName("compileTestKotlin$pubName")
+        if (testTask != null) {
+            signTask.mustRunAfter(testTask)
+        }
+    }
 }

jvm.publish.kpsb

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

koin/generator/build.gradle

@@ -15,6 +15,6 @@ dependencies {
 }
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }

koin/generator/test/src/androidMain/AndroidManifest.xml

@@ -1 +1 @@
-<manifest package="dev.inmo.micro_utils.koin.generator.test"/>
+<manifest/>

koin/src/androidMain/AndroidManifest.xml

@@ -1 +1 @@
-<manifest package="dev.inmo.micro_utils.koin"/>
+<manifest/>

ktor/client/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {
@@ -30,5 +30,11 @@ kotlin {
                 api internalProject("micro_utils.mime_types")
             }
         }
+
+        linuxArm64Main {
+            dependencies {
+                api internalProject("micro_utils.mime_types")
+            }
+        }
     }
 }

ktor/client/src/androidMain/AndroidManifest.xml

@@ -1 +1 @@
-<manifest package="dev.inmo.micro_utils.ktor.client"/>
+<manifest/>

ktor/client/src/linuxArm64Main/kotlin/ActualTemporalUpload.kt

@@ -0,0 +1,40 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.filename
+import dev.inmo.micro_utils.ktor.common.TemporalFileId
+import dev.inmo.micro_utils.mime_types.getMimeTypeOrAny
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.onUpload
+import io.ktor.client.request.forms.formData
+import io.ktor.client.request.forms.submitFormWithBinaryData
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.Headers
+import io.ktor.http.HttpHeaders
+
+internal val MPPFile.mimeType: String
+    get() = getMimeTypeOrAny(filename.extension).raw
+
+actual suspend fun HttpClient.tempUpload(
+    fullTempUploadDraftPath: String,
+    file: MPPFile,
+    onUpload: OnUploadCallback
+): TemporalFileId {
+    val inputProvider = file.inputProvider()
+    val fileId = submitFormWithBinaryData(
+        fullTempUploadDraftPath,
+        formData = formData {
+            append(
+                "data",
+                inputProvider,
+                Headers.build {
+                    append(HttpHeaders.ContentType, file.mimeType)
+                    append(HttpHeaders.ContentDisposition, "filename=\"${file.filename.string}\"")
+                }
+            )
+        }
+    ) {
+        onUpload(onUpload)
+    }.bodyAsText()
+    return TemporalFileId(fileId)
+}

ktor/client/src/linuxArm64Main/kotlin/ActualUniUpload.kt

@@ -0,0 +1,107 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.Progress
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.mergeHeaders
+import io.ktor.client.plugins.onUpload
+import io.ktor.client.request.HttpRequestBuilder
+import io.ktor.client.request.forms.InputProvider
+import io.ktor.client.request.forms.formData
+import io.ktor.client.request.forms.submitForm
+import io.ktor.client.request.forms.submitFormWithBinaryData
+import io.ktor.client.request.headers
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.Headers
+import io.ktor.http.HttpHeaders
+import io.ktor.http.HttpStatusCode
+import io.ktor.http.Parameters
+import io.ktor.http.content.PartData
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.InternalSerializationApi
+import kotlinx.serialization.SerializationStrategy
+import kotlinx.serialization.StringFormat
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.serializer
+
+/**
+ * Will execute submitting of multipart data request
+ *
+ * @param data [Map] where keys will be used as names for multipart parts and values as values. If you will pass
+ * [dev.inmo.micro_utils.common.MPPFile] (File from JS or JVM platform). Also you may pass [UniUploadFileInfo] as value
+ * in case you wish to pass other source of multipart binary data than regular file
+ * @suppress
+ */
+@OptIn(InternalSerializationApi::class)
+actual suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    data: Map<String, Any>,
+    resultDeserializer: DeserializationStrategy<T>,
+    headers: Headers,
+    stringFormat: StringFormat,
+    onUpload: OnUploadCallback
+): T? {
+    val withBinary = data.values.any { it is MPPFile || it is UniUploadFileInfo }
+
+    val formData = formData {
+        for (k in data.keys) {
+            val v = data[k] ?: continue
+            when (v) {
+                is MPPFile -> append(
+                    k,
+                    v.inputProvider(),
+                    Headers.build {
+                        append(HttpHeaders.ContentType, v.mimeType)
+                        append(HttpHeaders.ContentDisposition, "filename=\"${v.name}\"")
+                    }
+                )
+                is UniUploadFileInfo -> append(
+                    k,
+                    InputProvider(block = v.inputAllocator),
+                    Headers.build {
+                        append(HttpHeaders.ContentType, v.mimeType)
+                        append(HttpHeaders.ContentDisposition, "filename=\"${v.fileName.name}\"")
+                    }
+                )
+                else -> append(
+                    k,
+                    stringFormat.encodeToString(v::class.serializer() as SerializationStrategy<in Any>, v)
+                )
+            }
+        }
+    }
+
+    val requestBuilder: HttpRequestBuilder.() -> Unit = {
+        headers {
+            appendAll(headers)
+        }
+        onUpload { bytesSentTotal, contentLength ->
+            onUpload(bytesSentTotal, contentLength)
+        }
+    }
+
+    val response = if (withBinary) {
+        submitFormWithBinaryData(
+            url,
+            formData,
+            block = requestBuilder
+        )
+    } else {
+        submitForm(
+            url,
+            Parameters.build {
+                for (it in formData) {
+                    val formItem = (it as PartData.FormItem)
+                    append(it.name!!, it.value)
+                }
+            },
+            block = requestBuilder
+        )
+    }
+
+    return if (response.status == HttpStatusCode.OK) {
+        stringFormat.decodeFromString(resultDeserializer, response.bodyAsText())
+    } else {
+        null
+    }
+}

ktor/common/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {

ktor/common/src/androidMain/AndroidManifest.xml

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

ktor/common/src/linuxArm64Main/kotlin/ActualMPPFileInput.kt

@@ -0,0 +1,11 @@
+package dev.inmo.micro_utils.ktor.common
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.bytesAllocatorSync
+import io.ktor.utils.io.core.ByteReadPacket
+import io.ktor.utils.io.core.Input
+
+actual fun MPPFile.input(): Input {
+    return ByteReadPacket(bytesAllocatorSync())
+}
+

language_codes/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {

language_codes/generator/build.gradle

@@ -26,6 +26,6 @@ dependencies {
 mainClassName="MainKt"
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }

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

@@ -12,9 +12,12 @@ private val json = Json {
     ignoreUnknownKeys = true
 }
 
-private const val baseClassName = "IetfLanguageCode"
+private const val baseClassName = "IetfLang"
+private const val oldBaseClassName = "IetfLanguageCode"
 private const val unknownBaseClassName = "Unknown$baseClassName"
-private const val baseClassSerializerName = "IetfLanguageCodeSerializer"
+private const val oldUnknownBaseClassName = "Unknown$oldBaseClassName"
+private const val baseClassSerializerName = "${baseClassName}Serializer"
+private const val oldBaseClassSerializerName = "IetfLanguageCodeSerializer"
 private const val baseClassSerializerAnnotationName = "@Serializable(${baseClassSerializerName}::class)"
 
 @Serializable
@@ -78,14 +81,12 @@ private fun printLanguageCodeAndTags(
     indents: String = "    "
 ): String = if (tag.subtags.isEmpty()) {
 """${indents}${baseClassSerializerAnnotationName}
-${indents}object ${tag.title} : ${parent ?.title ?: baseClassName}() { override val code: String = "${tag.tag}"; override val withoutDialect: String get() = ${parent ?.title ?.let { "$it.code" } ?: "code"} }"""
+${indents}object ${tag.title} : ${parent ?.title ?: baseClassName}() { override val code: String = "${tag.tag}"${parent ?.let { parent -> "; override val parentLang: ${parent.title} get() = ${parent.title};" } ?: ""} }"""
 } else {
 """
 ${indents}${baseClassSerializerAnnotationName}
 ${indents}sealed class ${tag.title} : ${parent ?.title ?: baseClassName}() {
-${indents}    override val code: String = "${tag.tag}"
-${indents}    override val withoutDialect: String
-${indents}        get() = code
+${indents}    override val code: String = "${tag.tag}"${parent ?.let { parent -> "\n${indents}    override val parentLang: ${parent.title} get() = ${parent.title};" } ?: ""}
 
 ${tag.subtags.joinToString("\n") { printLanguageCodeAndTags(it, tag, "${indents}    ") }}
 
@@ -95,7 +96,7 @@ ${indents}}
 """
 }
 
-fun buildKtFileContent(tags: List<Tag>): String = """
+fun buildKtFileContent(tags: List<Tag>, prePackage: String): String = """
 import kotlinx.serialization.Serializable
 
 /**
@@ -106,20 +107,27 @@ import kotlinx.serialization.Serializable
 ${baseClassSerializerAnnotationName}
 sealed class $baseClassName {
     abstract val code: String
-    abstract val withoutDialect: String
+    open val parentLang: $baseClassName?
+        get() = null
+    open val withoutDialect: String
+        get() = parentLang ?.code ?: code
 
 ${tags.joinToString("\n") { printLanguageCodeAndTags(it, indents = "    ") } }
 
     $baseClassSerializerAnnotationName
     data class $unknownBaseClassName (override val code: String) : $baseClassName() {
-        override val withoutDialect: String = code.takeWhile { it != '-' }
+        override val parentLang = code.dropLastWhile { it != '-' }.removeSuffix("-").takeIf { it.length > 0 } ?.let(::$unknownBaseClassName)
     }
+    @Deprecated("Renamed", ReplaceWith("$baseClassName.$unknownBaseClassName", "${if (prePackage.isNotEmpty()) "$prePackage." else ""}$baseClassName.$unknownBaseClassName"))
+    val $oldUnknownBaseClassName = $unknownBaseClassName
 
     override fun toString() = code
 }
+@Deprecated("Renamed", ReplaceWith("$baseClassName", "${if (prePackage.isNotEmpty()) "$prePackage." else ""}$baseClassName"))
+typealias $oldBaseClassName = $baseClassName
 """.trimIndent()
 
-fun createStringConverterCode(tags: List<Tag>): String {
+fun createStringConverterCode(tags: List<Tag>, prePackage: String): String {
     fun createDeserializeVariantForTag(
         tag: Tag,
         pretitle: String = baseClassName,
@@ -128,19 +136,70 @@ fun createStringConverterCode(tags: List<Tag>): String {
         val currentTitle = "$pretitle.${tag.title}"
         return """${indents}$currentTitle.code -> $currentTitle${if (tag.subtags.isNotEmpty()) tag.subtags.joinToString("\n", "\n") { createDeserializeVariantForTag(it, currentTitle, indents) } else ""}"""
     }
-
-    return """fun String.as$baseClassName(): $baseClassName {
-    return when (this) {
-${tags.joinToString("\n") { createDeserializeVariantForTag(it) }}
-        else -> $baseClassName.${unknownBaseClassName}(this)
+    fun createInheritorVariantForTag(
+        tag: Tag,
+        pretitle: String = baseClassName,
+        indents: String = "        "
+    ): String {
+        val currentTitle = "$pretitle.${tag.title}"
+        val subtags = if (tag.subtags.isNotEmpty()) {
+            tag.subtags.joinToString(",\n", ",\n") { createInheritorVariantForTag(it, currentTitle, "$indents    ") }
+        } else {
+            ""
+        }
+        return "${indents}$currentTitle$subtags"
     }
+    fun createInheritorVariantForMapForTag(
+        tag: Tag,
+        pretitle: String = baseClassName,
+        indents: String = "        ",
+        codeSuffix: String = ""
+    ): String {
+        val currentTitle = "$pretitle.${tag.title}"
+        val subtags = if (tag.subtags.isNotEmpty()) {
+            tag.subtags.joinToString(",\n", ",\n") { createInheritorVariantForMapForTag(it, currentTitle, "$indents    ", codeSuffix) }
+        } else {
+            ""
+        }
+        return "${indents}$currentTitle.code${codeSuffix} to $currentTitle$subtags"
+    }
+
+    return """val knownLanguageCodesMap: Map<String, $baseClassName> by lazy {
+    mapOf(
+${tags.joinToString(",\n") { createInheritorVariantForMapForTag(it, indents = "        ") }}
+    )
 }
+val knownLanguageCodesMapByLowerCasedKeys: Map<String, $baseClassName> by lazy {
+    mapOf(
+${tags.joinToString(",\n") { createInheritorVariantForMapForTag(it, indents = "        ", codeSuffix = ".lowercase()") }}
+    )
+}
+val knownLanguageCodes: List<$baseClassName> by lazy {
+    knownLanguageCodesMap.values.toList()
+}
+
+fun String.as$baseClassName(): $baseClassName {
+    return knownLanguageCodesMap[this] ?: $baseClassName.${unknownBaseClassName}(this)
+}
+fun String.as${baseClassName}CaseInsensitive(): $baseClassName {
+    return knownLanguageCodesMapByLowerCasedKeys[this.lowercase()] ?: $baseClassName.${unknownBaseClassName}(this)
+}
+@Deprecated("Renamed", ReplaceWith("this.as$baseClassName()", "${if (prePackage.isNotEmpty()) "$prePackage." else ""}as$baseClassName"))
+fun String.as$oldBaseClassName(): $baseClassName = as$baseClassName()
+
 fun convertTo$baseClassName(code: String) = code.as$baseClassName()
+fun convertTo${baseClassName}CaseInsensitive(code: String) = code.as${baseClassName}CaseInsensitive()
+@Deprecated("Renamed", ReplaceWith("convertTo$baseClassName(code)", "${if (prePackage.isNotEmpty()) "$prePackage." else ""}convertTo$baseClassName"))
+fun convertTo$oldBaseClassName(code: String) = convertTo$baseClassName(code)
+
 fun $baseClassName(code: String) = code.as$baseClassName()
+fun ${baseClassName}CaseInsensitive(code: String) = code.as${baseClassName}CaseInsensitive()
+@Deprecated("Renamed", ReplaceWith("$baseClassName(code)", "${if (prePackage.isNotEmpty()) "$prePackage." else ""}$baseClassName"))
+fun $oldBaseClassName(code: String) = $baseClassName(code)
 """
 }
 
-fun createSerializerCode(tags: List<Tag>): String {
+fun createSerializerCode(tags: List<Tag>, prePackage: String): String {
     return """import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.serializer
 import kotlinx.serialization.encoding.Decoder
@@ -153,16 +212,20 @@ object $baseClassSerializerName : KSerializer<$baseClassName> {
         return $baseClassName(decoder.decodeString())
     }
 
-    override fun serialize(encoder: Encoder, value: IetfLanguageCode) {
+    override fun serialize(encoder: Encoder, value: $baseClassName) {
         encoder.encodeString(value.code)
     }
 }
+@Deprecated("Renamed", ReplaceWith("$baseClassSerializerName", "${if (prePackage.isNotEmpty()) "$prePackage." else ""}$baseClassSerializerName"))
+typealias $oldBaseClassSerializerName = $baseClassSerializerName
 """
 }
 
 suspend fun main(vararg args: String) {
     val outputFolder = args.firstOrNull() ?.let { File(it) }
     outputFolder ?.mkdirs()
+    val targetPackage = args.getOrNull(1)
+    val targetPackagePrefix = targetPackage ?.let { "package $it\n\n" } ?: ""
     val ietfLanguageCodesLink = "https://datahub.io/core/language-codes/r/language-codes.json"
     val ietfLanguageCodesAdditionalTagsLink = "https://datahub.io/core/language-codes/r/ietf-language-tags.json"
 
@@ -203,18 +266,18 @@ suspend fun main(vararg args: String) {
     File(outputFolder, "LanguageCodes.kt").apply {
         delete()
         createNewFile()
-        writeText(buildKtFileContent(tags))
+        writeText(targetPackagePrefix + buildKtFileContent(tags, targetPackage ?: ""))
     }
 
     File(outputFolder, "StringToLanguageCodes.kt").apply {
         delete()
         createNewFile()
-        writeText(createStringConverterCode(tags))
+        writeText(targetPackagePrefix + createStringConverterCode(tags, targetPackage ?: ""))
     }
 
     File(outputFolder, "$baseClassSerializerName.kt").apply {
         delete()
         createNewFile()
-        writeText(createSerializerCode(tags))
+        writeText(targetPackagePrefix + createSerializerCode(tags, targetPackage ?: ""))
     }
 }

language_codes/src/androidMain/AndroidManifest.xml

@@ -1 +1 @@
-<manifest package="dev.inmo.micro_utils.language_codes"/>
+<manifest/>

language_codes/src/commonMain/kotlin/dev/inmo/micro_utils/language_codes/IetfLangSerializer.kt

@@ -0,0 +1,20 @@
+package dev.inmo.micro_utils.language_codes
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+object IetfLangSerializer : KSerializer<IetfLang> {
+    override val descriptor = String.serializer().descriptor
+
+    override fun deserialize(decoder: Decoder): IetfLang {
+        return IetfLang(decoder.decodeString())
+    }
+
+    override fun serialize(encoder: Encoder, value: IetfLang) {
+        encoder.encodeString(value.code)
+    }
+}
+@Deprecated("Renamed", ReplaceWith("IetfLangSerializer", "dev.inmo.micro_utils.language_codes.IetfLangSerializer"))
+typealias IetfLanguageCodeSerializer = IetfLangSerializer

language_codes/src/commonMain/kotlin/dev/inmo/micro_utils/language_codes/IetfLanguageCodeSerializer.kt

@@ -1,18 +0,0 @@
-package dev.inmo.micro_utils.language_codes
-
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.serializer
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-
-object IetfLanguageCodeSerializer : KSerializer<IetfLanguageCode> {
-    override val descriptor = String.serializer().descriptor
-
-    override fun deserialize(decoder: Decoder): IetfLanguageCode {
-        return IetfLanguageCode(decoder.decodeString())
-    }
-
-    override fun serialize(encoder: Encoder, value: IetfLanguageCode) {
-        encoder.encodeString(value.code)
-    }
-}

language_codes/src/commonTest/kotlin/UnknownIetfLanguageTests.kt

@@ -0,0 +1,16 @@
+package dev.inmo.micro_utils.language_codes
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class UnknownIetfLanguageTests {
+    @Test
+    fun commonTestOfParentCode() {
+        knownLanguageCodes.forEach {
+            val language = IetfLang.UnknownIetfLang(it.code)
+            assertEquals(it.code, language.code)
+            assertEquals(it.withoutDialect, language.withoutDialect)
+            assertEquals(it.parentLang ?.code, language.parentLang ?.code)
+        }
+    }
+}

language_codes/src/jvmMain/kotlin/Locale.kt

@@ -2,7 +2,9 @@ package dev.inmo.micro_utils.language_codes
 
 import java.util.Locale
 
-fun IetfLanguageCode.toJavaLocale(): Locale = Locale.forLanguageTag(code)
-fun IetfLanguageCode?.toJavaLocaleOrDefault(): Locale = this ?.toJavaLocale() ?: Locale.getDefault()
+fun IetfLang.toJavaLocale(): Locale = Locale.forLanguageTag(code)
+fun IetfLang?.toJavaLocaleOrDefault(): Locale = this?.toJavaLocale() ?: Locale.getDefault()
 
-fun Locale.toIetfLanguageCode(): IetfLanguageCode = IetfLanguageCode(toLanguageTag())
+fun Locale.toIetfLang(): IetfLang = IetfLang(toLanguageTag())
+@Deprecated("Renamed", ReplaceWith("this.toIetfLang()", "dev.inmo.micro_utils.language_codes.toIetfLang"))
+fun Locale.toIetfLanguageCode(): IetfLang = toIetfLang()

matrix/build.gradle

@@ -4,4 +4,4 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"

matrix/src/androidMain/AndroidManifest.xml

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

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

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

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

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

mime_types/build.gradle

@@ -4,4 +4,4 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"

mime_types/src/androidMain/AndroidManifest.xml

@@ -1 +1 @@
-<manifest package="dev.inmo.micro_utils.mime_types"/>
+<manifest/>

mppAndroidProject.gradle

@@ -4,8 +4,13 @@ project.group = "$group"
 apply from: "$publishGradlePath"
 
 kotlin {
-    android {
+    androidTarget {
         publishAllLibraryVariants()
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
     }
 
     sourceSets {
@@ -27,6 +32,6 @@ kotlin {
 apply from: "$defaultAndroidSettingsPresetPath"
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }

mppJavaProject.gradle

@@ -7,7 +7,7 @@ kotlin {
     jvm {
         compilations.main {
             kotlinOptions {
-                jvmTarget = "1.8"
+                jvmTarget = "17"
             }
         }
     }
@@ -35,6 +35,6 @@ kotlin {
 }
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }

mppJvmJsAndroidLinuxMingwLinuxArm64Project.gradle

@@ -0,0 +1,71 @@
+project.version = "$version"
+project.group = "$group"
+
+apply from: "$publishGradlePath"
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+    js (IR) {
+        browser()
+        nodejs()
+    }
+    androidTarget {
+        publishAllLibraryVariants()
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+    linuxX64()
+    mingwX64()
+    linuxArm64()
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+                api libs.kt.serialization
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test-common')
+                implementation kotlin('test-annotations-common')
+                implementation libs.kt.coroutines.test
+            }
+        }
+
+        androidUnitTest {
+            dependencies {
+                implementation kotlin('test-junit')
+                implementation libs.android.test.junit
+                implementation libs.android.espresso
+            }
+        }
+        jvmTest {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+        jsTest {
+            dependencies {
+                implementation kotlin('test-js')
+                implementation kotlin('test-junit')
+            }
+        }
+    }
+}
+
+apply from: "$defaultAndroidSettingsPresetPath"
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

mppJvmJsAndroidProject.gradle

@@ -7,7 +7,7 @@ kotlin {
     jvm {
         compilations.main {
             kotlinOptions {
-                jvmTarget = "1.8"
+                jvmTarget = "17"
             }
         }
     }
@@ -15,8 +15,13 @@ kotlin {
         browser()
         nodejs()
     }
-    android {
+    androidTarget {
         publishAllLibraryVariants()
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
     }
     linuxX64()
     mingwX64()
@@ -71,6 +76,6 @@ kotlin {
 apply from: "$defaultAndroidSettingsPresetPath"
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }

mppJvmJsLinuxMingwLinuxArm64Project.gradle

@@ -0,0 +1,54 @@
+project.version = "$version"
+project.group = "$group"
+
+apply from: "$publishGradlePath"
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+    js (IR) {
+        browser()
+        nodejs()
+    }
+    linuxX64()
+    mingwX64()
+    linuxArm64()
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+                api libs.kt.serialization
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test-common')
+                implementation kotlin('test-annotations-common')
+                implementation libs.kt.coroutines.test
+            }
+        }
+
+        jvmTest {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+        jsTest {
+            dependencies {
+                implementation kotlin('test-js')
+                implementation kotlin('test-junit')
+            }
+        }
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

mppJvmJsLinuxMingwProject.gradle

@@ -7,7 +7,7 @@ kotlin {
     jvm {
         compilations.main {
             kotlinOptions {
-                jvmTarget = "1.8"
+                jvmTarget = "17"
             }
         }
     }
@@ -22,6 +22,7 @@ kotlin {
         commonMain {
             dependencies {
                 implementation kotlin('stdlib')
+                api libs.kt.serialization
             }
         }
         commonTest {
@@ -43,10 +44,22 @@ kotlin {
                 implementation kotlin('test-junit')
             }
         }
+        mingwX64Test {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+        linuxX64Test {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+
+        androidMain.dependsOn jvmMain
     }
 }
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }

mppProjectWithSerializationAndCompose.gradle

@@ -7,7 +7,7 @@ kotlin {
     jvm {
         compilations.main {
             kotlinOptions {
-                jvmTarget = "1.8"
+                jvmTarget = "17"
             }
         }
     }
@@ -15,8 +15,13 @@ kotlin {
         browser()
         nodejs()
     }
-    android {
+    androidTarget {
         publishAllLibraryVariants()
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
     }
 
     sourceSets {
@@ -70,6 +75,13 @@ kotlin {
 apply from: "$defaultAndroidSettingsPresetPath"
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }
+
+
+//compose {
+//    if (composePluginKotlinVersion != null && !composePluginKotlinVersion.isEmpty()) {
+//        kotlinCompilerPlugin.set(composePluginKotlinVersion)
+//    }
+//}

pagination/common/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {

pagination/common/src/androidMain/AndroidManifest.xml

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

pagination/ktor/common/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {

pagination/ktor/common/src/androidMain/AndroidManifest.xml

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

publish.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'maven-publish'
 
 task javadocsJar(type: Jar) {
-    classifier = 'javadoc'
+    archiveClassifier = 'javadoc'
 }
 
 publishing {
@@ -19,29 +19,29 @@ publishing {
             }
 
             developers {
-
+                
                     developer {
                         id = "InsanusMokrassar"
                         name = "Aleksei Ovsiannikov"
                         email = "ovsyannikov.alexey95@gmail.com"
                     }
-
+                
 
                     developer {
                         id = "000Sanya"
                         name = "Syrov Aleksandr"
                         email = "000sanya.000sanya@gmail.com"
                     }
-
+                
             }
 
             licenses {
-
+                
                     license {
                         name = "Apache Software License 2.0"
                         url = "https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"
                     }
-
+                
             }
         }
         repositories {
@@ -49,57 +49,77 @@ publishing {
                 maven {
                     name = "GithubPackages"
                     url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
-
+            
                     credentials {
                         username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
                         password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
                     }
-
+            
                 }
             }
-            if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
+            if ((project.hasProperty('INMONEXUS_USER') || System.getenv('INMONEXUS_USER') != null) && (project.hasProperty('INMONEXUS_PASSWORD') || System.getenv('INMONEXUS_PASSWORD') != null)) {
                 maven {
-                    name = "Gitea"
-                    url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
-
-                    credentials(HttpHeaderCredentials) {
-                        name = "Authorization"
-                        value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
-                    }
-
-                    authentication {
-                        header(HttpHeaderAuthentication)
+                    name = "InmoNexus"
+                    url = uri("https://nexus.inmo.dev/repository/maven-releases/")
+            
+                    credentials {
+                        username = project.hasProperty('INMONEXUS_USER') ? project.property('INMONEXUS_USER') : System.getenv('INMONEXUS_USER')
+                        password = project.hasProperty('INMONEXUS_PASSWORD') ? project.property('INMONEXUS_PASSWORD') : System.getenv('INMONEXUS_PASSWORD')
                     }
+            
                 }
             }
             if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
                 maven {
                     name = "sonatype"
                     url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
-
+            
                     credentials {
                         username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
                         password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
                     }
-
+            
                 }
             }
         }
     }
 }
-
+    
 if (project.hasProperty("signing.gnupg.keyName")) {
     apply plugin: 'signing'
-
+    
     signing {
         useGpgCmd()
-
+    
         sign publishing.publications
     }
-
+    
     task signAll {
         tasks.withType(Sign).forEach {
             dependsOn(it)
         }
     }
+
+    // Workaround to make android sign operations depend on signing tasks
+    project.getTasks().withType(AbstractPublishToMaven.class).configureEach {
+        def signingTasks = project.getTasks().withType(Sign.class)
+        mustRunAfter(signingTasks)
+    }
+    // Workaround to make test tasks use sign
+    project.getTasks().withType(Sign.class).configureEach { signTask ->
+        def withoutSign = (signTask.name.startsWith("sign") ? signTask.name.minus("sign") : signTask.name)
+        def pubName = withoutSign.endsWith("Publication") ? withoutSign.substring(0, withoutSign.length() - "Publication".length()) : withoutSign
+        // These tasks only exist for native targets, hence findByName() to avoid trying to find them for other targets
+
+        // Task ':linkDebugTest<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def debugTestTask = tasks.findByName("linkDebugTest$pubName")
+        if (debugTestTask != null) {
+            signTask.mustRunAfter(debugTestTask)
+        }
+        // Task ':compileTestKotlin<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def testTask = tasks.findByName("compileTestKotlin$pubName")
+        if (testTask != null) {
+            signTask.mustRunAfter(testTask)
+        }
+    }
 }

publish.kpsb

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

repos/cache/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {

repos/cache/src/androidMain/AndroidManifest.xml

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

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

@@ -5,6 +5,7 @@ import dev.inmo.micro_utils.coroutines.withReadAcquire
 import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.micro_utils.repos.cache.cache.KVCache
+import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -29,7 +30,7 @@ open class ReadCRUDCacheRepo<ObjectType, IdType>(
             kvCache.getAll()
         }.takeIf { it.size.toLong() == count() } ?: parentRepo.getAll().also {
             locker.withWriteLock {
-                kvCache.actualizeAll(true) { it }
+                kvCache.actualizeAll(clearMode = ActualizeAllClearMode.BeforeSet) { it }
             }
         }
     }
@@ -61,18 +62,28 @@ open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>(
     override val deletedObjectsIdsFlow: Flow<IdType> by parentRepo::deletedObjectsIdsFlow
 
     val createdObjectsFlowJob = parentRepo.newObjectsFlow.onEach {
-        locker.withWriteLock { kvCache.set(idGetter(it), it) }
+        locker.withWriteLock {
+            kvCache.set(idGetter(it), it)
+        }
     }.launchIn(scope)
 
     val updatedObjectsFlowJob = parentRepo.updatedObjectsFlow.onEach {
-        locker.withWriteLock { kvCache.set(idGetter(it), it) }
+        locker.withWriteLock {
+            kvCache.set(idGetter(it), it)
+        }
     }.launchIn(scope)
 
     val deletedObjectsFlowJob = parentRepo.deletedObjectsIdsFlow.onEach {
-        locker.withWriteLock { kvCache.unset(it) }
+        locker.withWriteLock {
+            kvCache.unset(it)
+        }
     }.launchIn(scope)
 
-    override suspend fun deleteById(ids: List<IdType>) = parentRepo.deleteById(ids)
+    override suspend fun deleteById(ids: List<IdType>) = parentRepo.deleteById(ids).also {
+        locker.withWriteLock {
+            kvCache.unset(ids)
+        }
+    }
 
     override suspend fun update(values: List<UpdatedValuePair<IdType, InputValueType>>): List<ObjectType> {
         val updated = parentRepo.update(values)
@@ -138,7 +149,9 @@ open class CRUDCacheRepo<ObjectType, IdType, InputValueType>(
     locker,
     idGetter
 ),
-    CRUDRepo<ObjectType, IdType, InputValueType>
+    CRUDRepo<ObjectType, IdType, InputValueType> {
+    override suspend fun invalidate() = kvCache.actualizeAll(parentRepo, locker = locker)
+}
 
 fun <ObjectType, IdType, InputType> CRUDRepo<ObjectType, IdType, InputType>.cached(
     kvCache: KVCache<IdType, ObjectType>,

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

@@ -1,5 +1,11 @@
 package dev.inmo.micro_utils.repos.cache
 
-interface CacheRepo {
+interface InvalidatableRepo {
+    /**
+     * Invalidates its internal data. It __may__ lead to autoreload of data. In case when repo makes autoreload,
+     * it must do loading of data __before__ clear
+     */
     suspend fun invalidate()
 }
+
+typealias CacheRepo = InvalidatableRepo

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

@@ -6,6 +6,7 @@ import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.micro_utils.repos.cache.cache.KVCache
+import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
@@ -48,9 +49,7 @@ open class ReadKeyValueCacheRepo<Key,Value>(
         }
     }
 
-    override suspend fun invalidate() = locker.withWriteLock {
-        kvCache.clear()
-    }
+    override suspend fun invalidate() = kvCache.actualizeAll(parentRepo, locker = locker)
 }
 
 fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
@@ -75,10 +74,6 @@ open class KeyValueCacheRepo<Key,Value>(
         }
     }.launchIn(scope)
 
-    override suspend fun invalidate() = locker.withWriteLock {
-        kvCache.clear()
-    }
-
     override suspend fun clear() {
         parentRepo.clear()
         locker.withWriteLock {

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

@@ -7,6 +7,7 @@ import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.*
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.micro_utils.repos.cache.cache.KVCache
+import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
@@ -47,9 +48,7 @@ open class ReadKeyValuesCacheRepo<Key,Value>(
         kvCache.contains(k)
     } || parentRepo.contains(k)
 
-    override suspend fun invalidate() = locker.withWriteLock {
-        kvCache.clear()
-    }
+    override suspend fun invalidate() = kvCache.actualizeAll(parentRepo, locker = locker)
 }
 
 fun <Key, Value> ReadKeyValuesRepo<Key, Value>.cached(
@@ -84,10 +83,6 @@ open class KeyValuesCacheRepo<Key,Value>(
             kvCache.unset(it)
         }
     }.launchIn(scope)
-
-    override suspend fun invalidate() = locker.withWriteLock {
-        kvCache.clear()
-    }
 }
 
 fun <Key, Value> KeyValuesRepo<Key, Value>.cached(

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/crud/AutoRecacheReadCRUDRepo.kt

@@ -9,6 +9,7 @@ import dev.inmo.micro_utils.repos.ReadCRUDRepo
 import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
+import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.set
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
@@ -56,7 +57,7 @@ open class AutoRecacheReadCRUDRepo<RegisteredObject, Id>(
     override suspend fun getAll(): Map<Id, RegisteredObject> = actionWrapper.wrap {
         originalRepo.getAll()
     }.onSuccess {
-        kvCache.actualizeAll(clear = true) { it }
+        kvCache.actualizeAll(clearMode = ActualizeAllClearMode.BeforeSet) { it }
     }.getOrElse {
         kvCache.getAll()
     }

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalue/AutoRecacheReadKeyValueRepo.kt

@@ -9,6 +9,7 @@ import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
+import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.set
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
@@ -56,7 +57,7 @@ open class AutoRecacheReadKeyValueRepo<Id, RegisteredObject>(
     override suspend fun getAll(): Map<Id, RegisteredObject> = actionWrapper.wrap {
         originalRepo.getAll()
     }.onSuccess {
-        kvCache.actualizeAll(clear = true) { it }
+        kvCache.actualizeAll(clearMode = ActualizeAllClearMode.BeforeSet) { it }
     }.getOrElse {
         kvCache.getAll()
     }

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullCRUDCacheRepo.kt

@@ -9,6 +9,7 @@ import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.micro_utils.repos.cache.*
+import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -28,12 +29,21 @@ open class FullReadCRUDCacheRepo<ObjectType, IdType>(
             kvCache.action().onPresented { return it }
         }
         return parentRepo.actionElse().also {
-            locker.withWriteLock { kvCache.actualize(it) }
+            kvCache.actualize(it)
         }
     }
+    protected suspend inline fun <T> doOrTakeAndActualizeWithWriteLock(
+        action: KeyValueRepo<IdType, ObjectType>.() -> Optional<T>,
+        actionElse: ReadCRUDRepo<ObjectType, IdType>.() -> T,
+        actualize: KeyValueRepo<IdType, ObjectType>.(T) -> Unit
+    ): T = doOrTakeAndActualize(
+        action = action,
+        actionElse = actionElse,
+        actualize = { locker.withWriteLock { actualize(it) } }
+    )
 
     protected open suspend fun actualizeAll() {
-        locker.withWriteLock { kvCache.actualizeAll(parentRepo) }
+        kvCache.actualizeAll(parentRepo, locker = locker)
     }
 
     override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = doOrTakeAndActualize(
@@ -54,22 +64,22 @@ open class FullReadCRUDCacheRepo<ObjectType, IdType>(
         { if (it != 0L) actualizeAll() }
     )
 
-    override suspend fun contains(id: IdType): Boolean = doOrTakeAndActualize(
+    override suspend fun contains(id: IdType): Boolean = doOrTakeAndActualizeWithWriteLock(
         { contains(id).takeIf { it }.optionalOrAbsentIfNull },
         { contains(id) },
-        { if (it) parentRepo.getById(id) ?.let { set(id, it) } }
+        { if (it) parentRepo.getById(id) ?.let { kvCache.set(id, it) } }
     )
 
-    override suspend fun getAll(): Map<IdType, ObjectType> = doOrTakeAndActualize(
+    override suspend fun getAll(): Map<IdType, ObjectType> = doOrTakeAndActualizeWithWriteLock(
         { getAll().takeIf { it.isNotEmpty() }.optionalOrAbsentIfNull },
         { getAll() },
-        { kvCache.actualizeAll(clear = true) { it } }
+        { kvCache.actualizeAll(clearMode = ActualizeAllClearMode.BeforeSet) { it } }
     )
 
-    override suspend fun getById(id: IdType): ObjectType? = doOrTakeAndActualize(
+    override suspend fun getById(id: IdType): ObjectType? = doOrTakeAndActualizeWithWriteLock(
         { get(id) ?.optional ?: Optional.absent() },
         { getById(id) },
-        { it ?.let { set(idGetter(it), it) } }
+        { it ?.let { kvCache.set(idGetter(it), it) } }
     )
 
     override suspend fun invalidate() {

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullKeyValueCacheRepo.kt

@@ -8,8 +8,8 @@ import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
-import dev.inmo.micro_utils.repos.pagination.getAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
@@ -28,20 +28,26 @@ open class FullReadKeyValueCacheRepo<Key,Value>(
             kvCache.action().onPresented { return it }
         }
         return parentRepo.actionElse().also {
-            locker.withWriteLock { kvCache.actualize(it) }
+            kvCache.actualize(it)
         }
     }
+    protected suspend inline fun <T> doOrTakeAndActualizeWithWriteLock(
+        action: KeyValueRepo<Key, Value>.() -> Optional<T>,
+        actionElse: ReadKeyValueRepo<Key, Value>.() -> T,
+        actualize: KeyValueRepo<Key, Value>.(T) -> Unit
+    ): T = doOrTakeAndActualize(
+        action = action,
+        actionElse = actionElse,
+        actualize = { locker.withWriteLock { actualize(it) } }
+    )
     protected open suspend fun actualizeAll() {
-        locker.withWriteLock {
-            kvCache.clear()
-            kvCache.set(parentRepo.getAll { keys(it) }.toMap())
-        }
+        kvCache.actualizeAll(parentRepo, locker)
     }
 
-    override suspend fun get(k: Key): Value? = doOrTakeAndActualize(
+    override suspend fun get(k: Key): Value? = doOrTakeAndActualizeWithWriteLock(
         { get(k) ?.optional ?: Optional.absent() },
         { get(k) },
-        { set(k, it ?: return@doOrTakeAndActualize) }
+        { kvCache.set(k, it ?: return@doOrTakeAndActualizeWithWriteLock) }
     )
 
     override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = doOrTakeAndActualize(
@@ -56,16 +62,16 @@ open class FullReadKeyValueCacheRepo<Key,Value>(
         { if (it != 0L) actualizeAll() }
     )
 
-    override suspend fun contains(key: Key): Boolean = doOrTakeAndActualize(
+    override suspend fun contains(key: Key): Boolean = doOrTakeAndActualizeWithWriteLock(
         { contains(key).takeIf { it }.optionalOrAbsentIfNull },
         { contains(key) },
         { if (it) parentRepo.get(key) ?.also { kvCache.set(key, it) } }
     )
 
-    override suspend fun getAll(): Map<Key, Value> = doOrTakeAndActualize(
+    override suspend fun getAll(): Map<Key, Value> = doOrTakeAndActualizeWithWriteLock(
         { getAll().takeIf { it.isNotEmpty() }.optionalOrAbsentIfNull },
         { getAll() },
-        { kvCache.actualizeAll(clear = true) { it } }
+        { kvCache.actualizeAll(clearMode = ActualizeAllClearMode.BeforeSet) { it } }
     )
 
     override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = doOrTakeAndActualize(
@@ -141,9 +147,7 @@ open class FullKeyValueCacheRepo<Key,Value>(
     override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset)
 
     override suspend fun invalidate() {
-        locker.withWriteLock {
-            kvCache.actualizeAll(parentRepo)
-        }
+        kvCache.actualizeAll(parentRepo, locker)
     }
 
     override suspend fun clear() {

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullKeyValuesCacheRepo.kt

@@ -8,6 +8,7 @@ import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.*
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -27,20 +28,27 @@ open class FullReadKeyValuesCacheRepo<Key,Value>(
             kvCache.action().onPresented { return it }
         }
         return parentRepo.actionElse().also {
-            locker.withWriteLock { kvCache.actualize(it) }
+            kvCache.actualize(it)
         }
     }
+    protected suspend inline fun <T> doOrTakeAndActualizeWithWriteLock(
+        action: KeyValueRepo<Key, List<Value>>.() -> Optional<T>,
+        actionElse: ReadKeyValuesRepo<Key, Value>.() -> T,
+        actualize: KeyValueRepo<Key, List<Value>>.(T) -> Unit
+    ): T = doOrTakeAndActualize(
+        action = action,
+        actionElse = actionElse,
+        actualize = { locker.withWriteLock { actualize(it) } }
+    )
 
     protected open suspend fun actualizeKey(k: Key) {
-        locker.withWriteLock {
-            kvCache.set(k, parentRepo.getAll(k))
+        kvCache.actualizeAll(locker = locker, clearMode = ActualizeAllClearMode.Never) {
+            mapOf(k to parentRepo.getAll(k))
         }
     }
 
     protected open suspend fun actualizeAll() {
-        locker.withWriteLock {
-            kvCache.actualizeAll(parentRepo)
-        }
+        kvCache.actualizeAll(parentRepo, locker = locker)
     }
 
     override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
@@ -178,9 +186,11 @@ open class FullKeyValuesCacheRepo<Key,Value>(
     }
 
     override suspend fun invalidate() {
-        locker.withWriteLock {
-            kvCache.actualizeAll(parentRepo)
-        }
+        kvCache.actualizeAll(parentRepo, locker = locker)
+    }
+
+    override suspend fun set(toSet: Map<Key, List<Value>>) {
+        super<KeyValuesRepo>.set(toSet)
     }
 
     override suspend fun removeWithValue(v: Value) {

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/util/ActualizeAll.kt

@@ -1,43 +1,169 @@
 package dev.inmo.micro_utils.repos.cache.util
 
+import dev.inmo.micro_utils.coroutines.SmartRWLocker
+import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.repos.*
+import kotlinx.serialization.Serializable
+import kotlin.js.JsName
+import kotlin.jvm.JvmName
 
-suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAll(
-    clear: Boolean = true,
+/**
+ * `invalidate`/`actualizeAll` clearing mode. Declare when data in original repo will be cleared
+ */
+@Serializable
+sealed interface ActualizeAllClearMode {
+    /**
+     * Instruct user of this mode to clear internal data __before load__ of external data
+     */
+    @Serializable
+    data object BeforeLoad : ActualizeAllClearMode
+    /**
+     * Instruct user of this mode to clear internal data __after load__ of external data and __before set__ of internal data
+     */
+    @Serializable
+    data object BeforeSet : ActualizeAllClearMode
+    /**
+     * Instruct user of this mode to never clear internal data
+     */
+    @Serializable
+    data object Never : ActualizeAllClearMode
+}
+
+suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeLoad(
     getAll: () -> Map<K, V>
 ) {
-    set(
-        getAll().also {
-            if (clear) {
-                clear()
-            }
-        }
-    )
+    clear()
+    val newData = getAll()
+    set(newData)
+}
+
+suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeSet(
+    getAll: () -> Map<K, V>
+) {
+    val newData = getAll()
+    clear()
+    set(newData)
+}
+
+suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAllWithoutClear(
+    getAll: () -> Map<K, V>
+) {
+    val newData = getAll()
+    set(newData)
+}
+
+@JvmName("actualizeAllWithClearBeforeLoadWithLocker")
+@JsName("actualizeAllWithClearBeforeLoadWithLocker")
+suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeLoad(
+    locker: SmartRWLocker,
+    getAll: () -> Map<K, V>
+) {
+    locker.withWriteLock {
+        clear()
+    }
+
+    val newData = getAll()
+    locker.withWriteLock {
+        set(newData)
+    }
+}
+
+@JvmName("actualizeAllWithClearBeforeSetWithLocker")
+@JsName("actualizeAllWithClearBeforeSetWithLocker")
+suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeSet(
+    locker: SmartRWLocker,
+    getAll: () -> Map<K, V>
+) {
+    val newData = getAll()
+    locker.withWriteLock {
+        clear()
+        set(newData)
+    }
+}
+
+@JvmName("actualizeAllWithoutClearWithLocker")
+@JsName("actualizeAllWithoutClearWithLocker")
+suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAllWithoutClear(
+    locker: SmartRWLocker,
+    getAll: () -> Map<K, V>
+) {
+    val newData = getAll()
+    locker.withWriteLock {
+        set(newData)
+    }
+}
+
+suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeLoad(
+    locker: SmartRWLocker? = null,
+    getAll: () -> Map<K, V>
+) {
+    locker ?.let {
+        actualizeAllWithClearBeforeLoad(locker = locker, getAll)
+    } ?: actualizeAllWithClearBeforeLoad(getAll)
+}
+
+suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeSet(
+    locker: SmartRWLocker? = null,
+    getAll: () -> Map<K, V>
+) {
+    locker ?.let {
+        actualizeAllWithClearBeforeSet(locker = locker, getAll)
+    } ?: actualizeAllWithClearBeforeSet(getAll)
+}
+
+suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAllWithoutClear(
+    locker: SmartRWLocker? = null,
+    getAll: () -> Map<K, V>
+) {
+    locker ?.let {
+        actualizeAllWithoutClear(locker = locker, getAll)
+    } ?: actualizeAllWithoutClear(getAll)
 }
 
 suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAll(
-    repo: ReadKeyValueRepo<K, V>,
-    clear: Boolean = true,
+    locker: SmartRWLocker? = null,
+    clearMode: ActualizeAllClearMode = ActualizeAllClearMode.BeforeSet,
+    getAll: () -> Map<K, V>
 ) {
-    actualizeAll(clear) {
-        repo.getAll()
+    when (clearMode) {
+        ActualizeAllClearMode.BeforeLoad -> locker ?.let {
+            actualizeAllWithClearBeforeLoad(locker = locker, getAll)
+        } ?: actualizeAllWithClearBeforeLoad(getAll)
+        ActualizeAllClearMode.BeforeSet -> locker ?.let {
+            actualizeAllWithClearBeforeSet(locker = locker, getAll)
+        } ?: actualizeAllWithClearBeforeSet(getAll)
+        ActualizeAllClearMode.Never -> locker ?.let {
+            actualizeAllWithoutClear(locker = locker, getAll)
+        } ?: actualizeAllWithoutClear(getAll)
+    }
+}
+
+suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAll(
+    parentRepo: ReadKeyValueRepo<K, V>,
+    locker: SmartRWLocker? = null,
+    clearMode: ActualizeAllClearMode = ActualizeAllClearMode.BeforeSet,
+) {
+    actualizeAll(locker, clearMode) {
+        parentRepo.getAll()
     }
 }
 
 suspend inline fun <K, V> KeyValueRepo<K, List<V>>.actualizeAll(
-    repo: ReadKeyValuesRepo<K, V>,
-    clear: Boolean = true,
+    parentRepo: ReadKeyValuesRepo<K, V>,
+    locker: SmartRWLocker? = null,
+    clearMode: ActualizeAllClearMode = ActualizeAllClearMode.BeforeSet,
 ) {
-    actualizeAll(clear) {
-        repo.getAll()
+    actualizeAll(locker, clearMode) {
+        parentRepo.getAll()
     }
 }
 
 suspend inline fun <K, V> KeyValueRepo<K, V>.actualizeAll(
-    repo: ReadCRUDRepo<V, K>,
-    clear: Boolean = true,
+    parentRepo: ReadCRUDRepo<V, K>,
+    locker: SmartRWLocker? = null,
+    clearMode: ActualizeAllClearMode = ActualizeAllClearMode.BeforeSet,
 ) {
-    actualizeAll(clear) {
-        repo.getAll()
+    actualizeAll(locker, clearMode) {
+        parentRepo.getAll()
     }
 }

repos/common/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {

repos/common/src/androidMain/AndroidManifest.xml

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

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

@@ -1,5 +1,6 @@
 package dev.inmo.micro_utils.repos
 
+import dev.inmo.micro_utils.common.diff
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
@@ -130,6 +131,14 @@ interface KeyValuesRepo<Key, Value> : ReadKeyValuesRepo<Key, Value>, WriteKeyVal
 
         remove(toRemove)
     }
+
+    override suspend fun set(toSet: Map<Key, List<Value>>) {
+        toSet.forEach { (k, v) ->
+            val diff = getAll(k).diff(v)
+            remove(k, diff.removed.map { it.value })
+            add(k, diff.added.map { it.value })
+        }
+    }
 }
 typealias OneToManyKeyValueRepo<Key,Value> = KeyValuesRepo<Key, Value>
 

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/AbstractExposedCRUDRepo.kt

@@ -1,14 +1,19 @@
 package dev.inmo.micro_utils.repos.exposed
 
 import dev.inmo.micro_utils.repos.CRUDRepo
+import kotlinx.coroutines.channels.BufferOverflow
 
 abstract class AbstractExposedCRUDRepo<ObjectType, IdType, InputValueType>(
     flowsChannelsSize: Int = 0,
-    tableName: String = ""
+    tableName: String = "",
+    replyCacheInFlows: Int = 0,
+    onBufferOverflowBehaviour: BufferOverflow = BufferOverflow.SUSPEND
 ) :
     AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
         flowsChannelsSize,
-        tableName
+        tableName,
+        replyCacheInFlows,
+        onBufferOverflowBehaviour
     ),
     ExposedCRUDRepo<ObjectType, IdType>,
     CRUDRepo<ObjectType, IdType, InputValueType>

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/AbstractExposedReadCRUDRepo.kt

@@ -35,14 +35,14 @@ abstract class AbstractExposedReadCRUDRepo<ObjectType, IdType>(
     }
     override suspend fun getById(id: IdType): ObjectType? {
         return transaction(db = database) {
-            select {
+            selectAll().where {
                 selectById(id)
             }.limit(1).firstOrNull() ?.asObject
         }
     }
 
     override suspend fun contains(id: IdType): Boolean = transaction(db = database) {
-        select { selectById(id) }.limit(1).any()
+        selectAll().where { selectById(id) }.limit(1).any()
     }
 
     override suspend fun getAll(): Map<IdType, ObjectType> = transaction(database) {

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/AbstractExposedWriteCRUDRepo.kt

@@ -2,6 +2,7 @@ package dev.inmo.micro_utils.repos.exposed
 
 import dev.inmo.micro_utils.repos.UpdatedValuePair
 import dev.inmo.micro_utils.repos.WriteCRUDRepo
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.statements.*
@@ -11,19 +12,26 @@ import java.util.Objects
 abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
     flowsChannelsSize: Int = 0,
     tableName: String = "",
-    replyCacheInFlows: Int = 0
+    replyCacheInFlows: Int = 0,
+    onBufferOverflowBehaviour: BufferOverflow = BufferOverflow.SUSPEND
 ) :
     AbstractExposedReadCRUDRepo<ObjectType, IdType>(tableName),
     ExposedCRUDRepo<ObjectType, IdType>,
     WriteCRUDRepo<ObjectType, IdType, InputValueType>
 {
-    protected val _newObjectsFlow = MutableSharedFlow<ObjectType>(replyCacheInFlows, flowsChannelsSize)
-    protected val _updatedObjectsFlow = MutableSharedFlow<ObjectType>(replyCacheInFlows, flowsChannelsSize)
-    protected val _deletedObjectsIdsFlow = MutableSharedFlow<IdType>(replyCacheInFlows, flowsChannelsSize)
+    protected open val _newObjectsFlow = MutableSharedFlow<ObjectType>(replyCacheInFlows, flowsChannelsSize, onBufferOverflowBehaviour)
+    protected open val _updatedObjectsFlow = MutableSharedFlow<ObjectType>(replyCacheInFlows, flowsChannelsSize, onBufferOverflowBehaviour)
+    protected open val _deletedObjectsIdsFlow = MutableSharedFlow<IdType>(replyCacheInFlows, flowsChannelsSize, onBufferOverflowBehaviour)
 
-    override val newObjectsFlow: Flow<ObjectType> = _newObjectsFlow.asSharedFlow()
-    override val updatedObjectsFlow: Flow<ObjectType> = _updatedObjectsFlow.asSharedFlow()
-    override val deletedObjectsIdsFlow: Flow<IdType> = _deletedObjectsIdsFlow.asSharedFlow()
+    override val newObjectsFlow: Flow<ObjectType> by lazy {
+        _newObjectsFlow.asSharedFlow()
+    }
+    override val updatedObjectsFlow: Flow<ObjectType> by lazy {
+        _updatedObjectsFlow.asSharedFlow()
+    }
+    override val deletedObjectsIdsFlow: Flow<IdType> by lazy {
+        _deletedObjectsIdsFlow.asSharedFlow()
+    }
 
     protected abstract fun InsertStatement<Number>.asObject(value: InputValueType): ObjectType
 
@@ -93,7 +101,7 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
         }.let {
             if (it > 0) {
                 transaction(db = database) {
-                    select {
+                    selectAll().where {
                         selectById(this, id)
                     }.limit(1).firstOrNull() ?.asObject
                 }
@@ -134,7 +142,7 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
                 ids
             } else {
                 ids.filter {
-                    select { selectById(it) }.limit(1).none()
+                    selectAll().where { selectById(it) }.limit(1).none()
                 }
             }
         }.forEach {

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/AbstractExposedKeyValueRepo.kt

@@ -65,7 +65,7 @@ abstract class AbstractExposedKeyValueRepo<Key, Value>(
     override suspend fun unsetWithValues(toUnset: List<Value>) {
         transaction(database) {
             toUnset.flatMap {
-                val keys = select { selectByValue(it) }.mapNotNull { it.asKey }
+                val keys = selectAll().where { selectByValue(it) }.mapNotNull { it.asKey }
                 deleteWhere { selectByIds(it, keys) }
                 keys
             }