@momo-kits/native-kits 0.112.1-beta.1 → 0.112.1-beta.2

package/compose/src/commonMain/kotlin/vn/momo/kits/application/Components.kt

@@ -242,10 +242,12 @@ fun Header(
                     }
                 }
 
-                Box(Modifier.graphicsLayer {
-                    alpha = if (animatedHeader !== null) opacity ?: 1f else 1f
-                }) {
-                    headerRight?.invoke()
+                if (inputSearchProps == null) {
+                    Box(Modifier.graphicsLayer {
+                        alpha = if (animatedHeader !== null) opacity ?: 1f else 1f
+                    }) {
+                        headerRight?.invoke()
+                    }
                 }
             }
 

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

@@ -23,6 +23,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
+import vn.momo.compose.utils.datamapping.ModelConvertUtils
 import vn.momo.kits.application.ComposeApi
 import vn.momo.kits.application.PlatformApi
 import vn.momo.kits.const.Colors
@@ -81,14 +82,29 @@ fun ToolkitHeaderRight(headerRight: HeaderRightData? = null) {
     fun onPressShortcut() {
         isFavorite = !isFavorite
     }
-    fun onPressHelpCenter(){
-        api?.request("showHelpCenter", "")
+
+    fun onPressHelpCenter() {
+        val params = ModelConvertUtils.encodeToJsonFromAny(
+            arrayOf<Any>(
+                mapOf("title" to "title"),
+                mapOf("title" to "title")
+            )
+        ).toString()
+        api?.request("showHelpCenter", params, {})
     }
-    fun onPressClose(){
+
+    fun onPressClose() {
         api?.request("dismiss", "")
     }
+
     fun onPressMore() {
-        api?.request("showTools", "")
+        val params = ModelConvertUtils.encodeToJsonFromAny(
+            arrayOf(
+                headerRight?.tools,
+                emptyMap<Any, Any>()
+            )
+        ).toString()
+        api?.request("showTools", params, {})
     }
 
     fun getNavigationButtonConfig(

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

@@ -0,0 +1,175 @@
+package vn.momo.compose.utils.datamapping
+
+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

@@ -0,0 +1,82 @@
+package vn.momo.compose.utils.datamapping
+
+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
+
+
+object ModelConvertUtils {
+    private const val discriminator = "momoClassDiscriminator"
+    val formatter = Json {
+        encodeDefaults = true
+        ignoreUnknownKeys = true
+        classDiscriminator = discriminator
+    }
+
+    fun encodeToJson(data: String?): JsonElement? = try {
+        formatter.parseToJsonElement(data ?: "")
+    } catch (e: Throwable) {
+        null
+    }
+
+    fun encodeToJson(data: Collection<*>): JsonElement {
+        val parsedData = mutableListOf<JsonElement>()
+        data.forEach { value ->
+            when (value) {
+                is Map<*, *> -> parsedData.add(encodeToJson(value))
+                is Collection<*> -> parsedData.add(encodeToJson(value))
+                is Number -> parsedData.add(JsonPrimitive(value))
+                is Boolean -> parsedData.add(JsonPrimitive(value))
+                is String -> parsedData.add(JsonPrimitive(value))
+                is Enum<*> -> encodeToJson(value.name)?.let { parsedData.add(it) }
+                is JsonPrimitive -> parsedData.add(value)
+                is JsonElement -> parsedData.add(value)
+                null -> parsedData.add(JsonNull)
+                else -> throw IllegalStateException("Can't serialize unknown collection type: $value")
+            }
+        }
+        return JsonArray(parsedData)
+    }
+
+    fun encodeToJson(data: Map<*, *>): JsonElement {
+        val parsedData = mutableMapOf<String, JsonElement>()
+        data.forEach { (key, value) ->
+            if (key is String && value != null) {
+                when (value) {
+                    is Map<*, *> -> parsedData[key] = encodeToJson(value)
+                    is Collection<*> -> parsedData[key] = encodeToJson(value)
+                    is Number -> parsedData[key] = JsonPrimitive(value)
+                    is Boolean -> parsedData[key] = JsonPrimitive(value)
+                    is String -> parsedData[key] = JsonPrimitive(value)
+                    is Enum<*> -> encodeToJson(value.name)?.let { parsedData[key] = it }
+                    is Array<*> -> parsedData[key] = encodeToJsonFromArray(value)
+                    is JsonPrimitive -> parsedData[key] = value
+                    is JsonElement -> parsedData[key] = value
+                    else -> throw IllegalStateException("Can't serialize unknown type:  $value")
+                }
+            }
+        }
+        return JsonObject(parsedData)
+    }
+
+    fun encodeToJsonFromAny(data: Any): JsonElement {
+        return when (data) {
+            is Map<*, *> -> encodeToJson(data)
+            is Collection<*> -> encodeToJson(data)
+            is Number -> JsonPrimitive(data)
+            is Boolean -> JsonPrimitive(data)
+            is String -> JsonPrimitive(data)
+            is Enum<*> -> encodeToJson(data.name) ?: JsonNull
+            is Array<*> -> encodeToJsonFromArray(data)
+            is JsonElement -> data
+            else -> JsonNull
+        }
+    }
+
+    private fun encodeToJsonFromArray(data: Array<*>): JsonArray =
+        JsonArray(data.filterNotNull().map { encodeToJsonFromAny(it) })
+
+}

package/package.json

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