@momo-kits/native-kits 0.162.2-sp.7-debug → 0.162.2-sp.8-debug

package/ios/Application/Navigation/Overplay/BottomSheet.swift

@@ -43,42 +43,84 @@ struct BottomSheetView<Content: View>: View {
     let content: () -> Content
 
     @EnvironmentObject private var navigator: Navigator
+    @Environment(\.appTheme) private var theme
+    @Environment(\.applicationEnvironment) private var appEnv
 
     /// Vertical translation of the sheet; starts off-screen and animates to 0.
     @State private var sheetOffset: CGFloat = UIScreen.main.bounds.height
-    @State private var scrimAlpha: CGFloat = 0
+    /// Mirrors Compose's `backgroundAlpha`: only touched by open()/close(), never by drag.
+    @State private var backgroundAlpha: CGFloat = 0
     @State private var sheetHeight: CGFloat = 0
     @State private var didAppear = false
+    @State private var keyboardHeight: CGFloat = 0
+    /// Live drag offset, isolated from `sheetOffset` so a touch-move only invalidates
+    /// this gesture-scoped value instead of forcing the whole body (including
+    /// `content()`) to reconstruct every frame — mirrors the pattern already used in
+    /// `ios/PopupView/PopupView.swift` for smooth drag-to-dismiss.
+    @GestureState private var dragTranslation: CGFloat = 0
 
     /// Mirrors Compose's `sheetCloseOffset` (100dp drag threshold to dismiss).
     private let closeThreshold: CGFloat = 100
 
+    /// Mirrors Compose's per-term peak (0.3f). Combined with `backgroundAlpha` the
+    /// steady-state (fully open) scrim peaks at 0.6, matching ModalScreen's peak.
+    private let maxDynamicAlpha: CGFloat = 0.3
+
     private var screenHeight: CGFloat { UIScreen.main.bounds.height }
     private var bottomInset: CGFloat { safeAreaBottomInset() }
+    /// While the keyboard is up, it already covers the home-indicator area, so it
+    /// replaces (rather than adds to) the usual bottom-inset filler.
+    private var effectiveBottomInset: CGFloat { keyboardHeight > 0 ? keyboardHeight : bottomInset }
 
     private var backgroundColor: Color {
-        // Compose uses background.surface (white) for `isSurface`, otherwise
-        // background.default. Both resolve to white in the current iOS palette.
-        isSurface ? Colors.black01 : Colors.black01
+        isSurface ? theme.colors.background.surface : theme.colors.background.default
+    }
+
+    private var effectiveOffset: CGFloat { sheetOffset + dragTranslation }
+
+    /// Mirrors Compose's `dynamicAlpha`: a plain derived value (not itself animated)
+    /// that tracks the current offset live, shrinking toward 0 as the sheet is
+    /// dragged down.
+    private var dynamicAlpha: CGFloat {
+        let denom = sheetHeight > 0 ? sheetHeight : screenHeight
+        guard denom > 0 else { return maxDynamicAlpha }
+        let progress = min(max(1 - effectiveOffset / denom, 0), 1)
+        return progress * maxDynamicAlpha
     }
 
+    /// Mirrors Compose's `alpha = backgroundAlpha + dynamicAlpha`: additive, so the
+    /// scrim peaks at 0.6 at rest and only fades to a 0.3 floor while dragging
+    /// (backgroundAlpha holds steady until an explicit close()).
+    private var totalScrimAlpha: CGFloat { backgroundAlpha + dynamicAlpha }
+
     var body: some View {
         ZStack(alignment: .bottom) {
-            // Dimmed scrim (max 0.3 alpha, mirrors Compose).
-            Color.black.opacity(scrimAlpha)
-                .ignoresSafeArea()
+            // Dimmed scrim — additive backgroundAlpha + dynamicAlpha (see above).
+            Color.black.opacity(totalScrimAlpha)
                 .contentShape(Rectangle())
                 .onTapGesture {
                     if barrierDismissible { close() }
                 }
 
             sheet
-                .offset(y: sheetOffset)
+                .offset(y: effectiveOffset)
         }
         .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .ignoresSafeArea()
+        .onReceive(NotificationCenter.default.publisher(for: UIResponder.keyboardWillChangeFrameNotification)) { notification in
+            guard let endFrame = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else { return }
+            withAnimation(.easeOut(duration: 0.25)) {
+                keyboardHeight = UIScreen.main.bounds.height - endFrame.origin.y
+            }
+        }
         .onAppear {
             guard !didAppear else { return }
             didAppear = true
+            ScreenTracker.trackPopupDisplayed(
+                maxApi: appEnv.maxApi,
+                context: appEnv.applicationContext,
+                parentScreenName: ScreenTracker.getLastScreenName()
+            )
             navigator.registerOverplayDismiss { close() }
             open()
         }
@@ -103,16 +145,16 @@ struct BottomSheetView<Content: View>: View {
             .gesture(dragGesture)
 
             Rectangle()
-                .fill(Colors.black04)
+                .fill(theme.colors.border.default)
                 .frame(height: 1)
 
             content()
 
             backgroundColor
-                .frame(height: bottomInset)
+                .frame(height: effectiveBottomInset)
         }
         .frame(maxWidth: .infinity)
-        .frame(maxHeight: screenHeight - safeAreaTopInset() - 90, alignment: .bottom)
+        .frame(alignment: .bottom)
         .background(
             GeometryReader { geo in
                 Color.clear.onAppear { sheetHeight = geo.size.height }
@@ -143,13 +185,33 @@ struct BottomSheetView<Content: View>: View {
     // MARK: - Drag handling (mirrors Compose's detectDragGestures)
 
     private var dragGesture: some Gesture {
-        DragGesture()
-            .onChanged { value in
-                let newOffset = max(value.translation.height, 0)
-                sheetOffset = newOffset
+        // `.global` (not the default `.local`) so the gesture tracks against the
+        // window rather than the handle's own view, which is itself repositioned
+        // every frame by this same gesture's output (`sheet.offset(y: effectiveOffset)`
+        // in `body`) — the local coordinate space chasing its own moving reference
+        // frame is a plausible source of a continuous drag-time jitter.
+        DragGesture(coordinateSpace: .global)
+            .onChanged { _ in
+                // Touching the handle should immediately settle `sheetOffset` to its
+                // resting value (0) with no animation, so a drag that starts while the
+                // open animation — or the keyboard-driven resize, which shifts this
+                // same bottom-anchored top edge — is still in flight doesn't fight a
+                // moving target. Without this, the live drag value chases an animated
+                // one, producing a couple of corrective jumps before it settles.
+                if sheetOffset != 0 {
+                    sheetOffset = 0
+                }
+            }
+            .updating($dragTranslation) { value, state, _ in
+                state = max(value.translation.height, 0)
             }
-            .onEnded { _ in
-                if sheetOffset > closeThreshold {
+            .onEnded { value in
+                let finalOffset = max(value.translation.height, 0)
+                // Capture into persisted state BEFORE @GestureState resets to 0,
+                // avoiding a one-frame snap back to rest before close()'s own
+                // slide-out animation starts (mirrors PopupView's `lastDragPosition`).
+                sheetOffset = finalOffset
+                if finalOffset > closeThreshold {
                     close()
                 } else {
                     withAnimation(.spring(response: 0.3, dampingFraction: 0.9)) {
@@ -163,17 +225,23 @@ struct BottomSheetView<Content: View>: View {
 
     private func open() {
         DispatchQueue.main.async {
-            withAnimation(.easeOut(duration: 0.1)) { scrimAlpha = 0.3 }
+            withAnimation(.timingCurve(0.05, 0.7, 0.1, 1, duration: 0.1)) { backgroundAlpha = maxDynamicAlpha }
             withAnimation(.timingCurve(0.05, 0.7, 0.1, 1, duration: 0.35)) { sheetOffset = 0 }
         }
     }
 
+    /// Mirrors Compose's `closeEvent`: slide out over 200ms, then fade the scrim
+    /// out over 100ms only after the slide finishes, then dismiss.
     private func close() {
         withAnimation(.timingCurve(0.3, 0, 0.8, 0.15, duration: 0.2)) {
             sheetOffset = max(sheetHeight, screenHeight)
-            scrimAlpha = 0
         }
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            withAnimation(.timingCurve(0.3, 0, 0.8, 0.15, duration: 0.1)) {
+                backgroundAlpha = 0
+            }
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
             navigator.finishOverplayDismiss()
         }
     }

package/ios/Application/Navigation/Overplay/ModalScreen.swift

@@ -15,6 +15,7 @@ struct ModalScreen<Content: View>: View {
     let content: () -> Content
 
     @EnvironmentObject private var navigator: Navigator
+    @Environment(\.applicationEnvironment) private var appEnv
 
     @State private var scrimOpacity: CGFloat = 0
     @State private var contentScale: CGFloat = 0.8
@@ -38,6 +39,11 @@ struct ModalScreen<Content: View>: View {
         .onAppear {
             guard !didAppear else { return }
             didAppear = true
+            ScreenTracker.trackPopupDisplayed(
+                maxApi: appEnv.maxApi,
+                context: appEnv.applicationContext,
+                parentScreenName: ScreenTracker.getLastScreenName()
+            )
             navigator.registerOverplayDismiss { close() }
             open()
         }

package/ios/Application/Navigation/Tracking/ScreenTracker.swift

@@ -0,0 +1,117 @@
+//
+//  ScreenTracker.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `navigation/tracking/ScreenTracker.kt`. Pure
+//  logic, no platform dependency beyond the `MaxApi` bridge.
+//
+
+import Foundation
+
+public final class ScreenTrackingState {
+    public var time: Double = Date().timeIntervalSince1970 * 1000
+    public var releaseNavigated: Bool = false
+    public var releaseLoad: Bool = false
+    public var releaseInteraction: Bool = false
+    public var previousScreenName: String?
+    public var action: String = "push"
+
+    public init() {}
+}
+
+public enum ScreenTracker {
+    private static var lastScreenName: String?
+
+    public static func trackScreenNavigated(
+        maxApi: MaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        action: String,
+        state: ScreenTrackingState
+    ) {
+        guard !state.releaseNavigated else { return }
+
+        let previousScreen = lastScreenName
+        lastScreenName = screenName
+
+        var params = buildBaseParams(context: context, screenName: screenName)
+        params["pre_screen_name"] = previousScreen
+        params["state"] = "navigated"
+        params["action"] = action
+        maxApi?.track(eventName: "auto_screen_navigated", params: params)
+
+        state.releaseNavigated = true
+        state.previousScreenName = previousScreen
+    }
+
+    public static func trackScreenDisplayed(
+        maxApi: MaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        duration: Double,
+        state: ScreenTrackingState
+    ) {
+        guard !state.releaseLoad else { return }
+
+        var params = buildBaseParams(context: context, screenName: screenName)
+        params["state"] = "load"
+        params["duration"] = duration
+        maxApi?.track(eventName: "auto_screen_displayed", params: params)
+
+        state.releaseLoad = true
+    }
+
+    public static func trackScreenInteracted(
+        maxApi: MaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        duration: Double,
+        totalDuration: Double,
+        state: ScreenTrackingState
+    ) {
+        guard !state.releaseInteraction else { return }
+
+        var params = buildBaseParams(context: context, screenName: screenName)
+        params["state"] = "interaction"
+        params["duration"] = duration
+        params["total_duration"] = totalDuration
+        maxApi?.track(eventName: "auto_screen_interacted", params: params)
+
+        state.releaseInteraction = true
+    }
+
+    public static func trackPopupDisplayed(
+        maxApi: MaxApi?,
+        context: MiniAppContext?,
+        parentScreenName: String?
+    ) {
+        maxApi?.track(eventName: "auto_popup_displayed", params: [
+            "screen_name": parentScreenName,
+            "tracking_source": 1,
+            "app_id": context?.appId,
+            "feature_code": context?.appCode,
+            "kits_version": nil,
+            "component_name": "Modal"
+        ])
+    }
+
+    private static func buildBaseParams(
+        context: MiniAppContext?,
+        screenName: String,
+        componentName: String = "Screen"
+    ) -> [String: Any?] {
+        [
+            "app_id": context?.appId,
+            "feature_code": context?.appCode,
+            "screen_name": screenName,
+            "component_name": componentName,
+            "tracking_source": 1
+        ]
+    }
+
+    public static func getLastScreenName() -> String? { lastScreenName }
+
+    public static func reset() {
+        lastScreenName = nil
+    }
+}

package/ios/Application/Screen.swift

@@ -237,7 +237,7 @@ struct Footer: View {
         }
         .padding(.vertical, Spacing.S)
         .padding(.horizontal, Spacing.M)
-        .padding(.bottom, keyboardSize + bottomInset)
+        .padding(.bottom, keyboardSize - bottomInset)
         .background(Colors.black01)
         .overlay(
             Rectangle()

package/ios/Application/StackScreen.swift

@@ -39,6 +39,7 @@ public struct StackScreen<Content: View>: View {
     var layoutOffset: CGFloat
     var inputSearchProps: InputSearchProps?
     var fabProps: FabProps?
+    var screenName: String = ""
     var content: () -> Content
 
     public init(
@@ -66,6 +67,7 @@ public struct StackScreen<Content: View>: View {
         layoutOffset: CGFloat = 56,
         inputSearchProps: InputSearchProps? = nil,
         fabProps: FabProps? = nil,
+        screenName: String = "",
         @ViewBuilder content: @escaping () -> Content
     ) {
         self.backgroundColor = backgroundColor
@@ -92,12 +94,21 @@ public struct StackScreen<Content: View>: View {
         self.layoutOffset = layoutOffset
         self.inputSearchProps = inputSearchProps
         self.fabProps = fabProps
+        self.screenName = screenName
         self.content = content
     }
 
     @State private var scrollOffset: CGFloat = 0
     @State private var keyboardHeight: CGFloat = 0
     @State private var headerRightWidth: CGFloat = 0
+    @State private var isBottomTabRoot: Bool = false
+
+    @Environment(\.applicationEnvironment) private var appEnv
+
+    // Auto-tracking state (mirrors Compose's `remember { ScreenTrackingState() }` +
+    // the once-computed push/back `action`).
+    @State private var trackingState = ScreenTrackingState()
+    @State private var trackingAction: String = ScreenTracker.getLastScreenName() != nil ? "push" : "back"
 
     /// Header background fade tied to scroll: 0 → transparent (over a hero image
     /// or transparent header), 1 → opaque surface with the drop shadow.
@@ -135,7 +146,10 @@ public struct StackScreen<Content: View>: View {
         GeometryReader { geometry in
             let keyboardSize: CGFloat = useAvoidKeyboard ? max(keyboardHeight, 0) : 0
             let bottomInset = min(geometry.safeAreaInsets.bottom, 21)
-            let contentBottomInset = footer == nil ? bottomInset : 0
+            // Skip this screen's own bottom-inset reservation when hosting a footer
+            // OR a self-contained BottomTab surface (mirrors Compose's
+            // `if (options.footerComponent != null || isBottomTab) 0.dp else navigationBar`).
+            let contentBottomInset = (footer == nil && !isBottomTabRoot) ? bottomInset : 0
 
             ZStack(alignment: .top) {
                 // Background color
@@ -175,6 +189,9 @@ public struct StackScreen<Content: View>: View {
             .onPreferenceChange(HeaderRightWidthKey.self) { width in
                 if headerRightWidth != width { headerRightWidth = width }
             }
+            .onPreferenceChange(IsBottomTabRootKey.self) { isRoot in
+                if isBottomTabRoot != isRoot { isBottomTabRoot = isRoot }
+            }
             .onReceive(NotificationCenter.default.publisher(for: UIResponder.keyboardWillChangeFrameNotification)) { notification in
                 guard useAvoidKeyboard,
                       let endFrame = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else { return }
@@ -186,6 +203,37 @@ public struct StackScreen<Content: View>: View {
             // taps still reach buttons/fields while also dismissing the keyboard.
             .modifier(HideKeyboardOnTap(enabled: keyboardShouldPersistTaps))
         }
+        .task(id: screenName) {
+            ScreenTracker.trackScreenNavigated(
+                maxApi: appEnv.maxApi,
+                context: appEnv.applicationContext,
+                screenName: screenName,
+                action: trackingAction,
+                state: trackingState
+            )
+            do {
+                try await Task.sleep(nanoseconds: 2_000_000_000)
+            } catch {
+                return
+            }
+            let loadTime = Date().timeIntervalSince1970 * 1000 - trackingState.time
+            ScreenTracker.trackScreenDisplayed(
+                maxApi: appEnv.maxApi,
+                context: appEnv.applicationContext,
+                screenName: screenName,
+                duration: loadTime,
+                state: trackingState
+            )
+            let interactionTime = Date().timeIntervalSince1970 * 1000 - trackingState.time
+            ScreenTracker.trackScreenInteracted(
+                maxApi: appEnv.maxApi,
+                context: appEnv.applicationContext,
+                screenName: screenName,
+                duration: interactionTime - loadTime,
+                totalDuration: interactionTime,
+                state: trackingState
+            )
+        }
     }
 
     // MARK: - Header + content layer

package/ios/Badge/BadgeRibbon.swift

@@ -196,6 +196,86 @@ public struct BadgeRibbon: View {
     }
 }
 
+/// Ported from Compose's `RoundedBadgeRibbon` (BadgeRibbon.kt:164-326): a canvas-drawn
+/// ribbon shape sized to its text, mirrored per corner via scaleX/scaleY (never an actual
+/// rotation) — the label gets the same scale applied a second time so it stays right-reading
+/// while only the ribbon shape flips.
+public struct RoundedBadgeRibbon: View {
+    let text: String
+    let position: RibbonPosition
+
+    public init(text: String = "Label", position: RibbonPosition = .topLeft) {
+        self.text = text
+        self.position = position
+    }
+
+    private var scale: (x: CGFloat, y: CGFloat) {
+        switch position {
+        case .topLeft: return (-1, 1)
+        case .topRight: return (1, 1)
+        case .bottomRight: return (1, -1)
+        case .bottomLeft: return (-1, -1)
+        }
+    }
+
+    private var measuredTextSize: CGSize {
+        let fontSize = scaleSize(TypographyStyle.labelXsMedium.fontSize)
+        let font = UIFont.systemFont(ofSize: fontSize, weight: .medium)
+        return text.size(withAttributes: [.font: font])
+    }
+
+    public var body: some View {
+        let textSize = measuredTextSize
+        let minRibbonHeight = max(textSize.height * 1.2, 16)
+        let padding = minRibbonHeight / 4
+        let badgeHeight = minRibbonHeight + padding
+        let badgeWidth = max(textSize.width + padding * 2, 28)
+
+        ZStack {
+            Canvas { context, size in
+                let ribbonHeight = size.height - padding
+                let cornerRadius = (badgeHeight - padding) / 2
+                let mainColor = Colors.orange03
+                let tailColor = Colors.red01
+
+                let headWidth: CGFloat = 4
+                // Kotlin computes `leftSectionWidth` + `middleSectionWidth` here, but those
+                // cancel algebraically to `width - headWidth` — kept as the direct result.
+                let rightX = size.width - headWidth
+
+                let leftMiddlePath = RoundedCorners(topLeft: cornerRadius, topRight: 0, bottomLeft: cornerRadius, bottomRight: 0)
+                    .path(in: CGRect(x: 0, y: 0, width: rightX + 1, height: ribbonHeight))
+                context.fill(leftMiddlePath, with: .color(mainColor))
+
+                let headPath = RoundedCorners(topLeft: 0, topRight: cornerRadius, bottomLeft: 0, bottomRight: 0)
+                    .path(in: CGRect(x: rightX, y: 0, width: headWidth, height: ribbonHeight))
+                context.fill(headPath, with: .color(mainColor))
+
+                let halfHeadWidth = headWidth / 2
+                let tailStartX = rightX + headWidth - halfHeadWidth
+                let tailY = ribbonHeight
+                let tailHeight = padding
+
+                context.fill(
+                    Path(CGRect(x: tailStartX, y: tailY, width: halfHeadWidth, height: halfHeadWidth)),
+                    with: .color(mainColor)
+                )
+
+                let tailRightPath = RoundedCorners(topLeft: 0, topRight: tailHeight, bottomLeft: 0, bottomRight: tailHeight)
+                    .path(in: CGRect(x: tailStartX, y: tailY, width: halfHeadWidth, height: tailHeight))
+                context.fill(tailRightPath, with: .color(tailColor))
+            }
+
+            MomoText(text, typography: .labelXsMedium, color: Colors.black01, maxLines: 1)
+                .padding(.bottom, padding)
+                .padding(.horizontal, padding / 2)
+                .scaleEffect(x: scale.x, y: scale.y)
+        }
+        .frame(width: badgeWidth, height: badgeHeight)
+        .scaleEffect(x: scale.x, y: scale.y)
+    }
+}
+
 // MARK: - Constants
 private struct RibbonConstants {
     static let ribbonHeight: CGFloat = 20

package/ios/Button/Button.swift

@@ -39,7 +39,7 @@ public extension ButtonType {
         case .disabled: return theme.colors.background.disable.opacity(loading ? 0.75 : 1)
         case .primary: return theme.colors.primary.opacity(loading ? 0.75 : 1)
         case .secondary: return theme.colors.background.surface.opacity(loading ? 0.75 : 1)
-        case .outline: return theme.colors.background.surface.opacity(loading ? 0.75 : 1)           
+        case .outline: return theme.colors.background.surface.opacity(loading ? 0.75 : 1)
         case .tonal: return theme.colors.background.tonal.opacity(loading ? 0.75 : 1)
         case .danger: return theme.colors.error.primary.opacity(loading ? 0.75 : 1)
         case .text: return .clear
@@ -123,7 +123,6 @@ extension ButtonSize {
         case .large: return .actionDefaultBold
         case .medium: return .actionSBold
         case .small: return .actionXsBold
-        default : return .actionDefaultBold
         }
     }
 }
@@ -162,6 +161,35 @@ public struct Button: View {
         self.useTintColor = useTintColor
     }
 
+    /// Mirrors Kotlin's `Button(iconLeft: String, iconRight: String, ...)`, which resolves
+    /// icons by design-system source name through the shared `Icon` component rather than
+    /// a caller-supplied view. `iconLeft` is required here (unlike Kotlin's `= ""` default)
+    /// solely to keep this initializer unambiguous alongside the `AnyView`-based one above —
+    /// pass `""` explicitly for an icon-right-only button.
+    public init(
+        title: String = "Button",
+        action: @escaping () -> Void,
+        type: ButtonType = .primary,
+        size: ButtonSize = .large,
+        iconLeft: String,
+        iconRight: String = "",
+        isFull: Bool = true,
+        loading: Bool = false,
+        useTintColor: Bool = true
+    ) {
+        self.init(
+            title: title,
+            action: action,
+            type: type,
+            size: size,
+            iconLeft: iconLeft.isEmpty ? nil : AnyView(Icon(source: iconLeft)),
+            iconRight: iconRight.isEmpty ? nil : AnyView(Icon(source: iconRight)),
+            isFull: isFull,
+            loading: loading,
+            useTintColor: useTintColor
+        )
+    }
+
     private func shouldLoadingOnLeft(_ left: AnyView?, _ right: AnyView?) -> Bool {
         let hasLeft = left != nil
         let hasRight = right != nil
@@ -214,14 +242,15 @@ public struct Button: View {
             .frame(maxWidth: isFull ? .infinity : nil)
             .padding(.horizontal, size.padding)
             .frame(height: size.height)
-            .background(bg)
-            .overlay(
-                RoundedRectangle(cornerRadius: size.radius)
-                    .strokeBorder(border ?? .clear, lineWidth: border != nil ? borderWidth : 0)
-            )
-            .clipShape(RoundedRectangle(cornerRadius: size.radius))
         }
-        .buttonStyle(ButtonPressFeedbackStyle(isEnabled: isEnabled))
+        .buttonStyle(ButtonPressFeedbackStyle(
+            isEnabled: isEnabled,
+            background: bg,
+            border: border,
+            borderWidth: borderWidth,
+            radius: size.radius,
+            height: size.height
+        ))
         .disabled(!isEnabled)
     }
 
@@ -238,12 +267,39 @@ public struct Button: View {
     }
 }
 
+/// Mirrors Compose's press feedback: the background shrinks via an animated
+/// horizontal inset while the content fades, rather than a plain opacity dim on
+/// the whole button (matching `animatedPadding`/`alpha` in Button.kt).
 private struct ButtonPressFeedbackStyle: ButtonStyle {
     let isEnabled: Bool
+    let background: Color
+    let border: Color?
+    let borderWidth: CGFloat
+    let radius: CGFloat
+    let height: CGFloat
 
     func makeBody(configuration: Configuration) -> some View {
-        configuration.label
-            .opacity(configuration.isPressed && isEnabled ? 0.5 : 1)
-            .animation(.easeInOut(duration: 0.1), value: configuration.isPressed)
+        let pressed = configuration.isPressed && isEnabled
+
+        ZStack {
+            RoundedRectangle(cornerRadius: radius)
+                .fill(background)
+                .overlay(
+                    RoundedRectangle(cornerRadius: radius)
+                        .strokeBorder(border ?? .clear, lineWidth: border != nil ? borderWidth : 0)
+                )
+                .padding(.horizontal, pressed ? 2 : 0)
+
+            configuration.label
+                .opacity(pressed ? 0.5 : 1)
+        }
+        // Pin the whole button to its intended height explicitly: the bare
+        // RoundedRectangle background has no intrinsic size of its own, so left
+        // unconstrained in a ZStack inside a non-height-constraining container
+        // (e.g. a footer VStack) it can report an oversized ideal height and
+        // stretch the button — and its container — far taller than intended.
+        .frame(height: height)
+        .clipShape(RoundedRectangle(cornerRadius: radius))
+        .animation(.easeInOut(duration: 0.1), value: pressed)
     }
 }

package/ios/Carousel/Carousel.swift

@@ -94,12 +94,27 @@ public struct Carousel<Content: View>: View {
         // Offset so the current page is centered within the viewport padding.
         let baseOffset = -CGFloat(currentPage) * step + contentPadding
 
+        // Windows the rendered range around `currentPage` instead of instantiating all
+        // `virtualPageCount` slides up front — with `loop=true`, that's `itemCount * 1000`
+        // eager views, a real memory/perf regression versus Compose's lazy `HorizontalPager`.
+        // Clear spacers of the skipped width keep the HStack's total layout size (and thus
+        // the existing `baseOffset` math) unchanged.
+        let windowRadius = 3
+        let windowStart = max(0, currentPage - windowRadius)
+        let windowEnd = min(virtualPageCount - 1, currentPage + windowRadius)
+
         ZStack {
             HStack(spacing: 0) {
-                ForEach(0 ..< virtualPageCount, id: \.self) { page in
+                if windowStart > 0 {
+                    Color.clear.frame(width: CGFloat(windowStart) * step)
+                }
+                ForEach(windowStart...windowEnd, id: \.self) { page in
                     slide(page: page, step: step, viewportWidth: viewportWidth)
                         .frame(width: pageWidth)
                 }
+                if windowEnd < virtualPageCount - 1 {
+                    Color.clear.frame(width: CGFloat(virtualPageCount - 1 - windowEnd) * step)
+                }
             }
             .offset(x: baseOffset + dragOffset)
             .animation(isDragging ? nil : .easeInOut(duration: 0.25), value: currentPage)