@momo-kits/native-kits 0.112.1-beta.7 → 0.112.1-beta.8

package/compose/src/commonMain/kotlin/vn/momo/kits/components/HeaderRight.kt

@@ -27,7 +27,6 @@ import vn.momo.kits.application.ApplicationContext
 import vn.momo.kits.application.ComposeApi
 import vn.momo.kits.application.PlatformApi
 import vn.momo.kits.const.Colors
-import vn.momo.kits.utils.ModelConvertUtils
 
 data class HeaderRightData(
     val useOnBoarding: Boolean = false,
@@ -62,6 +61,10 @@ object Spacing {
     val S = 8.dp
     val XXS = 2.dp
 }
+object ComposeApiUtils {
+    fun parseParams(vararg params: Any) = ModelConvertUtils.encodeToJsonFromAny(params).toString()
+}
+
 
 @Composable
 fun HeaderRight(
@@ -93,7 +96,7 @@ fun ToolkitHeaderRight(headerRight: HeaderRightData? = null) {
             "icon" to context?.icon,
             "description" to context?.description
         )
-        val params = ModelConvertUtils.encodeToJsonFromAny(paramMap).toString()
+        val params = ComposeApiUtils.parseParams(paramMap)
         api?.request("showHelpCenter", params, { _ -> })
     }
 
@@ -113,7 +116,7 @@ fun ToolkitHeaderRight(headerRight: HeaderRightData? = null) {
             )
         )
 
-        val params = ModelConvertUtils.encodeToJsonFromAny(param).toString()
+        val params = ComposeApiUtils.parseParams(param)
         api?.request("showTools", params, { _ -> })
     }
 

package/compose/src/commonMain/kotlin/vn/momo/kits/utils/AnyConverter.kt

@@ -0,0 +1,86 @@
+package vn.momo.kits.utils
+
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonPrimitive
+
+internal fun Any?.forceToBoolean() = when (this) {
+    is Number -> this == 1
+    is Boolean -> this
+    is String -> this == "true" || this == "1"
+    else -> null
+}
+
+fun Any?.forceToString() = when (this) {
+    null -> this
+    is Number -> this.toLong().toString()
+    is String -> this
+    else -> this.toString()
+}
+
+internal fun Any?.forceToInt() = when (this) {
+    null -> this
+    is Number -> this.toInt()
+    is String -> this.toInt()
+    is Boolean -> if (this) 1 else 0
+    else -> null
+}
+
+internal fun Any?.forceToDouble() = when (this) {
+    null -> this
+    is Number -> this.toDouble()
+    is String -> this.toDouble()
+    else -> null
+}
+
+internal fun Any?.forceToLong() = when (this) {
+    null -> this
+    is Number -> this.toLong()
+    is String -> this.toLong()
+    else -> null
+}
+
+
+fun Any?.toJsonElement(): JsonElement {
+    return when (this) {
+        is Number -> JsonPrimitive(this)
+        is Boolean -> JsonPrimitive(this)
+        is String -> JsonPrimitive(this)
+        is Array<*> -> this.toJsonArray()
+        is List<*> -> this.toJsonArray()
+        is Map<*, *> -> this.toJsonObject()
+        is JsonElement -> this
+        else -> JsonNull
+    }
+}
+
+fun Any?.tryForceToBoolean() = try {
+    this.forceToBoolean()
+} catch (e: Exception) {
+    false
+}
+
+fun Any?.tryForceToString() = try {
+    this.forceToString()
+} catch (e: Exception) {
+    ""
+}
+
+fun Any?.tryForceToInt() = try {
+    this.forceToInt()
+} catch (e: Exception) {
+    0
+}
+
+fun Any?.tryForceToDouble() = try {
+    this.forceToDouble()
+} catch (e: Exception) {
+    0.0
+}
+
+fun Any?.tryForceToLong() = try {
+    this.forceToLong()
+} catch (e: Exception) {
+    0L
+}
+

package/compose/src/commonMain/kotlin/vn/momo/kits/utils/CollectionConverter.kt

@@ -0,0 +1,67 @@
+package vn.momo.kits.utils
+
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+
+fun Array<*>.toJsonArray(): JsonArray {
+    val array = mutableListOf<JsonElement>()
+    this.forEach { array.add(it.toJsonElement()) }
+    return JsonArray(array)
+}
+
+fun List<*>.toJsonArray(): JsonArray {
+    val array = mutableListOf<JsonElement>()
+    this.forEach { array.add(it.toJsonElement()) }
+    return JsonArray(array)
+}
+
+fun Map<*, *>.toJsonObject(): JsonObject {
+    val map = mutableMapOf<String, JsonElement>()
+    this.forEach {
+        if (it.key is String) {
+            map[it.key as String] = it.value.toJsonElement()
+        }
+    }
+    return JsonObject(map)
+}
+
+internal fun Collection<*>.toJsonElement(): JsonElement {
+    val list: MutableList<JsonElement> = mutableListOf()
+    this.forEach { value ->
+        when (value) {
+            null -> list.add(JsonNull)
+            is Map<*, *> -> list.add(value.toJsonElement())
+            is Collection<*> -> list.add(value.toJsonElement())
+            is Boolean -> list.add(JsonPrimitive(value))
+            is Number -> list.add(JsonPrimitive(value))
+            is String -> list.add(JsonPrimitive(value))
+            is Enum<*> -> list.add(JsonPrimitive(value.toString()))
+            is JsonPrimitive -> list.add(value)
+            else -> throw IllegalStateException("Can't serialize unknown collection type: $value")
+        }
+    }
+    return JsonArray(list)
+}
+
+// clear
+internal fun Map<*, *>.toJsonElement(): JsonElement {
+    val map: MutableMap<String, JsonElement> = mutableMapOf()
+    this.forEach { (key, value) ->
+        key as String
+        when (value) {
+            null -> map[key] = JsonNull
+            is Map<*, *> -> map[key] = value.toJsonElement()
+            is Collection<*> -> map[key] = value.toJsonElement()
+            is Boolean -> map[key] = JsonPrimitive(value)
+            is Number -> map[key] = JsonPrimitive(value)
+            is String -> map[key] = JsonPrimitive(value)
+            is Enum<*> -> map[key] = JsonPrimitive(value.toString())
+            is JsonPrimitive -> map[key] = value
+            else -> throw IllegalStateException("Can't serialize unknown type: $value")
+        }
+    }
+    return JsonObject(map)
+}

package/compose/src/commonMain/kotlin/vn/momo/kits/utils/JsonConverter.kt

@@ -0,0 +1,175 @@
+package vn.momo.kits.utils
+
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.floatOrNull
+import kotlinx.serialization.json.intOrNull
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.longOrNull
+
+fun emptyJsonObject() = JsonObject(mapOf())
+
+val JsonObject.Companion.EMPTY
+    get() = JsonObject(emptyMap())
+
+val JsonArray.Companion.EMPTY
+    get() = JsonArray(emptyList())
+
+fun JsonObject.tryToGetObject(key: String): JsonObject? {
+    return try {
+        this[key]?.toJsonElement()?.jsonObject
+    } catch (_: Exception) {
+        JsonObject.EMPTY
+    }
+}
+
+fun JsonObject.tryToGetArray(key: String): JsonArray? {
+    return try {
+        this[key]?.toJsonElement()?.jsonArray
+    } catch (_: Exception) {
+        JsonArray.EMPTY
+    }
+}
+
+fun JsonObject.tryToGetString(key: String): String {
+    return try {
+        this.getOrElse(key) { "" }.toJsonElement().jsonPrimitive.content
+    } catch (_: Exception) {
+        ""
+    }
+}
+
+fun JsonObject.tryToGetStringNullable(key: String): String? {
+    return try {
+        this.getOrElse(key) { null }.toJsonElement().jsonPrimitive.contentOrNull
+    } catch (_: Exception) {
+        null
+    }
+}
+
+fun JsonObject.tryToGetLong(key: String): Long? {
+    return try {
+        this.getOrElse(key) { "" }.toJsonElement().jsonPrimitive.longOrNull
+    } catch (_: Exception) {
+        null
+    }
+}
+
+fun JsonObject.tryToGetLong(key: String, default: Long = 0L): Long {
+    return try {
+        this.getOrElse(key) { default }.toJsonElement().jsonPrimitive.longOrNull ?: default
+    } catch (_: Exception) {
+        default
+    }
+}
+
+fun JsonObject.tryToGetDoubleNullable(key: String): Double? {
+    return try {
+        this.getOrElse(key) { "" }.toJsonElement().jsonPrimitive.doubleOrNull
+    } catch (_: Exception) {
+        null
+    }
+}
+
+fun JsonObject.tryToGetDouble(key: String, default: Double = 0.0): Double {
+    return try {
+        this.getOrElse(key) { default }.toJsonElement().jsonPrimitive.doubleOrNull ?: default
+    } catch (_: Exception) {
+        default
+    }
+}
+
+fun JsonObject.tryToGetBoolean(key: String): Boolean {
+    return try {
+        this[key]?.jsonPrimitive?.booleanOrNull ?: false
+    } catch (_: Exception) {
+        false
+    }
+}
+
+fun JsonObject.tryToGetBooleanNullable(key: String): Boolean? {
+    return try {
+        this[key]?.jsonPrimitive?.booleanOrNull
+    } catch (_: Exception) {
+        null
+    }
+}
+
+internal fun JsonElement.toPureMap(): Map<String, Any?> {
+    return (this as? JsonObject)?.toPureMap() ?: emptyMap()
+}
+
+fun JsonObject.toPureMap(): Map<String, Any?> {
+    val map: MutableMap<String, Any?> = mutableMapOf()
+    this.jsonObject.entries.forEach { (key, value) ->
+        when (value) {
+            is Map<*, *> -> map[key] = value.toPureMap()
+            is Collection<*> -> map[key] = value.toList().map { it.toJsonElement().toPureMap() }
+            is JsonPrimitive -> map[key] =
+                if (value.isString) value.content else value.intOrNull ?: value.doubleOrNull
+                ?: value.floatOrNull ?: value.booleanOrNull
+            is JsonNull -> map[key] = null
+            else -> throw IllegalStateException("Can't serialize unknown type: $value")
+        }
+    }
+    return map
+}
+
+fun JsonElement.tryToString(): String {
+    return try {
+        this.jsonPrimitive.content
+    } catch (_: Exception) {
+        ""
+    }
+}
+
+internal fun JsonElement.toCollection(): Collection<Any?> {
+    val list: MutableList<Any?> = mutableListOf()
+    (this as? JsonArray)?.forEach { value ->
+        when (value) {
+            is Map<*, *> -> list.add(value.toMap())
+            is Collection<*> -> list.add(value.toCollection())
+            is JsonPrimitive -> list.add(
+                if (value.isString) value.content else value.booleanOrNull ?: value.intOrNull
+                ?: value.longOrNull ?: value.doubleOrNull ?: value.floatOrNull
+            )
+
+            is JsonNull -> list.add(null)
+            else -> throw IllegalStateException("Can't serialize unknown type: $value")
+        }
+    }
+    return list
+}
+
+internal fun JsonElement.toMap(): Map<String, Any?> {
+    val map: MutableMap<String, Any?> = mutableMapOf()
+    (this as? JsonObject)?.entries?.forEach { (key, value) ->
+        when (value) {
+            is Map<*, *> -> map[key] = value.toMap()
+            is Collection<*> -> map[key] = value.toCollection()
+            is JsonPrimitive -> map[key] =
+                if (value.isString) value.content else value.booleanOrNull ?: value.intOrNull
+                ?: value.longOrNull ?: value.doubleOrNull ?: value.floatOrNull
+
+            is JsonNull -> map[key] = null
+            else -> throw IllegalStateException("Can't serialize unknown type: $value")
+        }
+    }
+    return map
+}
+
+fun JsonElement.tryForceToStringStringMap(): Map<String, String?>? = try {
+    this.toMap() as Map<String, String?>?
+} catch (e: Exception) {
+    null
+}
+
+

package/compose/src/commonMain/kotlin/vn/momo/kits/utils/{ModelConverter.kt → ModelConvertUtils.kt}

@@ -1,11 +1,15 @@
 package vn.momo.kits.utils
 
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.ListSerializer
+import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonNull
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonObject
 
 
 object ModelConvertUtils {
@@ -16,12 +20,51 @@ object ModelConvertUtils {
         classDiscriminator = discriminator
     }
 
+    fun handleJsonError(e: Throwable) {
+        e.printStackTrace()
+    }
+
+    fun <T> encodeToString(kSerializer: KSerializer<T>, obj: T): String? = try {
+        formatter.encodeToString(kSerializer, obj)
+    } catch (ex: Throwable) {
+        handleJsonError(ex)
+        null
+    }
+
+    fun <T> encodeToMap(kSerializer: KSerializer<T>, obj: T): Map<String, Any?>? {
+        val value = encodeToJson(kSerializer, obj)
+        return if (value == null) null
+        else jsonToMap(value)
+    }
+
+
+    fun <T> encodeToPureMap(kSerializer: KSerializer<T>, obj: T): Map<String, Any?> {
+        val jsonObject = encodeToJson(kSerializer, obj) as? JsonObject
+        return jsonObject?.toPureMap() ?: emptyMap()
+    }
+
+    fun <T> encodeToJson(kSerializer: KSerializer<T>, obj: T): JsonElement? = try {
+        formatter.encodeToJsonElement(kSerializer, obj)
+    } catch (ex: Throwable) {
+        handleJsonError(ex)
+        null
+    }
+
     fun encodeToJson(data: String?): JsonElement? = try {
         formatter.parseToJsonElement(data ?: "")
     } catch (e: Throwable) {
+        handleJsonError(e)
         null
     }
 
+    fun decodeToPureMap(string: String): Map<String, Any?> = try {
+        formatter.parseToJsonElement(string).jsonObject.toPureMap()
+    } catch (ex: Throwable) {
+        handleJsonError(ex)
+        emptyMap()
+    }
+
+
     fun encodeToJson(data: Collection<*>): JsonElement {
         val parsedData = mutableListOf<JsonElement>()
         data.forEach { value ->
@@ -79,4 +122,67 @@ object ModelConvertUtils {
     private fun encodeToJsonFromArray(data: Array<*>): JsonArray =
         JsonArray(data.filterNotNull().map { encodeToJsonFromAny(it) })
 
+    fun <T> decode(kSerializer: KSerializer<T>, obj: String): T? = try {
+        formatter.decodeFromString(kSerializer, obj)
+    } catch (ex: Throwable) {
+        handleJsonError(ex)
+        null
+    }
+
+    fun <T> decode(kSerializer: KSerializer<T>, obj: Map<String, Any?>): T? = try {
+        formatter.decodeFromJsonElement(kSerializer, obj.toJsonElement())
+    } catch (ex: Throwable) {
+        handleJsonError(ex)
+        null
+    }
+
+    inline fun <reified T> decode(data: String): T? = try {
+        formatter.decodeFromString(data)
+    } catch (e: Exception) {
+        handleJsonError(e)
+        null
+    }
+
+    fun decode(string: String): Map<String, Any?> = try {
+        jsonToMap(formatter.parseToJsonElement(string))
+    } catch (ex: Throwable) {
+        handleJsonError(ex)
+        emptyMap()
+    }
+
+    fun <T> decodeFromJson(deserializer: KSerializer<T>, element: JsonElement): T? = try {
+        formatter.decodeFromJsonElement(deserializer, element)
+    } catch (e: Exception) {
+        handleJsonError(e)
+        null
+    }
+
+    fun jsonToMap(element: JsonElement): Map<String, Any?> = element.jsonObject.toMap()
+
+
+    fun <T> decodeToList(kSerializer: KSerializer<T>, jsonString: String): List<T> {
+        return try {
+            formatter.decodeFromString(ListSerializer(kSerializer), jsonString)
+        } catch (exception: Throwable) {
+            handleJsonError(exception)
+            emptyList()
+        }
+    }
+
+    inline fun <reified T> encodeToString(value: T): String? = try {
+        formatter.encodeToString(value)
+    } catch (e: Exception) {
+        handleJsonError(e)
+        null
+    }
+
+    inline fun <reified T> decodeNonNull(data: String): T =
+        try {
+            formatter.decodeFromString(data)
+        } catch (ex: Exception) {
+            ex.printStackTrace()
+            formatter.decodeFromString("{}")
+        }
+
+
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.112.1-beta.7",
+  "version": "0.112.1-beta.8",
   "private": false,
   "dependencies": {},
   "devDependencies": {},