update changelog

Update ksp to v1.9.22-1.0.16

CHANGELOG.md

@@ -1,7 +1,22 @@
 # Changelog
 
+## 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`

gradle.properties

@@ -15,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.20.23
+version=0.20.24
-android_code_version=229
+android_code_version=230

gradle/libs.versions.toml

@@ -10,16 +10,16 @@ jb-compose = "1.5.11"
 jb-exposed = "0.45.0"
 jb-dokka = "1.9.10"
 
-korlibs = "4.0.10"
+korlibs = "5.3.0"
 uuid = "0.8.2"
 
 ktor = "2.3.7"
 
 gh-release = "2.4.1"
 
-koin = "3.5.0"
+koin = "3.5.3"
 
-okio = "3.6.0"
+okio = "3.7.0"
 
 ksp = "1.9.21-1.0.16"
 kotlin-poet = "1.15.3"
@@ -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" }
+klock = { module = "com.soywiz.korge:korlibs-time", version.ref = "korlibs" }
-krypto = { module = "com.soywiz.korlibs.krypto:krypto", 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" }
 

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 IetfLang.toJavaLocale(): Locale = Locale.forLanguageTag(code)
-fun IetfLanguageCode?.toJavaLocaleOrDefault(): Locale = this ?.toJavaLocale() ?: Locale.getDefault()
+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()

resources/src/androidMain/kotlin/StringResourceContextGetter.kt

@@ -4,7 +4,6 @@ import android.content.Context
 import android.content.res.Configuration
 import android.content.res.Resources
 import android.os.Build
-import dev.inmo.micro_utils.language_codes.toIetfLanguageCode
 
 fun StringResource.translation(configuration: Configuration): String = translation(
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

resources/src/commonMain/kotlin/StringResource.kt

@@ -1,6 +1,6 @@
 package dev.inmo.micro_utils.strings
 
-import dev.inmo.micro_utils.language_codes.IetfLanguageCode
+import dev.inmo.micro_utils.language_codes.IetfLang
 
 /**
  * Use this class as a type of your strings object fields. For example:
@@ -17,28 +17,29 @@ import dev.inmo.micro_utils.language_codes.IetfLanguageCode
  */
 class StringResource(
     val default: String,
-    val map: Map<IetfLanguageCode, Lazy<String>>
+    val map: Map<IetfLang, Lazy<String>>
 ) {
     class Builder(
         var default: String
     ) {
-        private val map = mutableMapOf<IetfLanguageCode, Lazy<String>>()
+        private val map = mutableMapOf<IetfLang, Lazy<String>>()
 
-        infix fun IetfLanguageCode.variant(value: Lazy<String>) {
+        infix fun IetfLang.variant(value: Lazy<String>) {
             map[this] = value
         }
-        infix fun IetfLanguageCode.variant(value: () -> String) = this variant lazy(value)
+
-        infix fun IetfLanguageCode.variant(value: String) = this variant lazyOf(value)
+        infix fun IetfLang.variant(value: () -> String) = this variant lazy(value)
+        infix fun IetfLang.variant(value: String) = this variant lazyOf(value)
 
 
-        infix fun String.variant(value: Lazy<String>) = IetfLanguageCode(this) variant value
+        infix fun String.variant(value: Lazy<String>) = IetfLang(this) variant value
-        infix fun String.variant(value: () -> String) = IetfLanguageCode(this) variant lazy(value)
+        infix fun String.variant(value: () -> String) = IetfLang(this) variant lazy(value)
         infix fun String.variant(value: String) = this variant lazyOf(value)
 
         fun build() = StringResource(default, map.toMap())
     }
 
-    fun translation(languageCode: IetfLanguageCode): String {
+    fun translation(languageCode: IetfLang): String {
         map[languageCode] ?.let { return it.value }
 
         return languageCode.parentLang ?.let {

resources/src/jvmMain/kotlin/StringResourceLocaleGetter.kt

@@ -1,10 +1,10 @@
 package dev.inmo.micro_utils.strings
 
-import dev.inmo.micro_utils.language_codes.toIetfLanguageCode
+import dev.inmo.micro_utils.language_codes.toIetfLang
 import java.util.Locale
 
 fun StringResource.translation(locale: Locale = Locale.getDefault()): String {
-    return translation(locale.toIetfLanguageCode())
+    return translation(locale.toIetfLang())
 }
 
 fun Locale.translation(resource: StringResource): String = resource.translation(this)

serialization/mapper/src/commonMain/kotlin/MapperDeserializationStrategy.kt

@@ -16,11 +16,16 @@ import kotlinx.serialization.encoding.Encoder
  */
 open class MapperDeserializationStrategy<I, O>(
     private val base: DeserializationStrategy<I>,
-    private val deserialize: (I) -> O
+    private val deserialize: (Decoder, I) -> O
 ) : DeserializationStrategy<O> {
     override val descriptor: SerialDescriptor = base.descriptor
 
+    constructor(
+        base: DeserializationStrategy<I>,
+        deserialize: (I) -> O
+    ) : this(base, { _, i -> deserialize(i) })
+
     override fun deserialize(decoder: Decoder): O {
-        return deserialize(base.deserialize(decoder))
+        return deserialize(decoder, base.deserialize(decoder))
     }
 }

serialization/mapper/src/commonMain/kotlin/MapperSerializationStrategy.kt

@@ -1,9 +1,7 @@
 package dev.inmo.micro_utils.serialization.mapper
 
-import kotlinx.serialization.KSerializer
 import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 
 /**
@@ -11,15 +9,20 @@ import kotlinx.serialization.encoding.Encoder
  * serialization
  *
  * @param base Serializer for [I]
- * @param serialize Will be used in [serialize] method to convert incoming [O] to [I] and serialize with [base]
+ * @param internalSerialize Will be used in [internalSerialize] method to convert incoming [O] to [I] and serialize with [base]
  */
 open class MapperSerializationStrategy<I, O>(
     private val base: SerializationStrategy<I>,
-    private val serialize: (O) -> I
+    private val internalSerialize: (Encoder, O) -> I
 ) : SerializationStrategy<O> {
     override val descriptor: SerialDescriptor = base.descriptor
 
+    constructor(
+        base: SerializationStrategy<I>,
+        serialize: (O) -> I
+    ) : this(base, { _, o -> serialize(o) })
+
     override fun serialize(encoder: Encoder, value: O) {
-        base.serialize(encoder, serialize(value))
+        base.serialize(encoder, internalSerialize(encoder, value))
     }
 }

serialization/mapper/src/commonMain/kotlin/MapperSerializer.kt

@@ -1,6 +1,8 @@
 package dev.inmo.micro_utils.serialization.mapper
 
+import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
@@ -15,16 +17,28 @@ import kotlinx.serialization.encoding.Encoder
  */
 open class MapperSerializer<I, O>(
     private val base: KSerializer<I>,
-    private val serialize: (O) -> I,
+    private val serialize: (Encoder, O) -> I,
-    private val deserialize: (I) -> O
+    private val deserialize: (Decoder, I) -> O
-) : KSerializer<O> {
+) : KSerializer<O>,
+    DeserializationStrategy<O> by MapperDeserializationStrategy<I, O>(base, deserialize),
+    SerializationStrategy<O> by MapperSerializationStrategy<I, O>(base, serialize) {
     override val descriptor: SerialDescriptor = base.descriptor
 
-    override fun deserialize(decoder: Decoder): O {
+    constructor(
-        return deserialize(base.deserialize(decoder))
+        base: KSerializer<I>,
-    }
+        serialize: (O) -> I,
+        deserialize: (I) -> O
+    ) : this(base, { _, o -> serialize(o) }, { _, i -> deserialize(i) })
 
-    override fun serialize(encoder: Encoder, value: O) {
+    constructor(
-        base.serialize(encoder, serialize(value))
+        base: KSerializer<I>,
-    }
+        serialize: (Encoder, O) -> I,
+        deserialize: (I) -> O
+    ) : this(base, serialize, { _, i -> deserialize(i) })
+
+    constructor(
+        base: KSerializer<I>,
+        serialize: (O) -> I,
+        deserialize: (Decoder, I) -> O
+    ) : this(base, { _, o -> serialize(o) }, deserialize)
 }