@momo-kits/native-kits 0.300.6-debug → 0.300.6

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/CurvedContainer.kt

@@ -1,86 +0,0 @@
-package vn.momo.kits.navigation.bottomtab
-
-import androidx.compose.foundation.Canvas
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.offset
-import androidx.compose.foundation.layout.width
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Path
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.IntOffset
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.zIndex
-import vn.momo.kits.const.AppTheme
-
-@Composable
-internal fun CurvedContainer(
-    circleSize: Dp = 48.dp,
-    tabBarItemIconSize: Dp = 28.dp,
-    circleOverSize: Dp = 2.dp,
-    width: Dp = 71.dp,
-    height: Dp = 16.dp
-) {
-    val theme = AppTheme.current
-    val density = LocalDensity.current
-    val widthPx = with(density) { width.toPx()}
-
-    val circleSizePx = with(density) { circleSize.toPx() }
-    val tabBarItemIconSizePx = with(density) { tabBarItemIconSize.toPx() }
-    val circleOverSizePx = with(density) { circleOverSize.toPx() }
-
-    val circlePositionTop = circleSizePx - tabBarItemIconSizePx - 10f
-    val circleOverTop = circlePositionTop + circleOverSizePx
-    val circleR = circleSizePx / 2
-    val circleOverR = circleR + circleOverSizePx
-
-    val centerX = widthPx / 2
-
-    val curvedPath = getPath(
-        circleOverTop = circleOverTop,
-        centerX = centerX,
-        circleOverR = circleOverR,
-        widthPx = widthPx
-    )
-
-    Box(
-        contentAlignment = Alignment.BottomCenter
-    ){
-        Canvas(
-            modifier = Modifier
-                .width(width)
-                .height(height)
-                .offset{ IntOffset(x = 0, y = 24) }
-                .zIndex(-1f)
-        ) {
-            drawPath(path = curvedPath, color = theme.colors.background.surface)
-        }
-    }
-}
-
-private fun getPath(circleOverTop: Float, centerX: Float, circleOverR: Float, widthPx: Float): Path{
-    return Path().apply {
-        moveTo(0f, circleOverTop)
-        lineTo(centerX - circleOverR - 40f, circleOverTop)
-
-        cubicTo(
-            centerX - circleOverR, circleOverTop,
-            centerX - circleOverR, 0f,
-            centerX, 0f
-        )
-
-        cubicTo(
-            centerX + circleOverR, 0f,
-            centerX + circleOverR, circleOverTop,
-            centerX + circleOverR + 40f, circleOverTop
-        )
-
-        lineTo(widthPx, circleOverTop)
-        lineTo(widthPx, 60f)
-        lineTo(0f, 60f)
-        close()
-    }
-}

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/DuoBarCompression.kt

@@ -1,97 +0,0 @@
-package vn.momo.kits.navigation.bottomtab
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.Stable
-import androidx.compose.runtime.compositionLocalOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.unit.Dp
-import vn.momo.kits.const.Spacing
-import vn.momo.kits.layout.DuoMetrics
-import vn.momo.kits.layout.ScreenLayout
-
-// iPhone Duo: which side bar bar starts compressed when the strip cannot hold both whole.
-enum class DuoBarCompressionBehavior { TOOLBAR, TAB_BAR }
-
-private enum class DuoBar { TOOLBAR, TAB_BAR }
-
-@Stable
-internal class DuoBarCompression(
-    val toolbarCompressed: Boolean = false,
-    val tabBarCompressed: Boolean = false,
-    // the open rail needs the toolbar button slot too: only Back stays
-    val toolbarHidden: Boolean = false,
-    val expandToolbar: () -> Unit = {},
-    val expandTabBar: () -> Unit = {},
-    // a rail opened from the compressed state closes once a tab is picked
-    val onTabSelected: () -> Unit = {},
-    // side bar columns report their full height so the tab bar knows what is left
-    val setToolbarHeight: (Dp) -> Unit = {},
-)
-
-internal val LocalDuoBarCompression = compositionLocalOf { DuoBarCompression() }
-
-// space kept between the top and the bottom groups (HIG Vertical controls)
-internal val DUO_GROUP_GAP = Spacing.M
-// Back, then the right toolkit: help + home capsule
-private val DEFAULT_TOOLBAR_HEIGHT = DuoMetrics.controlSize + Spacing.M + DuoMetrics.itemPitch * 2
-// Back, then the single button the toolbar folds into
-private val COMPRESSED_TOOLBAR_HEIGHT = DuoMetrics.controlSize * 2 + Spacing.M
-
-// Port of RN DuoBarCompression (HIG, Designing for iPhone Duo: Vertical controls):
-// - both fit: both stay whole
-// - one fits whole beside the other compressed: one is compressed, tapping it swaps them
-// - otherwise both rest compressed; tapping one opens it for a moment (the rail closes
-//   again once a tab is picked)
-@Composable
-internal fun rememberDuoBarCompression(
-    behavior: DuoBarCompressionBehavior,
-    tabCount: Int,
-    hasQr: Boolean,
-    layout: ScreenLayout,
-): DuoBarCompression {
-    var toolbarHeight by remember { mutableStateOf(DEFAULT_TOOLBAR_HEIGHT) }
-    var expanded by remember(behavior) {
-        mutableStateOf(if (behavior == DuoBarCompressionBehavior.TOOLBAR) DuoBar.TAB_BAR else DuoBar.TOOLBAR)
-    }
-    var opened by remember { mutableStateOf<DuoBar?>(null) }
-    val setToolbarHeight = remember { { height: Dp -> toolbarHeight = height } }
-    val sideBar = layout.sideBar
-
-    return remember(sideBar, layout.height, tabCount, hasQr, toolbarHeight, expanded, opened) {
-        if (sideBar == null) return@remember DuoBarCompression()
-        val room = layout.height - sideBar.bottom - sideBar.top - DUO_GROUP_GAP
-        val tabBar = duoRailHeight(tabCount, hasQr)
-        val compressedTabBar = duoRailHeight(1, hasQr, compressed = true)
-        fun fits(toolbar: Dp, tabs: Dp) = toolbar + tabs <= room
-
-        when {
-            fits(toolbarHeight, tabBar) -> DuoBarCompression(setToolbarHeight = setToolbarHeight)
-            fits(COMPRESSED_TOOLBAR_HEIGHT, tabBar) && fits(toolbarHeight, compressedTabBar) -> DuoBarCompression(
-                toolbarCompressed = expanded == DuoBar.TAB_BAR,
-                tabBarCompressed = expanded == DuoBar.TOOLBAR,
-                expandToolbar = { expanded = DuoBar.TOOLBAR },
-                expandTabBar = { expanded = DuoBar.TAB_BAR },
-                setToolbarHeight = setToolbarHeight,
-            )
-            // an opened rail always shows, even when only the group gap is short: it closes once a tab is picked
-            opened == DuoBar.TAB_BAR -> DuoBarCompression(
-                toolbarCompressed = true,
-                toolbarHidden = true,
-                expandToolbar = { opened = DuoBar.TOOLBAR },
-                expandTabBar = { opened = DuoBar.TAB_BAR },
-                onTabSelected = { opened = null },
-                setToolbarHeight = setToolbarHeight,
-            )
-            else -> DuoBarCompression(
-                toolbarCompressed = opened != DuoBar.TOOLBAR,
-                tabBarCompressed = true,
-                expandToolbar = { opened = DuoBar.TOOLBAR },
-                expandTabBar = { opened = DuoBar.TAB_BAR },
-                setToolbarHeight = setToolbarHeight,
-            )
-        }
-    }
-}

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/DuoTabBar.kt

@@ -1,377 +0,0 @@
-package vn.momo.kits.navigation.bottomtab
-
-import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.animateDpAsState
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.animation.core.spring
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.interaction.collectIsPressedAsState
-import androidx.compose.foundation.border
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.BoxScope
-import androidx.compose.foundation.layout.BoxWithConstraints
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.RowScope
-import androidx.compose.foundation.layout.absolutePadding
-import androidx.compose.foundation.layout.fillMaxHeight
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.offset
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.compositionLocalOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.AbsoluteAlignment
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.shadow
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.Shape
-import androidx.compose.ui.semantics.Role
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import vn.momo.kits.application.LocalContext
-import vn.momo.kits.application.MiniAppContext
-import vn.momo.kits.components.Badge
-import vn.momo.kits.components.BadgeDot
-import vn.momo.kits.components.DotSize
-import vn.momo.kits.components.Icon
-import vn.momo.kits.components.Text
-import vn.momo.kits.const.AppTheme
-import vn.momo.kits.const.Spacing
-import vn.momo.kits.const.Typography
-import vn.momo.kits.layout.DuoMetrics
-import vn.momo.kits.layout.ScreenLayout
-import vn.momo.kits.layout.SideBarEdge
-import vn.momo.kits.modifier.noFeedbackClickable
-import vn.momo.kits.modifier.setAutomationId
-
-// Figma Fold-Design-System MT1/MT2, mirrored from RN DuoTabBar.tsx.
-private val ITEM_SIZE = DuoMetrics.controlSize
-private val ICON_SIZE = 28.dp
-private val QR_ICON_SIZE = 24.dp
-private val RAIL_PADDING = 6.dp
-private val RAIL_GAP = Spacing.XXS
-// selection bubble overflows the 48 rail cell by 5 above and below
-private val RAIL_BUBBLE_WIDTH = 44.dp
-private val RAIL_BUBBLE_HEIGHT = 58.dp
-private val FLOATING_HEIGHT = DuoMetrics.floatingTabBarHeight
-private val FLOATING_PADDING = Spacing.XS
-// the system bar sizes its pill to the tabs instead of stretching it across the display
-private val FLOATING_ITEM_WIDTH = 80.dp
-// while pressed the selection bubble grows into a lens past the pill's edges
-private const val LENS_SCALE_X = 1.2f
-private const val LENS_SCALE_Y = 1.3f
-// Figma Home-2026 tab bar "Selection": brand pink at 8%
-private const val SELECTION_TINT_ALPHA = 0x14 / 255f
-// RN reanimated spring { damping: 18, stiffness: 220, mass: 0.8 }
-private val BUBBLE_SPRING = spring<Dp>(dampingRatio = 0.68f, stiffness = 275f, visibilityThreshold = Dp(0.5f))
-private val LENS_SPRING = spring<Float>(dampingRatio = 0.68f, stiffness = 275f)
-
-// Space from the window bottom the rail stack and its gap take, so the header side bar stays above it.
-internal val LocalDuoRailReserve = compositionLocalOf { 0.dp }
-
-// Rail plus the QR button under it; compressed, the rail is a single button.
-internal fun duoRailHeight(itemCount: Int, hasQr: Boolean, compressed: Boolean = false): Dp {
-    val rail = if (compressed) ITEM_SIZE
-    else RAIL_PADDING * 2 + ITEM_SIZE * itemCount + RAIL_GAP * (itemCount - 1).coerceAtLeast(0)
-    return rail + if (hasQr) Spacing.M + ITEM_SIZE else 0.dp
-}
-
-// Overlaps the home indicator inset like the system tab bar (21pt above the bottom with a 34pt inset).
-private fun floatingTabBarBottom(insetBottom: Dp): Dp =
-    maxOf(insetBottom - DuoMetrics.floatingTabBarInsetOverlap, Spacing.S)
-
-// Space tab content leaves under the floating bar; 0 when the rail sits in the side strip or off Duo.
-internal fun duoFloatingTabBarInset(layout: ScreenLayout): Dp =
-    if (layout.isIPhoneDuo && layout.sideBar == null) FLOATING_HEIGHT + floatingTabBarBottom(layout.insetBottom) else 0.dp
-
-// iPhone Duo tab bar: rail in the side bar, or a floating bar when unfolded portrait.
-@Composable
-internal fun BoxScope.DuoTabBar(
-    layout: ScreenLayout,
-    items: List<BottomTabItem>,
-    floatingButton: BottomTabFloatingButton?,
-    selectedIndex: Int,
-    onTabSelected: (Int) -> Unit,
-    compression: DuoBarCompression = DuoBarCompression(),
-) {
-    if (layout.sideBar != null) {
-        DuoRailTabBar(layout, items, floatingButton, selectedIndex, onTabSelected, compression)
-    } else {
-        DuoFloatingTabBar(layout, items, floatingButton, selectedIndex, onTabSelected)
-    }
-}
-
-// Vertical bar anchored to the bottom of the side bar, QR button below it (Figma MT1-C/E). When the
-// side bar is short it can shrink to one button showing the current tab (HIG "Tab bar compressed");
-// tapping it expands the rail and compresses the toolbar.
-@Composable
-private fun BoxScope.DuoRailTabBar(
-    layout: ScreenLayout,
-    items: List<BottomTabItem>,
-    floatingButton: BottomTabFloatingButton?,
-    selectedIndex: Int,
-    onTabSelected: (Int) -> Unit,
-    compression: DuoBarCompression,
-) {
-    val sideBar = layout.sideBar ?: return
-    val isRight = sideBar.edge == SideBarEdge.RIGHT
-
-    Column(
-        modifier = Modifier
-            .align(if (isRight) AbsoluteAlignment.BottomRight else AbsoluteAlignment.BottomLeft)
-            .width(sideBar.width)
-            .padding(bottom = sideBar.bottom)
-            .absolutePadding(left = if (isRight) Spacing.M else 0.dp, right = if (isRight) 0.dp else Spacing.M),
-        horizontalAlignment = if (isRight) AbsoluteAlignment.Left else AbsoluteAlignment.Right,
-        verticalArrangement = Arrangement.spacedBy(Spacing.M),
-    ) {
-        val current = items.getOrNull(selectedIndex)
-        if (compression.tabBarCompressed && current != null) {
-            Box(
-                modifier = Modifier
-                    .size(ITEM_SIZE)
-                    .tabBarMaterial(CircleShape)
-                    .noFeedbackClickable(onClick = compression.expandTabBar)
-                    .setAutomationId("bottom_tab_bar"),
-                contentAlignment = Alignment.Center,
-            ) {
-                DuoTabIcon(current, selected = true)
-            }
-        } else {
-            Rail(items, selectedIndex) {
-                onTabSelected(it)
-                compression.onTabSelected()
-            }
-        }
-        if (floatingButton != null) {
-            QrButton(floatingButton, size = ITEM_SIZE)
-        }
-    }
-}
-
-// Column of icon-only tab items with the sliding selection bubble.
-@Composable
-private fun Rail(items: List<BottomTabItem>, selectedIndex: Int, onItemClick: (Int) -> Unit) {
-    val pressedIndex = remember { mutableStateOf<Int?>(null) }
-    val bubbleOffset by animateDpAsState(
-        targetValue = (ITEM_SIZE + RAIL_GAP) * (pressedIndex.value ?: selectedIndex).coerceAtLeast(0),
-        animationSpec = BUBBLE_SPRING,
-        label = "DuoRailBubble",
-    )
-    Box(
-        Modifier
-            .width(ITEM_SIZE)
-            .tabBarMaterial(CircleShape)
-            .setAutomationId("bottom_tab_bar")
-    ) {
-        Box(
-            Modifier
-                .offset(
-                    x = (ITEM_SIZE - RAIL_BUBBLE_WIDTH) / 2,
-                    y = RAIL_PADDING - (RAIL_BUBBLE_HEIGHT - ITEM_SIZE) / 2 + bubbleOffset,
-                )
-                .size(RAIL_BUBBLE_WIDTH, RAIL_BUBBLE_HEIGHT)
-                .selectionLens(pressedIndex.value != null)
-        )
-        Column(
-            modifier = Modifier.padding(vertical = RAIL_PADDING),
-            verticalArrangement = Arrangement.spacedBy(RAIL_GAP),
-        ) {
-            items.forEachIndexed { index, item ->
-                Box(
-                    modifier = Modifier
-                        .size(ITEM_SIZE)
-                        .tabClickable(index, pressedIndex) { onItemClick(index) },
-                    contentAlignment = Alignment.Center,
-                ) {
-                    DuoTabIcon(item, selected = index == selectedIndex)
-                }
-            }
-        }
-    }
-}
-
-// Floating labelled bar for the unfolded portrait display, QR pinned in its own platter beside it.
-@Composable
-private fun BoxScope.DuoFloatingTabBar(
-    layout: ScreenLayout,
-    items: List<BottomTabItem>,
-    floatingButton: BottomTabFloatingButton?,
-    selectedIndex: Int,
-    onTabSelected: (Int) -> Unit,
-) {
-    val pressedIndex = remember { mutableStateOf<Int?>(null) }
-
-    Row(
-        modifier = Modifier
-            .align(Alignment.BottomCenter)
-            .fillMaxWidth()
-            .absolutePadding(
-                left = layout.insetLeft + DuoMetrics.floatingTabBarMargin,
-                right = layout.insetRight + DuoMetrics.floatingTabBarMargin,
-            )
-            .padding(bottom = floatingTabBarBottom(layout.insetBottom)),
-        horizontalArrangement = Arrangement.spacedBy(Spacing.S, Alignment.CenterHorizontally),
-    ) {
-        Box(
-            modifier = Modifier
-                .weight(1f, fill = false)
-                .width(FLOATING_ITEM_WIDTH * items.size + FLOATING_PADDING * 2)
-                .height(FLOATING_HEIGHT)
-                .tabBarMaterial(RoundedCornerShape(FLOATING_HEIGHT / 2))
-                .padding(FLOATING_PADDING)
-                .setAutomationId("bottom_tab_bar")
-        ) {
-            BoxWithConstraints(Modifier.fillMaxSize()) {
-                val cellWidth = maxWidth / items.size.coerceAtLeast(1)
-                val bubbleOffset by animateDpAsState(
-                    targetValue = cellWidth * (pressedIndex.value ?: selectedIndex).coerceAtLeast(0),
-                    animationSpec = BUBBLE_SPRING,
-                    label = "DuoFloatingBubble",
-                )
-                Box(
-                    Modifier
-                        .offset(x = bubbleOffset)
-                        .width(cellWidth)
-                        .fillMaxHeight()
-                        .selectionLens(pressedIndex.value != null)
-                )
-                Row(Modifier.fillMaxSize()) {
-                    items.forEachIndexed { index, item ->
-                        FloatingCell(item, selected = index == selectedIndex, index, pressedIndex) {
-                            onTabSelected(index)
-                        }
-                    }
-                }
-            }
-        }
-        if (floatingButton != null) {
-            QrButton(floatingButton, size = FLOATING_HEIGHT, Modifier.shadow(3.dp, CircleShape))
-        }
-    }
-}
-
-@Composable
-private fun RowScope.FloatingCell(
-    item: BottomTabItem,
-    selected: Boolean,
-    index: Int,
-    pressedIndex: MutableState<Int?>,
-    onClick: () -> Unit,
-) {
-    val colors = AppTheme.current.colors
-    Column(
-        modifier = Modifier
-            .weight(1f)
-            .fillMaxHeight()
-            .tabClickable(index, pressedIndex, onClick),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.spacedBy(Spacing.XXS, Alignment.CenterVertically),
-    ) {
-        DuoTabIcon(item, selected)
-        // like the system tab bar the label keeps its design size; Text grows it up to 5pt on the wide Duo displays
-        val context = LocalContext.current
-        val fixedScale = remember(context) {
-            (context ?: MiniAppContext()).copy(userScaleRate = 1f, useOSScaleRate = false)
-        }
-        CompositionLocalProvider(LocalContext provides fixedScale) {
-            Text(
-                text = item.label,
-                style = Typography.labelXsMedium,
-                color = if (selected) colors.primary else colors.text.hint,
-                maxLines = 1,
-                overflow = TextOverflow.Ellipsis,
-            )
-        }
-    }
-}
-
-// Tracks the finger so the selection lens jumps to the pressed tab before it is selected.
-@Composable
-private fun Modifier.tabClickable(index: Int, pressedIndex: MutableState<Int?>, onClick: () -> Unit): Modifier {
-    val interactionSource = remember { MutableInteractionSource() }
-    val pressed by interactionSource.collectIsPressedAsState()
-    LaunchedEffect(pressed) {
-        if (pressed) pressedIndex.value = index
-        else if (pressedIndex.value == index) pressedIndex.value = null
-    }
-    return clickable(interactionSource = interactionSource, indication = null, role = Role.Tab, onClick = onClick)
-}
-
-// Selection bubble; while pressed it grows into a lens (80x54 to about 96x70).
-@Composable
-private fun Modifier.selectionLens(pressed: Boolean): Modifier {
-    val lens by animateFloatAsState(if (pressed) 1f else 0f, LENS_SPRING, label = "DuoSelectionLens")
-    val tint = AppTheme.current.colors.primary.copy(alpha = SELECTION_TINT_ALPHA)
-    return graphicsLayer {
-        scaleX = 1 + lens * (LENS_SCALE_X - 1)
-        scaleY = 1 + lens * (LENS_SCALE_Y - 1)
-    }.background(tint, CircleShape)
-}
-
-@Composable
-private fun DuoTabIcon(item: BottomTabItem, selected: Boolean) {
-    val colors = AppTheme.current.colors
-    val badgeLabel = item.badgeLabel?.takeUnless { it.toIntOrNull() == 0 }
-    Box {
-        Icon(
-            source = item.icon,
-            size = ICON_SIZE,
-            color = if (selected) colors.primary else colors.text.hint,
-        )
-        when {
-            badgeLabel == null && !item.showDot -> Unit
-            badgeLabel.isNullOrEmpty() -> BadgeDot(
-                size = DotSize.Small,
-                modifier = Modifier.align(Alignment.TopEnd),
-            )
-            else -> Badge(
-                badgeLabel,
-                modifier = Modifier.align(Alignment.TopStart).offset(x = ICON_SIZE / 2, y = -Spacing.XS),
-            )
-        }
-    }
-}
-
-@Composable
-private fun QrButton(data: BottomTabFloatingButton, size: Dp, modifier: Modifier = Modifier) {
-    Box(
-        modifier = modifier
-            .size(size)
-            .clip(CircleShape)
-            .background(AppTheme.current.colors.primary)
-            .noFeedbackClickable(onClick = data.onPress)
-            .setAutomationId(data.label),
-        contentAlignment = Alignment.Center,
-    ) {
-        Icon(source = data.icon, color = Color.White, size = QR_ICON_SIZE)
-    }
-}
-
-// RN BarMaterial: surface with a 1dp border.
-@Composable
-private fun Modifier.tabBarMaterial(shape: Shape): Modifier {
-    val colors = AppTheme.current.colors
-    return shadow(3.dp, shape)
-        .background(colors.background.surface)
-        .border(1.dp, colors.border.default, shape)
-}