@momo-kits/native-kits 0.168.1-beta.1 → 0.168.1-beta.10-debug

package/CLAUDE.md

@@ -48,7 +48,9 @@ Publishing is automated (`publish.sh` + GitLab CI on `[ci build]` / `main`). Do
 
 - **Entry point:** wrap content in `NavigationContainer(...)` from `navigation/`. It builds the `Navigator`, takes a host-supplied `Localize` (falls back to an empty one), and provides the CompositionLocals below. The legacy `Screen` / `ApplicationContainer` / `ComposeApi` stack has been removed on both sides — don't reintroduce it.
 - **Configuration flows via CompositionLocals**, not params. Public ones: `AppTheme`, `AppStatusBar`, `AppNavigationBar` (`const/Theme.kt`); `ApplicationContext`, `AppConfig`, `AppLanguage`, `LocalLocalize` (`application/`); `LocalNavigator`, `LocalMaxApi` (`navigation/`). Read with `X.current`.
-- **Design-system config** (`trustBanner`, `headerBar`, `headerGradient`): the host seeds `KitDesignSystemConfig.update(...)` once (same pattern as `KitFontScale`); `NavigationContainer` provides it as `LocalDesignSystemConfig` (param `designSystemConfig` → parent → global) and applies `headerBar` as the header image when the theme has none.
+- **`DesignSystemKits`** (`application/DesignSystemKits.kt`) is the single app-wide holder for the host-owned design-system inputs: font scale (`userScaleRate` / `useOSScaleRate`), whitelist (`isWhiteList`) and the remote `DesignSystemConfig`, bundled as `DesignSystemKitsConfigs`. The host calls `DesignSystemKits.init(source)` once at startup with its `DesignSystemKitsSource` (sync `getConfigs()` seed + `configsFlow`); `init` is idempotent. Without a source, call `setConfigs(...)` directly. Read with `getConfigs()` (snapshot state, recomposes); non-Compose observers use `configsFlow`.
+- **SwiftUI twin:** `ios/Application/DesignSystemKits.swift` mirrors it field for field (`DesignSystemKitsConfigs` with `designSystemConfig: KitConfig?`, `setConfigs` / `getConfigs`), plus the OS Dynamic Type factor (`osFontScale`). There is no `init(source:)` (Swift reserves `init`): the host observes its own bridge and pushes. A host that can't share Swift types (the KMP bridge) calls `DesignSystemKits.shared.setConfigs(json:)` (`ios/Application/DesignSystemKitsPayload.swift`); the JSON field names are a contract with momo-app's serializer (`HostDesignSystemKits.observeConfigsJson`, payload classes in `DesignSystemData.kt`) — change both together. Invalid JSON is ignored. The SwiftUI kit can't link the Kotlin `kits` framework (a second Kotlin/Native runtime would hold a second, never-initialized singleton), so the render-time logic — `FontScale` formula, Dynamic Type observation — is intentionally duplicated in Swift; only values flow across.
+- **Design-system config** (`trustBanner`, `headerBar`, `headerGradient`): `NavigationContainer` provides it as `LocalDesignSystemConfig` (param `designSystemConfig` → parent → `DesignSystemKits`) and applies `headerBar` as the header image when the theme has none.
 - **Platform code** goes through `expect`/`actual` in `platform/` — never reference Android/iOS APIs from `commonMain` directly.
 - **Native bridge:** `IMaxApi` (`vn.momo.maxapi`, exposed as `LocalMaxApi`) is the host-app bridge (dismiss, tracking, device info, language).
 - Navigation uses a runtime `DynamicScreenRegistry`; overlays (modal/bottom-sheet/snackbar) go through `Navigator` + `OverplayComponentRegistry`.
@@ -69,7 +71,7 @@ Publishing is automated (`publish.sh` + GitLab CI on `[ci build]` / `main`). Do
 ## Screen layout / iPhone Duo (port of RN `useScreenLayout`, momo-kits !664)
 
 - `layout/ScreenLayout.kt`: `getScreenLayout()` returns window size, raw top/bottom + side insets, `contentWidth`, header geometry, the iPhone Duo `sideBar` and `duoTopInset`. `NavigationContainer` computes it once and provides `LocalScreenLayout`; reactive to fold/unfold and rotation (window size + `WindowInsets`). Metrics (`DuoMetrics`, 72pt iPhone header floor, 20pt status-bar threshold) mirror RN `Layout/utils.ts` — change both together.
-- iPhone-only: everything gates on `isPhoneIdiom()` (`platform/`), never on "iOS", so iPad windows keep the regular layout. Two detectors, as in RN: `isIPhoneDuo` (window aspect < 1.6 or asymmetric side insets) drives layout; `isIPhoneDuoDevice` (short side of screen or window > 440, RN `device.ts`) drives popups, modal and bottom sheet.
+- iPhone-only: everything gates on `isPhoneIdiom()` (`platform/`), never on "iOS", so iPad windows keep the regular layout. Two detectors, as in RN: `isIPhoneDuo` (window aspect < 1.6 or asymmetric side insets) drives layout; `isIPhoneDuoDevice` (Apple's foldable check: a `.division` reserved region, queried with include-inactive; Swift also latches on `UIHingeInteraction`) drives popups, modal and bottom sheet.
 - Header height is `headerHeight` (not `AppStatusBar + HEADER_HEIGHT`); the bar row is `headerBarHeight` and starts `headerStatusBarHeight` below the window top. When the status bar is off the top edge (iPhone landscape, iPhone Duo) `headerStatusBarHeight` is 0 so the title stays centered — except on the Duo outer display: in portrait the header is 76pt and the row starts at 14pt so the title centers on the camera punchout; in landscape the row centers on the camera when it sits at the top end of the strip (else on the back button) and the header reaches 8pt below the back button.
 - iPhone Duo inner display in portrait (status bar on top): the header row shares the status bar band — `headerHeight` 94pt (2 × the clock digits' y 47), `headerStatusBarHeight` 0 — and `ScreenLayout.statusBarClearance` keeps it between the clock / battery clusters (from reserved regions, else 128pt on the right). Back and toolkit use the 48pt side bar controls laid out horizontally (`ToolkitLayout.SideBarRow`); the collapsed search and a centered title stay clear of the clusters. Port of momo-kits `90af33ba2`.
 - iPhone Duo with a side strip ≥ 60pt: back + toolkit leave the bar for `HeaderSideBar` (`navigation/component/SideBar.kt`, 48pt glass controls); custom header-right stays in the bar. `sideBar.top` is 170pt in portrait, 120pt on the inner display in landscape (height ≥ 600), 24pt on the outer display in landscape, or below the header when the status bar is on top; UIKit's `statusBarFrame` is useless on Duo. Unlike RN the column is clamped above footer (24pt gap) / rail (12pt gap).
@@ -104,9 +106,9 @@ The SwiftUI port differs from Compose in one important way: **it follows the hos
 
 One formula, both platforms: the device-width scale (`width / 375`, capped at `+5pt`) and the OS Dynamic Type scale (capped at `1.5×`) are computed independently and the **larger wins**. When `useOSScaleRate` is false neither applies — the size is just multiplied by `userScaleRate`. Max font scale is fixed at 1.5; the old per-call/per-scope override is deprecated and ignored on both sides.
 
-- **Compose** — `const/Typography.kt` (`scaleSize` overloads for `Float`/`Dp`/`TextUnit`/`TextStyle`). The `TextUnit` overload divides by `density.fontScale` so Compose's own `sp` scaling isn't applied twice. Inputs: `LocalContext.current` (`MiniAppContext.userScaleRate` / `useOSScaleRate`, per-field) falling back to the `KitFontScale` global. On iOS, `platform/OsFontScale.ios.kt` observes `UIContentSizeCategoryDidChangeNotification` and overrides `LocalDensity` — Compose MP otherwise reads `fontScale` once at `ComposeUIViewController` creation. Wired at `NavigationContainer`.
-- **SwiftUI** — `ios/Typography/FontScale.swift`. `FontScale` is an immutable snapshot with `callAsFunction`, so a view reads `@Environment(\.momoFontScale) private var fontScale` and calls `fontScale(16)`. `FontScaleStore.shared` is the `ObservableObject` holding both inputs and the OS factor (it observes `UIContentSizeCategory.didChangeNotification`); the host pushes its preference with `update(userScaleRate:useOSScaleRate:)`.
-- **Never set `\.momoFontScale` directly** — same trap as `\.localize`. Inject via `.momoFontScale(_:context:)`, which holds the store as `@ObservedObject`; that is what re-publishes the snapshot. `NavigationContainer` does it (passing `MiniAppContext` so the per-mini-app override applies); a bare `UIHostingController` root must too. The environment default reads the live store, so an un-injected subtree still gets correct values — just not live ones.
+- **Compose** — `const/Typography.kt` (`scaleSize` overloads for `Float`/`Dp`/`TextUnit`/`TextStyle`). The `TextUnit` overload divides by `density.fontScale` so Compose's own `sp` scaling isn't applied twice. Inputs: `LocalContext.current` (`MiniAppContext.userScaleRate` / `useOSScaleRate`, per-field) falling back to `DesignSystemKits.getConfigs()`. On iOS, `platform/OsFontScale.ios.kt` observes `UIContentSizeCategoryDidChangeNotification` and overrides `LocalDensity` — Compose MP otherwise reads `fontScale` once at `ComposeUIViewController` creation. Wired at `NavigationContainer`.
+- **SwiftUI** — `ios/Typography/FontScale.swift`. `FontScale` is an immutable snapshot with `callAsFunction`, so a view reads `@Environment(\.momoFontScale) private var fontScale` and calls `fontScale(16)`. `DesignSystemKits.shared` is the `ObservableObject` holding the host inputs and the OS factor (it observes `UIContentSizeCategory.didChangeNotification`); the host pushes them with `setConfigs(_:)`.
+- **Never set `\.momoFontScale` directly** — same trap as `\.localize`. Inject via `.momoFontScale(_:context:)`, which holds `DesignSystemKits` as `@ObservedObject`; that is what re-publishes the snapshot. It also injects `\.designSystemKitsConfigs`, which `MomoText` (whitelist font) and `TrustBanner` (fallback after `ApplicationEnvironment.config`) read so a host push re-renders them. `NavigationContainer` does it (passing `MiniAppContext` so the per-mini-app override applies); a bare `UIHostingController` root must too. The environment default reads the live store, so an un-injected subtree still gets correct values — just not live ones.
 - The global `scaleSize(_:)` and `Font.appFont(size:)` remain for call sites that can't read the environment (UIKit bridges, free functions). They are **not** reactive. `Font.header_default_bold` & friends are computed `static var`s for the same reason — as stored `static let`s they froze the scale at first access. `UIViewRepresentable`s should read `context.environment.momoFontScale` instead, and re-apply the font in `updateUIView`, not only in `makeUIView`.
 
 ## Code conventions

package/build.gradle.kts

@@ -0,0 +1,11 @@
+plugins {
+    // this is necessary to avoid the plugins to be loaded multiple times
+    // in each subproject's classloader
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.android.library) apply false
+    alias(libs.plugins.compose) apply false
+    alias(libs.plugins.kotlin.compose.compiler) apply false
+    alias(libs.plugins.jetbrains.kotlin.multiplatform) apply false
+    alias(libs.plugins.jetbrains.kotlin.serialization) apply false
+    alias(libs.plugins.vanniktech.mavenPublish) apply false
+}

package/compose/build.gradle.kts

@@ -0,0 +1,198 @@
+// import com.vanniktech.maven.publish.JavadocJar
+// import com.vanniktech.maven.publish.KotlinMultiplatform
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    alias(libs.plugins.jetbrains.kotlin.multiplatform)
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.compose)
+    alias(libs.plugins.kotlin.compose.compiler)
+//         alias(libs.plugins.vanniktech.mavenPublish)
+    id(libs.plugins.jetbrains.kotlin.cocoapods.get().pluginId)
+    kotlin("plugin.serialization")
+}
+
+val gitlabName: String = findProperty("name") as String? ?: ""
+val gitlabRepo: String = findProperty("repo") as String? ?: ""
+val gitlabUrl: String = findProperty("url") as String? ?: ""
+val gitlabGroup: String = findProperty("group") as String? ?: ""
+val gitlabArtifactId: String = findProperty("artifact.id") as String? ?: ""
+val gitlabVersion: String = findProperty("version") as String? ?: ""
+val gitlabUser: String = findProperty("gitlab.user") as String? ?: ""
+val gitlabKey: String = findProperty("gitlab.password") as String? ?: ""
+
+kotlin {
+    androidTarget {
+        compilerOptions {
+            jvmTarget.set(JvmTarget.JVM_17)
+        }
+        publishLibraryVariants("release")
+    }
+
+    val fwName = gitlabArtifactId
+    val iosTargets = listOf(iosArm64(), iosSimulatorArm64())
+    iosTargets.forEach {
+        it.binaries.framework {
+            baseName = fwName
+            binaryOption("bundleId", "$gitlabGroup.$fwName")
+            isStatic = true
+        }
+    }
+
+    cocoapods {
+        version = "0.168.1-beta.10-debug"
+        summary = "IOS Shared module"
+        homepage = "https://momo.vn"
+        ios.deploymentTarget = "15.0"
+
+        framework {
+            baseName = fwName
+            isStatic = true
+        }
+
+        pod("lottie-ios") {
+            moduleName = "Lottie"
+            version = "4.4.3"
+            extraOpts += listOf("-compiler-option", "-fmodules")
+        }
+    }
+
+    sourceSets {
+        all {
+            languageSettings.optIn("vn.momo.kits.modifier.InternalApi")
+        }
+        commonMain.dependencies {
+            implementation(compose.runtime)
+            implementation(compose.material)
+            implementation(compose.material3)
+            implementation(compose.components.resources)
+            implementation(libs.compose.ui.backhandler)
+            implementation(libs.ktor.client.core)
+            implementation(libs.jetbrains.coroutines.core)
+            implementation(libs.navigation.multiplatform)
+            implementation(libs.coil.multiplatform.compose)
+            implementation(libs.coil.multiplatform.core)
+            implementation(libs.coil.multiplatform.network.ktor)
+            implementation(libs.jetbrains.serialization.json)
+            implementation(libs.kotlinx.datetime)
+            api(libs.native.max.api)
+            implementation(libs.compottie)
+            implementation(libs.gif.image)
+        }
+        androidMain.dependencies {
+            implementation(libs.ktor.client.okhttp)
+            implementation(libs.airbnb.lottie)
+        }
+        iosMain.dependencies {
+            implementation(libs.ktor.client.darwin)
+        }
+    }
+}
+
+android {
+    namespace = "vn.momo.kits.kits"
+    compileSdk = 35
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    defaultConfig {
+        minSdk = 24
+    }
+}
+
+dependencies {
+}
+
+repositories {
+    google {
+        mavenContent {
+            includeGroupAndSubgroups("androidx")
+            includeGroupAndSubgroups("com.android")
+            includeGroupAndSubgroups("com.google")
+        }
+    }
+    mavenCentral()
+    maven { url = uri("https://maven.pkg.jetbrains.space/public/p/compose/dev") }
+    maven {
+        url = uri("https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven")
+        credentials {username = "download_packages"; password = "gldt-bjDqLpU_sPcHDuXau2ws" }
+    }
+    maven {
+        url = uri("https://artifacts.mservice.com.vn/repository/maven-momo-app/")
+        credentials {
+            username = "viewer"
+            password = "viewer"
+        }
+        isAllowInsecureProtocol = true
+    }
+}
+
+compose {
+    resources {
+        publicResClass = true
+        packageOfResClass = "vn.momo.uikits.resources"
+        generateResClass = always
+    }
+}
+
+// publishing {
+//     repositories {
+//         maven {
+//             name = "${gitlabRepo}Packages"
+//             credentials {
+//                 username = gitlabUser
+//                 password = gitlabKey
+//             }
+//             url = uri("$gitlabUrl")
+//         }
+//     }
+// }
+
+// mavenPublishing {
+//     configure(
+//         KotlinMultiplatform(
+//             javadocJar = JavadocJar.Empty(),
+//             sourcesJar = true,
+//             androidVariantsToPublish = listOf("release")
+//         )
+//     )
+// 
+//     repositories {
+//         maven {
+//             name = "${gitlabRepo}Packages"
+//             credentials { username = gitlabUser; password = gitlabKey }
+//             url = uri("$gitlabUrl")
+//         }
+//     }
+// 
+//     coordinates(gitlabGroup.toString(), gitlabArtifactId, gitlabVersion.toString())
+// 
+//     pom {
+//         name = "$gitlabName Klib"
+//         description = "$gitlabName"
+//         url = "https://gitlab.mservice.com.vn"
+//         licenses {
+//             license {
+//                 name = "The Apache License, Version 2.0"
+//                 url = "https://www.apache.org/licenses/LICENSE-2.0.txt"
+//                 distribution = "https://www.apache.org/licenses/LICENSE-2.0.txt"
+//             }
+//         }
+//         developers {
+//             developer {
+//                 id = "kotlin-hands-on"
+//                 name = "Kotlin Developer Advocate"
+//                 url = "https://github.com/kotlin-hands-on/"
+//             }
+//         }
+//     }
+// }
+
+// Xcode 27 rejects iOS < 15; KGP's synthetic Podfile only raises pods to 12 (KT-57741), leaving lottie-ios at 13.
+tasks.named("podGenIos") {
+    doLast {
+        val podfile = layout.buildDirectory.file("cocoapods/synthetic/ios/Podfile").get().asFile
+        podfile.writeText(podfile.readText().replace("major < 12 ||", "major < 15 ||").replace("#{12}", "#{15}"))
+    }
+}

package/compose/build.gradle.kts.backup

@@ -0,0 +1,198 @@
+import com.vanniktech.maven.publish.JavadocJar
+import com.vanniktech.maven.publish.KotlinMultiplatform
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    alias(libs.plugins.jetbrains.kotlin.multiplatform)
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.compose)
+    alias(libs.plugins.kotlin.compose.compiler)
+    alias(libs.plugins.vanniktech.mavenPublish)
+    id(libs.plugins.jetbrains.kotlin.cocoapods.get().pluginId)
+    kotlin("plugin.serialization")
+}
+
+val gitlabName: String = findProperty("name") as String? ?: ""
+val gitlabRepo: String = findProperty("repo") as String? ?: ""
+val gitlabUrl: String = findProperty("url") as String? ?: ""
+val gitlabGroup: String = findProperty("group") as String? ?: ""
+val gitlabArtifactId: String = findProperty("artifact.id") as String? ?: ""
+val gitlabVersion: String = findProperty("version") as String? ?: ""
+val gitlabUser: String = findProperty("gitlab.user") as String? ?: ""
+val gitlabKey: String = findProperty("gitlab.password") as String? ?: ""
+
+kotlin {
+    androidTarget {
+        compilerOptions {
+            jvmTarget.set(JvmTarget.JVM_17)
+        }
+        publishLibraryVariants("release")
+    }
+
+    val fwName = gitlabArtifactId
+    val iosTargets = listOf(iosArm64(), iosSimulatorArm64())
+    iosTargets.forEach {
+        it.binaries.framework {
+            baseName = fwName
+            binaryOption("bundleId", "$gitlabGroup.$fwName")
+            isStatic = true
+        }
+    }
+
+    cocoapods {
+        version = gitlabVersion
+        summary = "IOS Shared module"
+        homepage = "https://momo.vn"
+        ios.deploymentTarget = "15.0"
+
+        framework {
+            baseName = fwName
+            isStatic = true
+        }
+
+        pod("lottie-ios") {
+            moduleName = "Lottie"
+            version = "4.4.3"
+            extraOpts += listOf("-compiler-option", "-fmodules")
+        }
+    }
+
+    sourceSets {
+        all {
+            languageSettings.optIn("vn.momo.kits.modifier.InternalApi")
+        }
+        commonMain.dependencies {
+            implementation(compose.runtime)
+            implementation(compose.material)
+            implementation(compose.material3)
+            implementation(compose.components.resources)
+            implementation(libs.compose.ui.backhandler)
+            implementation(libs.ktor.client.core)
+            implementation(libs.jetbrains.coroutines.core)
+            implementation(libs.navigation.multiplatform)
+            implementation(libs.coil.multiplatform.compose)
+            implementation(libs.coil.multiplatform.core)
+            implementation(libs.coil.multiplatform.network.ktor)
+            implementation(libs.jetbrains.serialization.json)
+            implementation(libs.kotlinx.datetime)
+            api(libs.native.max.api)
+            implementation(libs.compottie)
+            implementation(libs.gif.image)
+        }
+        androidMain.dependencies {
+            implementation(libs.ktor.client.okhttp)
+            implementation(libs.airbnb.lottie)
+        }
+        iosMain.dependencies {
+            implementation(libs.ktor.client.darwin)
+        }
+    }
+}
+
+android {
+    namespace = "$gitlabGroup.$gitlabArtifactId"
+    compileSdk = libs.versions.android.compileSdk.get().toInt()
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    defaultConfig {
+        minSdk = libs.versions.android.minSdk.get().toInt()
+    }
+}
+
+dependencies {
+}
+
+repositories {
+    google {
+        mavenContent {
+            includeGroupAndSubgroups("androidx")
+            includeGroupAndSubgroups("com.android")
+            includeGroupAndSubgroups("com.google")
+        }
+    }
+    mavenCentral()
+    maven { url = uri("https://maven.pkg.jetbrains.space/public/p/compose/dev") }
+    maven {
+        url = uri("https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven")
+        credentials {username = "download_packages"; password = "gldt-bjDqLpU_sPcHDuXau2ws" }
+    }
+    maven {
+        url = uri("https://artifacts.mservice.com.vn/repository/maven-momo-app/")
+        credentials {
+            username = "viewer"
+            password = "viewer"
+        }
+        isAllowInsecureProtocol = true
+    }
+}
+
+compose {
+    resources {
+        publicResClass = true
+        packageOfResClass = "vn.momo.uikits.resources"
+        generateResClass = always
+    }
+}
+
+publishing {
+    repositories {
+        maven {
+            name = "${gitlabRepo}Packages"
+            credentials {
+                username = gitlabUser
+                password = gitlabKey
+            }
+            url = uri("$gitlabUrl")
+        }
+    }
+}
+
+mavenPublishing {
+    configure(
+        KotlinMultiplatform(
+            javadocJar = JavadocJar.Empty(),
+            sourcesJar = true,
+            androidVariantsToPublish = listOf("release")
+        )
+    )
+
+    repositories {
+        maven {
+            name = "${gitlabRepo}Packages"
+            credentials { username = gitlabUser; password = gitlabKey }
+            url = uri("$gitlabUrl")
+        }
+    }
+
+    coordinates(gitlabGroup.toString(), gitlabArtifactId, gitlabVersion.toString())
+
+    pom {
+        name = "$gitlabName Klib"
+        description = "$gitlabName"
+        url = "https://gitlab.mservice.com.vn"
+        licenses {
+            license {
+                name = "The Apache License, Version 2.0"
+                url = "https://www.apache.org/licenses/LICENSE-2.0.txt"
+                distribution = "https://www.apache.org/licenses/LICENSE-2.0.txt"
+            }
+        }
+        developers {
+            developer {
+                id = "kotlin-hands-on"
+                name = "Kotlin Developer Advocate"
+                url = "https://github.com/kotlin-hands-on/"
+            }
+        }
+    }
+}
+
+// Xcode 27 rejects iOS < 15; KGP's synthetic Podfile only raises pods to 12 (KT-57741), leaving lottie-ios at 13.
+tasks.named("podGenIos") {
+    doLast {
+        val podfile = layout.buildDirectory.file("cocoapods/synthetic/ios/Podfile").get().asFile
+        podfile.writeText(podfile.readText().replace("major < 12 ||", "major < 15 ||").replace("#{12}", "#{15}"))
+    }
+}

package/compose/compose.podspec

@@ -0,0 +1,47 @@
+Pod::Spec.new do |spec|
+    spec.name                     = 'compose'
+    spec.version                  = '0.167.1-beta.22-debug'
+    spec.homepage                 = 'https://momo.vn'
+    spec.source                   = { :http=> ''}
+    spec.authors                  = ''
+    spec.license                  = ''
+    spec.summary                  = 'IOS Shared module'
+    spec.vendored_frameworks      = 'build/cocoapods/framework/kits.framework'
+    spec.libraries                = 'c++'
+    spec.ios.deployment_target    = '15.0'
+    spec.dependency 'lottie-ios', '4.4.3'
+    if !Dir.exist?('build/cocoapods/framework/kits.framework') || Dir.empty?('build/cocoapods/framework/kits.framework')
+        raise "
+        Kotlin framework 'kits' doesn't exist yet, so a proper Xcode project can't be generated.
+        'pod install' should be executed after running ':generateDummyFramework' Gradle task:
+            ./gradlew :compose:generateDummyFramework
+        Alternatively, proper pod installation is performed during Gradle sync in the IDE (if Podfile location is set)"
+    end
+    spec.xcconfig = {
+        'ENABLE_USER_SCRIPT_SANDBOXING' => 'NO',
+    }
+    spec.pod_target_xcconfig = {
+        'KOTLIN_PROJECT_PATH' => ':compose',
+        'PRODUCT_MODULE_NAME' => 'kits',
+    }
+    spec.script_phases = [
+        {
+            :name => 'Build compose',
+            :execution_position => :before_compile,
+            :shell_path => '/bin/sh',
+            :script => <<-SCRIPT
+                if [ "YES" = "$OVERRIDE_KOTLIN_BUILD_IDE_SUPPORTED" ]; then
+                    echo "Skipping Gradle build task invocation due to OVERRIDE_KOTLIN_BUILD_IDE_SUPPORTED environment variable set to \"YES\""
+                    exit 0
+                fi
+                set -ev
+                REPO_ROOT="$PODS_TARGET_SRCROOT"
+                "$REPO_ROOT/../gradlew" -p "$REPO_ROOT" $KOTLIN_PROJECT_PATH:syncFramework \
+                    -Pkotlin.native.cocoapods.platform=$PLATFORM_NAME \
+                    -Pkotlin.native.cocoapods.archs="$ARCHS" \
+                    -Pkotlin.native.cocoapods.configuration="$CONFIGURATION"
+            SCRIPT
+        }
+    ]
+    spec.resources = ['build/compose/cocoapods/compose-resources']
+end

package/compose/src/androidMain/kotlin/vn/momo/kits/const/HostFont.android.kt

@@ -0,0 +1,20 @@
+package vn.momo.kits.const
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.font.Font
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+
+@Composable
+internal actual fun hostFontFamily(fileName: String, weight: FontWeight): FontFamily? {
+    val assets = LocalContext.current.applicationContext.assets
+    return remember(fileName, weight) {
+        val path = "fonts/$fileName"
+        // AssetManager.open ném IOException nếu thiếu file; Font(path, assetManager) thì lỗi
+        // muộn lúc render nên phải kiểm tra tồn tại trước.
+        val exists = runCatching { assets.open(path).close() }.isSuccess
+        if (exists) FontFamily(Font(path = path, assetManager = assets, weight = weight)) else null
+    }
+}

package/compose/src/androidMain/kotlin/vn/momo/kits/navigation/ScrollToTop.android.kt

@@ -0,0 +1,6 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.runtime.Composable
+
+@Composable
+internal actual fun RegisterScrollToTop(callback: (() -> Unit)?) = Unit

package/compose/src/androidMain/kotlin/vn/momo/kits/platform/BackGesture.android.kt

@@ -0,0 +1,12 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.State
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+
+// No passive observer at androidx.activity 1.10.x; a second callback would steal the gesture.
+@Composable
+actual fun rememberBackGestureProgress(): State<Float?> = remember { mutableStateOf(null) }
+
+actual fun reportFloatingArrowBack(shouldUse: Boolean) = Unit

package/compose/src/androidMain/kotlin/vn/momo/kits/platform/OsFontScale.android.kt

@@ -0,0 +1,7 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+
+// Android's LocalDensity.fontScale already tracks Configuration.fontScale live.
+@Composable
+actual fun ProvideOsFontScale(content: @Composable () -> Unit) = content()