fixes

0.18.1

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.18.2
+
+* `Startup`:
+    * Now internal `Json` is fully customizable
+
 ## 0.18.1
 
 * `Common`:

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

@@ -200,20 +200,18 @@ inline fun <T> Iterable<T>.calculateStrictDiff(
 ) = calculateDiff(other, strictComparison = true)
 
 /**
- * This method call [calculateDiff] with strict mode [strictComparison] and then apply differences to [this]
+ * Applies [diff] to [this] [MutableList]
- * mutable list
  */
 fun <T> MutableList<T>.applyDiff(
-    source: Iterable<T>,
+    diff: Diff<T>
-    strictComparison: Boolean = false
+) {
-): Diff<T> = calculateDiff(source, strictComparison).also {
+    for (i in diff.removed.indices.sortedDescending()) {
-    for (i in it.removed.indices.sortedDescending()) {
+        removeAt(diff.removed[i].index)
-        removeAt(it.removed[i].index)
     }
-    it.added.forEach { (i, t) ->
+    diff.added.forEach { (i, t) ->
         add(i, t)
     }
-    it.replaced.forEach { (_, new) ->
+    diff.replaced.forEach { (_, new) ->
         set(new.index, new.value)
     }
 }
@@ -222,17 +220,30 @@ fun <T> MutableList<T>.applyDiff(
  * This method call [calculateDiff] with strict mode [strictComparison] and then apply differences to [this]
  * mutable list
  */
+fun <T> MutableList<T>.applyDiff(
+    source: Iterable<T>,
+    strictComparison: Boolean = false
+): Diff<T> = calculateDiff(source, strictComparison).also {
+    applyDiff(it)
+}
+
+/**
+ * This method call [calculateDiff] and then apply differences to [this]
+ * mutable list
+ */
 fun <T> MutableList<T>.applyDiff(
     source: Iterable<T>,
     comparisonFun: (T?, T?) -> Boolean
 ): Diff<T> = calculateDiff(source, comparisonFun).also {
-    for (i in it.removed.indices.sortedDescending()) {
+    applyDiff(it)
-        removeAt(it.removed[i].index)
-    }
-    it.added.forEach { (i, t) ->
-        add(i, t)
-    }
-    it.replaced.forEach { (_, new) ->
-        set(new.index, new.value)
-    }
 }
+
+/**
+ * Reverse [this] [Diff]. Result will contain [Diff.added] on [Diff.removed] (and vice-verse), all the
+ * [Diff.replaced] values will be reversed too
+ */
+fun <T> Diff<T>.reversed() = Diff(
+    removed = added,
+    replaced = replaced.map { it.second to it.first },
+    added = removed
+)

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

@@ -76,15 +76,12 @@ fun <K, V> Map<K, V>.diff(
 )
 
 /**
- * Will apply changes with [other] map into [this] one
+ * Will apply [mapDiff] to [this] [MutableMap]
- *
- * @param compareFun Will be used to determine changed values
  */
 fun <K, V> MutableMap<K, V>.applyDiff(
-    from: Map<K, V>,
+    mapDiff: MapDiff<K, V>
-    compareFun: (K, V, V) -> Boolean = { _, first, second -> first == second }
 ) {
-    diff(from, compareFun).apply {
+    mapDiff.apply {
         removed.keys.forEach { remove(it) }
         changed.forEach { (k, oldNew) ->
             put(k, oldNew.second)
@@ -96,15 +93,43 @@ fun <K, V> MutableMap<K, V>.applyDiff(
 }
 
 /**
- * Will apply changes with [other] map into [this] one
+ * Will apply changes with [from] map into [this] one
+ *
+ * @param compareFun Will be used to determine changed values
+ *
+ * @return [MapDiff] applied to [this] [MutableMap]
+ */
+fun <K, V> MutableMap<K, V>.applyDiff(
+    from: Map<K, V>,
+    compareFun: (K, V, V) -> Boolean
+): MapDiff<K, V> {
+    return diff(from, compareFun).also {
+        applyDiff(it)
+    }
+}
+
+/**
+ * Will apply changes with [from] map into [this] one
  *
  * @param strictComparison If true, will use strict (===) comparison for the values' comparison. Otherwise, standard
  * `equals` will be used
+ *
+ * @return [MapDiff] applied to [this] [MutableMap]
  */
 fun <K, V> MutableMap<K, V>.applyDiff(
-    other: Map<K, V>,
+    from: Map<K, V>,
     strictComparison: Boolean = false
-) = applyDiff(
+): MapDiff<K, V> = applyDiff(
-    other,
+    from,
     compareFun = createCompareFun(strictComparison)
 )
+
+/**
+ * Reverse [this] [MapDiff]. Result will contain [MapDiff.added] on [MapDiff.removed] (and vice-verse), all the
+ * [MapDiff.changed] values will be reversed too
+ */
+fun <K, V> MapDiff<K, V>.reversed(): MapDiff<K, V> = MapDiff(
+    removed = added,
+    changed = changed.mapValues { (_, oldNew) -> oldNew.second to oldNew.first },
+    added = removed
+)

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.18.1
+version=0.18.2
-android_code_version=192
+android_code_version=193

startup/launcher/build.gradle

@@ -2,6 +2,7 @@ plugins {
     id "org.jetbrains.kotlin.multiplatform"
     id "org.jetbrains.kotlin.plugin.serialization"
     id "application"
+    id "com.google.devtools.ksp"
 }
 
 apply from: "$mppJvmJsLinuxMingwProjectPresetPath"
@@ -11,6 +12,7 @@ kotlin {
         commonMain {
             dependencies {
                 api internalProject("micro_utils.startup.plugin")
+                api internalProject("micro_utils.koin")
             }
         }
         commonTest {
@@ -29,3 +31,10 @@ java {
     sourceCompatibility = JavaVersion.VERSION_1_8
     targetCompatibility = JavaVersion.VERSION_1_8
 }
+
+dependencies {
+    add("kspCommonMainMetadata", project(":micro_utils.koin.generator"))
+}
+
+ksp {
+}

startup/launcher/src/commonMain/kotlin/GeneratedDefinitionsStartLauncherPlugin.kt

@@ -0,0 +1,38 @@
+// THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
+// TO REGENERATE IT JUST DELETE FILE
+// ORIGINAL FILE: StartLauncherPlugin.kt
+package dev.inmo.micro_utils.startup.launcher
+
+import kotlin.Boolean
+import kotlinx.serialization.json.Json
+import org.koin.core.Koin
+import org.koin.core.definition.Definition
+import org.koin.core.definition.KoinDefinition
+import org.koin.core.module.Module
+import org.koin.core.qualifier.named
+import org.koin.core.scope.Scope
+
+/**
+ * @return Definition by key "baseJsonProvider"
+ */
+public val Scope.baseJsonProvider: Json?
+  get() = getOrNull(named("baseJsonProvider"))
+
+/**
+ * @return Definition by key "baseJsonProvider"
+ */
+public val Koin.baseJsonProvider: Json?
+  get() = getOrNull(named("baseJsonProvider"))
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.single] and key "baseJsonProvider"
+ */
+public fun Module.baseJsonProviderSingle(createdAtStart: Boolean = false, definition: Definition<Json>):
+    KoinDefinition<Json> = single(named("baseJsonProvider"), createdAtStart = createdAtStart, definition
+    = definition)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.factory] and key "baseJsonProvider"
+ */
+public fun Module.baseJsonProviderFactory(definition: Definition<Json>): KoinDefinition<Json> =
+    factory(named("baseJsonProvider"), definition = definition)

startup/launcher/src/commonMain/kotlin/StartLauncherPlugin.kt

@@ -1,9 +1,11 @@
+@file:GenerateKoinDefinition("baseJsonProvider", Json::class)
 package dev.inmo.micro_utils.startup.launcher
 
 import dev.inmo.kslog.common.i
 import dev.inmo.kslog.common.taggedLogger
 import dev.inmo.kslog.common.w
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
+import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition
 import dev.inmo.micro_utils.startup.launcher.StartLauncherPlugin.setupDI
 import dev.inmo.micro_utils.startup.launcher.StartLauncherPlugin.startPlugin
 import dev.inmo.micro_utils.startup.plugin.StartPlugin
@@ -13,9 +15,10 @@ import kotlinx.coroutines.joinAll
 import kotlinx.coroutines.launch
 import kotlinx.serialization.SerialFormat
 import kotlinx.serialization.StringFormat
+import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.decodeFromJsonElement
 import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.modules.SerializersModule
 import org.koin.core.Koin
 import org.koin.core.KoinApplication
 import org.koin.core.context.startKoin
@@ -35,7 +38,20 @@ object StartLauncherPlugin : StartPlugin {
         single { rawJsonObject }
         single { config }
         single { CoroutineScope(Dispatchers.Default) }
-        single { defaultJson } binds arrayOf(StringFormat::class, SerialFormat::class)
+        single {
+            val serializersModules = getAll<SerializersModule>().distinct()
+            val baseJson = baseJsonProvider ?: defaultJson
+            if (serializersModules.isEmpty()) {
+                baseJson
+            } else {
+                Json(baseJson) {
+                    serializersModule = SerializersModule {
+                        include(baseJson.serializersModule)
+                        serializersModules.forEach { include(it) }
+                    }
+                }
+            }
+        } binds arrayOf(StringFormat::class, SerialFormat::class)
 
         includes(
             config.plugins.mapNotNull {