@momo-kits/native-kits 0.125.1-securityCustom.0 → 0.127.0-rc.1

package/build/kotlin/commonizedNativeDistributionLocation.txt

@@ -0,0 +1 @@
+/Users/huynhdung/.konan/kotlin-native-prebuilt-macos-aarch64-2.1.0/klib/commonized/2.1.0

package/compose/build/generated/compose/resourceGenerator/kotlin/androidMainResourceCollectors/vn/momo/uikits/resources/ActualResourceCollectors.kt

@@ -0,0 +1,49 @@
+@file:OptIn(org.jetbrains.compose.resources.InternalResourceApi::class)
+
+package vn.momo.uikits.resources
+
+import kotlin.OptIn
+import kotlin.String
+import kotlin.collections.Map
+import org.jetbrains.compose.resources.DrawableResource
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import org.jetbrains.compose.resources.FontResource
+import org.jetbrains.compose.resources.PluralStringResource
+import org.jetbrains.compose.resources.StringArrayResource
+import org.jetbrains.compose.resources.StringResource
+
+@ExperimentalResourceApi
+public actual val Res.allDrawableResources: Map<String, DrawableResource> by lazy {
+  val map = mutableMapOf<String, DrawableResource>()
+  return@lazy map
+}
+
+
+@ExperimentalResourceApi
+public actual val Res.allStringResources: Map<String, StringResource> by lazy {
+  val map = mutableMapOf<String, StringResource>()
+  return@lazy map
+}
+
+
+@ExperimentalResourceApi
+public actual val Res.allStringArrayResources: Map<String, StringArrayResource> by lazy {
+  val map = mutableMapOf<String, StringArrayResource>()
+  return@lazy map
+}
+
+
+@ExperimentalResourceApi
+public actual val Res.allPluralStringResources: Map<String, PluralStringResource> by lazy {
+  val map = mutableMapOf<String, PluralStringResource>()
+  return@lazy map
+}
+
+
+@ExperimentalResourceApi
+public actual val Res.allFontResources: Map<String, FontResource> by lazy {
+  val map = mutableMapOf<String, FontResource>()
+  _collectCommonMainFont0Resources(map)
+  return@lazy map
+}
+

package/compose/build/generated/compose/resourceGenerator/kotlin/commonMainResourceAccessors/vn/momo/uikits/resources/Font0.commonMain.kt

@@ -0,0 +1,187 @@
+@file:OptIn(org.jetbrains.compose.resources.InternalResourceApi::class)
+
+package vn.momo.uikits.resources
+
+import kotlin.OptIn
+import kotlin.String
+import kotlin.collections.MutableMap
+import org.jetbrains.compose.resources.FontResource
+import org.jetbrains.compose.resources.InternalResourceApi
+
+private object CommonMainFont0 {
+  public val momosignature: FontResource by 
+      lazy { init_momosignature() }
+
+  public val momotrustdisplay: FontResource by 
+      lazy { init_momotrustdisplay() }
+
+  public val sfprotext_black: FontResource by 
+      lazy { init_sfprotext_black() }
+
+  public val sfprotext_bold: FontResource by 
+      lazy { init_sfprotext_bold() }
+
+  public val sfprotext_heavy: FontResource by 
+      lazy { init_sfprotext_heavy() }
+
+  public val sfprotext_light: FontResource by 
+      lazy { init_sfprotext_light() }
+
+  public val sfprotext_medium: FontResource by 
+      lazy { init_sfprotext_medium() }
+
+  public val sfprotext_regular: FontResource by 
+      lazy { init_sfprotext_regular() }
+
+  public val sfprotext_semibold: FontResource by 
+      lazy { init_sfprotext_semibold() }
+
+  public val sfprotext_thin: FontResource by 
+      lazy { init_sfprotext_thin() }
+
+  public val sfprotext_ultralight: FontResource by 
+      lazy { init_sfprotext_ultralight() }
+}
+
+@InternalResourceApi
+internal fun _collectCommonMainFont0Resources(map: MutableMap<String, FontResource>) {
+  map.put("momosignature", CommonMainFont0.momosignature)
+  map.put("momotrustdisplay", CommonMainFont0.momotrustdisplay)
+  map.put("sfprotext_black", CommonMainFont0.sfprotext_black)
+  map.put("sfprotext_bold", CommonMainFont0.sfprotext_bold)
+  map.put("sfprotext_heavy", CommonMainFont0.sfprotext_heavy)
+  map.put("sfprotext_light", CommonMainFont0.sfprotext_light)
+  map.put("sfprotext_medium", CommonMainFont0.sfprotext_medium)
+  map.put("sfprotext_regular", CommonMainFont0.sfprotext_regular)
+  map.put("sfprotext_semibold", CommonMainFont0.sfprotext_semibold)
+  map.put("sfprotext_thin", CommonMainFont0.sfprotext_thin)
+  map.put("sfprotext_ultralight", CommonMainFont0.sfprotext_ultralight)
+}
+
+public val Res.font.momosignature: FontResource
+  get() = CommonMainFont0.momosignature
+
+private fun init_momosignature(): FontResource = org.jetbrains.compose.resources.FontResource(
+  "font:momosignature",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/momosignature.otf", -1, -1),
+    )
+)
+
+public val Res.font.momotrustdisplay: FontResource
+  get() = CommonMainFont0.momotrustdisplay
+
+private fun init_momotrustdisplay(): FontResource = org.jetbrains.compose.resources.FontResource(
+  "font:momotrustdisplay",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/momotrustdisplay.otf", -1, -1),
+    )
+)
+
+public val Res.font.sfprotext_black: FontResource
+  get() = CommonMainFont0.sfprotext_black
+
+private fun init_sfprotext_black(): FontResource = org.jetbrains.compose.resources.FontResource(
+  "font:sfprotext_black",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_black.otf", -1, -1),
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_black.ttf", -1, -1),
+    )
+)
+
+public val Res.font.sfprotext_bold: FontResource
+  get() = CommonMainFont0.sfprotext_bold
+
+private fun init_sfprotext_bold(): FontResource = org.jetbrains.compose.resources.FontResource(
+  "font:sfprotext_bold",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_bold.ttf", -1, -1),
+    )
+)
+
+public val Res.font.sfprotext_heavy: FontResource
+  get() = CommonMainFont0.sfprotext_heavy
+
+private fun init_sfprotext_heavy(): FontResource = org.jetbrains.compose.resources.FontResource(
+  "font:sfprotext_heavy",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_heavy.ttf", -1, -1),
+    )
+)
+
+public val Res.font.sfprotext_light: FontResource
+  get() = CommonMainFont0.sfprotext_light
+
+private fun init_sfprotext_light(): FontResource = org.jetbrains.compose.resources.FontResource(
+  "font:sfprotext_light",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_light.ttf", -1, -1),
+    )
+)
+
+public val Res.font.sfprotext_medium: FontResource
+  get() = CommonMainFont0.sfprotext_medium
+
+private fun init_sfprotext_medium(): FontResource = org.jetbrains.compose.resources.FontResource(
+  "font:sfprotext_medium",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_medium.ttf", -1, -1),
+    )
+)
+
+public val Res.font.sfprotext_regular: FontResource
+  get() = CommonMainFont0.sfprotext_regular
+
+private fun init_sfprotext_regular(): FontResource = org.jetbrains.compose.resources.FontResource(
+  "font:sfprotext_regular",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_regular.ttf", -1, -1),
+    )
+)
+
+public val Res.font.sfprotext_semibold: FontResource
+  get() = CommonMainFont0.sfprotext_semibold
+
+private fun init_sfprotext_semibold(): FontResource = org.jetbrains.compose.resources.FontResource(
+  "font:sfprotext_semibold",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_semibold.ttf", -1, -1),
+    )
+)
+
+public val Res.font.sfprotext_thin: FontResource
+  get() = CommonMainFont0.sfprotext_thin
+
+private fun init_sfprotext_thin(): FontResource = org.jetbrains.compose.resources.FontResource(
+  "font:sfprotext_thin",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_thin.otf", -1, -1),
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_thin.ttf", -1, -1),
+    )
+)
+
+public val Res.font.sfprotext_ultralight: FontResource
+  get() = CommonMainFont0.sfprotext_ultralight
+
+private fun init_sfprotext_ultralight(): FontResource =
+    org.jetbrains.compose.resources.FontResource(
+  "font:sfprotext_ultralight",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_ultralight.otf", -1, -1),
+      org.jetbrains.compose.resources.ResourceItem(setOf(),
+    "composeResources/vn.momo.uikits.resources/font/sfprotext_ultralight.ttf", -1, -1),
+    )
+)

package/compose/build/generated/compose/resourceGenerator/kotlin/commonMainResourceCollectors/vn/momo/uikits/resources/ExpectResourceCollectors.kt

@@ -0,0 +1,25 @@
+package vn.momo.uikits.resources
+
+import kotlin.String
+import kotlin.collections.Map
+import org.jetbrains.compose.resources.DrawableResource
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import org.jetbrains.compose.resources.FontResource
+import org.jetbrains.compose.resources.PluralStringResource
+import org.jetbrains.compose.resources.StringArrayResource
+import org.jetbrains.compose.resources.StringResource
+
+@ExperimentalResourceApi
+public expect val Res.allDrawableResources: Map<String, DrawableResource>
+
+@ExperimentalResourceApi
+public expect val Res.allStringResources: Map<String, StringResource>
+
+@ExperimentalResourceApi
+public expect val Res.allStringArrayResources: Map<String, StringArrayResource>
+
+@ExperimentalResourceApi
+public expect val Res.allPluralStringResources: Map<String, PluralStringResource>
+
+@ExperimentalResourceApi
+public expect val Res.allFontResources: Map<String, FontResource>

package/compose/build/generated/compose/resourceGenerator/kotlin/commonResClass/vn/momo/uikits/resources/Res.kt

@@ -0,0 +1,49 @@
+@file:OptIn(
+  org.jetbrains.compose.resources.InternalResourceApi::class,
+  org.jetbrains.compose.resources.ExperimentalResourceApi::class,
+)
+
+package vn.momo.uikits.resources
+
+import kotlin.ByteArray
+import kotlin.OptIn
+import kotlin.String
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import org.jetbrains.compose.resources.getResourceUri
+import org.jetbrains.compose.resources.readResourceBytes
+
+public object Res {
+  /**
+   * Reads the content of the resource file at the specified path and returns it as a byte array.
+   *
+   * Example: `val bytes = Res.readBytes("files/key.bin")`
+   *
+   * @param path The path of the file to read in the compose resource's directory.
+   * @return The content of the file as a byte array.
+   */
+  @ExperimentalResourceApi
+  public suspend fun readBytes(path: String): ByteArray =
+      readResourceBytes("composeResources/vn.momo.uikits.resources/" + path)
+
+  /**
+   * Returns the URI string of the resource file at the specified path.
+   *
+   * Example: `val uri = Res.getUri("files/key.bin")`
+   *
+   * @param path The path of the file in the compose resource's directory.
+   * @return The URI string of the file.
+   */
+  @ExperimentalResourceApi
+  public fun getUri(path: String): String =
+      getResourceUri("composeResources/vn.momo.uikits.resources/" + path)
+
+  public object drawable
+
+  public object string
+
+  public object array
+
+  public object plurals
+
+  public object font
+}

package/compose/build/generated/compose/resourceGenerator/kotlin/iosArm64MainResourceCollectors/vn/momo/uikits/resources/ActualResourceCollectors.kt

@@ -0,0 +1,49 @@
+@file:OptIn(org.jetbrains.compose.resources.InternalResourceApi::class)
+
+package vn.momo.uikits.resources
+
+import kotlin.OptIn
+import kotlin.String
+import kotlin.collections.Map
+import org.jetbrains.compose.resources.DrawableResource
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import org.jetbrains.compose.resources.FontResource
+import org.jetbrains.compose.resources.PluralStringResource
+import org.jetbrains.compose.resources.StringArrayResource
+import org.jetbrains.compose.resources.StringResource
+
+@ExperimentalResourceApi
+public actual val Res.allDrawableResources: Map<String, DrawableResource> by lazy {
+  val map = mutableMapOf<String, DrawableResource>()
+  return@lazy map
+}
+
+
+@ExperimentalResourceApi
+public actual val Res.allStringResources: Map<String, StringResource> by lazy {
+  val map = mutableMapOf<String, StringResource>()
+  return@lazy map
+}
+
+
+@ExperimentalResourceApi
+public actual val Res.allStringArrayResources: Map<String, StringArrayResource> by lazy {
+  val map = mutableMapOf<String, StringArrayResource>()
+  return@lazy map
+}
+
+
+@ExperimentalResourceApi
+public actual val Res.allPluralStringResources: Map<String, PluralStringResource> by lazy {
+  val map = mutableMapOf<String, PluralStringResource>()
+  return@lazy map
+}
+
+
+@ExperimentalResourceApi
+public actual val Res.allFontResources: Map<String, FontResource> by lazy {
+  val map = mutableMapOf<String, FontResource>()
+  _collectCommonMainFont0Resources(map)
+  return@lazy map
+}
+

package/compose/build.gradle.kts

@@ -15,11 +15,16 @@ kotlin {
         publishLibraryVariants("release")
     }
 
-    listOf(
-        iosX64(),
-        iosArm64(),
-        iosSimulatorArm64(),
-    ).forEach { iosTarget ->
+    val isDebug = (project.findProperty("kotlin.native.cocoapods.platform") as? String)
+        ?.contains("iphoneos", ignoreCase = true) == false
+
+    val iosTargets = if (isDebug) {
+        listOf(iosX64(), iosSimulatorArm64())
+    } else {
+        listOf(iosArm64())
+    }
+
+    iosTargets.forEach { iosTarget ->
         iosTarget.binaries.framework {
             baseName = "lib"
             isStatic = true
@@ -42,6 +47,7 @@ kotlin {
                 implementation(libs.coil.multiplatform.network.ktor)
                 implementation(libs.jetbrains.serialization.json)
                 implementation(libs.kotlinx.datetime)
+                api(project(":NativeMaxApi"))
             }
         }
         val androidMain by getting {
@@ -51,10 +57,12 @@ kotlin {
                 api("androidx.activity:activity-compose:1.8.2")
             }
         }
-        val iosX64Main by getting
-        val iosArm64Main by getting
-        val iosSimulatorArm64Main by getting
-
+        if (isDebug) {
+            val iosX64Main by getting
+            val iosSimulatorArm64Main by getting
+        } else {
+            val iosArm64Main by getting
+        }
         iosMain.dependencies {
             implementation(libs.ktor.client.darwin)
         }

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

@@ -73,7 +73,69 @@ data class MiniAppContext(
     val toolkitConfig: Map<String, Any?> = emptyMap(),
     val providerId: String = "",
     val permissions: List<Map<String, Any>>? = emptyList()
-)
+) {
+    companion object {
+        private const val KEY_ICON        = "icon"
+        private const val KEY_NAME        = "name"
+        private const val KEY_APP_ID      = "appId"
+        private const val KEY_CODE        = "code"
+        private const val KEY_DESCRIPTION = "description"
+        private const val KEY_SUPPORT     = "support"
+        private const val KEY_TOOLKIT_CFG = "toolkitConfig"
+        private const val KEY_PERMISSIONS = "permissions"
+        private const val KEY_ORIGIN_APP  = "originAppId"
+
+        fun toMap(context: MiniAppContext?): Map<String, Any?> = mapOf(
+            "icon"          to (context?.appIcon ?: ""),
+            "name"          to context?.appName,
+            "appId"         to (context?.appId ?: ""),
+            "code"          to (context?.appCode ?: ""),
+            "description"   to (context?.description ?: ""),
+            "support"       to (context?.support ?: emptyMap<String, Any?>()),
+            "toolkitConfig" to (context?.toolkitConfig ?: emptyMap<String, Any?>()),
+            "providerId"    to (context?.providerId ?: ""),
+            "permissions"   to (context?.permissions ?: emptyList<Map<String, Any>>())
+        )
+
+        fun fromMap(data: Map<String, Any?>?): MiniAppContext = MiniAppContext(
+            appIcon       = data.string(KEY_ICON) ?: "",
+            appName       = data?.get(KEY_NAME),
+            appId         = data.string(KEY_APP_ID) ?: "",
+            appCode       = data.string(KEY_CODE) ?: "",
+            description   = data?.get(KEY_DESCRIPTION),
+            support       = data.mapStringAny(KEY_SUPPORT),
+            toolkitConfig = data.mapStringAny(KEY_TOOLKIT_CFG),
+            providerId    = computeProviderId(
+                originAppId = data.string(KEY_ORIGIN_APP),
+                appId       = data.string(KEY_APP_ID)
+            ),
+            permissions   = data.listOfMapStringAny(KEY_PERMISSIONS)
+        )
+
+        private fun computeProviderId(originAppId: String?, appId: String?): String {
+            val id = when {
+                !originAppId.isNullOrBlank() -> originAppId
+                !appId.isNullOrBlank()       -> appId
+                else                         -> null
+            } ?: return "unknown"
+
+            val parts = id.split('.')
+            return parts.getOrNull(1) ?: "unknown"
+        }
+    }
+}
+
+private fun Map<String, Any?>?.string(key: String): String? =
+    (this?.get(key) as? String)
+
+@Suppress("UNCHECKED_CAST")
+private fun Map<String, Any?>?.mapStringAny(key: String): Map<String, Any?> =
+    (this?.get(key) as? Map<String, Any?>) ?: emptyMap()
+
+@Suppress("UNCHECKED_CAST")
+private fun Map<String, Any?>?.listOfMapStringAny(key: String): List<Map<String, Any>> =
+    (this?.get(key) as? List<Map<String, Any>>) ?: emptyList()
+
 
 val PlatformApi = staticCompositionLocalOf<Any?> { null }
 

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

@@ -21,6 +21,8 @@ import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -79,17 +81,20 @@ fun Screen(
 ) {
     val statusBarHeight = getAppStatusBarHeight()
     val keyboardController = LocalSoftwareKeyboardController.current
-    val keyboardHeight = WindowInsets.ime.asPaddingValues().calculateBottomPadding()
-    val keyboardSize = when {
-        !useAvoidKeyboard -> 0.dp
-        keyboardHeight > 100.dp && footer == null -> keyboardHeight
-        keyboardHeight > 100.dp && footer != null -> keyboardHeight - 21.dp
-        else -> 0.dp
-    }
 
     val indicator = WindowInsets.systemBars.asPaddingValues().calculateBottomPadding()
     val bottomPadding = min(indicator, 21.dp)
 
+    val keyboardHeight = WindowInsets.ime.asPaddingValues().calculateBottomPadding()
+    val keyboardSize by remember { mutableStateOf(
+        when {
+            !useAvoidKeyboard || keyboardController == null -> 0.dp
+            keyboardHeight > 100.dp && footer == null -> keyboardHeight
+            keyboardHeight > 100.dp && footer != null -> keyboardHeight - bottomPadding
+            else -> 0.dp
+        }
+    ) }
+
     val headerHeight = if (animatedHeader !== null)
         with(LocalDensity.current) { layoutOffset.roundToPx() }
     else HEADER_HEIGHT