@momo-kits/native-kits 0.300.3-debug → 0.300.4-debug

package/ios/{Application/Navigation/Overplay → Navigation}/BottomSheet.swift

@@ -2,7 +2,7 @@
 //  BottomSheet.swift
 //  MoMoUIKits
 //
-//  SwiftUI mirror of Compose's `BottomSheet` (navigation/BottomSheet.kt).
+//  SwiftUI mirror of Compose's `navigation/BottomSheet.kt`.
 //  A sheet that slides up from the bottom over a dimmed scrim, with a drag
 //  handle, a header (title or custom), a divider and the content body.
 //  Dragging down past a threshold (or tapping the scrim) dismisses it.
@@ -35,16 +35,21 @@ public struct BottomSheetHeader {
 
 // MARK: - Bottom sheet view
 
-@available(iOS 16.0, *)
 struct BottomSheetView<Content: View>: View {
+    let overplayId: UUID
     let header: BottomSheetHeader
     let isSurface: Bool
     let barrierDismissible: Bool
+    var draggable: Bool = true
+    /// Keeps the content above the home indicator (Compose `AppNavigationBar` padding).
+    var useBottomInset: Bool = true
+    var footer: (() -> AnyView)? = nil
     let content: () -> Content
 
     @EnvironmentObject private var navigator: Navigator
     @Environment(\.appTheme) private var theme
     @Environment(\.applicationEnvironment) private var appEnv
+    @Environment(\.screenLayout) private var layout
 
     /// Vertical translation of the sheet; starts off-screen and animates to 0.
     @State private var sheetOffset: CGFloat = UIScreen.main.bounds.height
@@ -52,6 +57,7 @@ struct BottomSheetView<Content: View>: View {
     @State private var backgroundAlpha: CGFloat = 0
     @State private var sheetHeight: CGFloat = 0
     @State private var didAppear = false
+    @State private var isClosing = 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
@@ -66,8 +72,35 @@ struct BottomSheetView<Content: View>: View {
     /// 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() }
+    // UIScreen stays on the outer display on iPhone Duo, even when unfolded
+    private var screenHeight: CGFloat { isDuo ? layout.height : UIScreen.main.bounds.height }
+
+    private var isDuo: Bool { layout.isDuoDevice }
+    // iPhone Duo inner display: center the sheet instead of spanning the width
+    private var isDuoCentered: Bool { isDuo && layout.width >= 600 }
+
+    /// Keeps the portrait width in landscape, like system sheets.
+    private var duoCenteredWidth: CGFloat {
+        min(
+            min(layout.width, layout.height) - Spacing.L * 2,
+            layout.width - max(layout.insets.leading, layout.insets.trailing, Spacing.L) * 2
+        )
+    }
+
+    /// Landscape side buttons span the full height, so the content is inset; in portrait the
+    /// side status bar only covers the top corner.
+    private var sideInsetLeading: CGFloat {
+        isDuo && !isDuoCentered && layout.width > layout.height ? layout.insets.leading : 0
+    }
+
+    private var sideInsetTrailing: CGFloat {
+        isDuo && !isDuoCentered && layout.width > layout.height ? layout.insets.trailing : 0
+    }
+
+    private var maxHeight: CGFloat {
+        isDuo ? layout.height - max(layout.duoTopInset, Spacing.XL) : screenHeight - 90
+    }
+    private var bottomInset: CGFloat { useBottomInset ? safeAreaBottomInset() : 0 }
     /// 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 }
@@ -110,7 +143,7 @@ struct BottomSheetView<Content: View>: View {
         .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
+                keyboardHeight = screenHeight - endFrame.origin.y
             }
         }
         .onAppear {
@@ -128,33 +161,48 @@ struct BottomSheetView<Content: View>: View {
 
     private var sheet: some View {
         VStack(spacing: 0) {
-            // Drag handle + header (the draggable region).
             VStack(spacing: 0) {
-                Spacer().frame(height: 8)
-                Capsule()
-                    .fill(Colors.black06)
-                    .frame(width: 40, height: 4)
-                Spacer().frame(height: 4)
-                headerView
-                    .frame(height: 56)
-                    .padding(.horizontal, Spacing.M)
-            }
-            .frame(maxWidth: .infinity)
-            .frame(height: 72)
-            .contentShape(Rectangle())
-            .gesture(dragGesture)
+                // Drag handle + header (the draggable region).
+                VStack(spacing: 0) {
+                    Spacer().frame(height: 8)
+                    Capsule()
+                        .fill(Colors.black06)
+                        .frame(width: 40, height: 4)
+                    Spacer().frame(height: 4)
+                    headerView
+                        .frame(height: 56)
+                        .padding(.horizontal, Spacing.M)
+                        .padding(.leading, sideInsetLeading)
+                        .padding(.trailing, sideInsetTrailing)
+                }
+                .frame(maxWidth: .infinity)
+                .frame(height: 72)
+                .contentShape(Rectangle())
+                .gesture(dragGesture, including: draggable ? .all : .subviews)
 
-            Rectangle()
-                .fill(theme.colors.border.default)
-                .frame(height: 1)
+                Rectangle()
+                    .fill(theme.colors.border.default)
+                    .frame(height: 1)
 
-            content()
+                content()
+                    .padding(.leading, sideInsetLeading)
+                    .padding(.trailing, sideInsetTrailing)
+                    // a tall sheet keeps its header (and footer) and gives the content what is left
+                    .layoutPriority(-1)
+
+                if let footer {
+                    BottomSheetFooter(content: footer)
+                }
+            }
+            // The filler stays outside the cap, which shrinks by it instead: the sheet still ends at
+            // `maxHeight`, and the iOS 15 fallback never measures the keyboard as content.
+            .modifier(CapHeight(maxHeight: maxHeight - effectiveBottomInset))
 
-            backgroundColor
+            (footer != nil ? theme.colors.background.surface : backgroundColor)
                 .frame(height: effectiveBottomInset)
         }
-        .frame(maxWidth: .infinity)
-        .frame(alignment: .bottom)
+        .frame(maxWidth: isDuoCentered ? duoCenteredWidth : .infinity)
+        .clipped()
         .background(
             GeometryReader { geo in
                 Color.clear.onAppear { sheetHeight = geo.size.height }
@@ -198,14 +246,16 @@ struct BottomSheetView<Content: View>: View {
                 // 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 {
+                // A closing sheet keeps going down.
+                if sheetOffset != 0 && !isClosing {
                     sheetOffset = 0
                 }
             }
             .updating($dragTranslation) { value, state, _ in
-                state = max(value.translation.height, 0)
+                state = isClosing ? 0 : max(value.translation.height, 0)
             }
             .onEnded { value in
+                guard !isClosing else { return }
                 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
@@ -233,6 +283,8 @@ struct BottomSheetView<Content: View>: View {
     /// 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() {
+        guard !isClosing else { return }
+        isClosing = true
         withAnimation(.timingCurve(0.3, 0, 0.8, 0.15, duration: 0.2)) {
             sheetOffset = max(sheetHeight, screenHeight)
         }
@@ -242,12 +294,100 @@ struct BottomSheetView<Content: View>: View {
             }
         }
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
-            navigator.finishOverplayDismiss()
+            navigator.finishOverplayDismiss(id: overplayId)
         }
     }
 }
 
+/// Compose's `heightIn(max:)`. `.frame(maxHeight:)` grows to the cap whenever the proposal is
+/// larger, leaving a gap above the header; this sizes the sheet to its content and only caps it
+/// when taller.
+private struct CapHeight: ViewModifier {
+    let maxHeight: CGFloat
+
+    func body(content: Content) -> some View {
+        if #available(iOS 16.0, *) {
+            CapHeightLayout(maxHeight: maxHeight) { content }
+        } else {
+            content.modifier(CapHeightFallback(maxHeight: maxHeight))
+        }
+    }
+}
+
+/// iOS 15 has no `Layout`: the sheet hugs its ideal height until that outgrows the cap, then is
+/// held at the cap. A capped sheet can't read its ideal height (that needs a second copy of the
+/// content), so it is re-measured only when the cap grows, e.g. once the keyboard goes down.
+private struct CapHeightFallback: ViewModifier {
+    let maxHeight: CGFloat
+    @State private var capped = false
+    @State private var idealHeight: CGFloat = 0
+
+    func body(content: Content) -> some View {
+        content
+            // both modifiers stay in place whatever `capped` is, so the content keeps its identity
+            .fixedSize(horizontal: false, vertical: !capped)
+            .background(
+                GeometryReader { proxy in
+                    Color.clear
+                        .onAppear { measure(proxy.size.height) }
+                        .onChange(of: proxy.size.height) { measure($0) }
+                }
+            )
+            .frame(height: capped ? maxHeight : nil, alignment: .top)
+            .onChange(of: maxHeight) { cap in
+                if capped {
+                    // the ideal height was over the old cap, so only a taller cap can release it
+                    if cap > idealHeight { capped = false }
+                } else if idealHeight > cap {
+                    capped = true
+                }
+            }
+    }
+
+    private func measure(_ height: CGFloat) {
+        guard !capped else { return }
+        idealHeight = height
+        if height > maxHeight { capped = true }
+    }
+}
+
 @available(iOS 16.0, *)
+private struct CapHeightLayout: Layout {
+    let maxHeight: CGFloat
+
+    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
+        guard let subview = subviews.first else { return .zero }
+        let cap = min(maxHeight, proposal.height ?? .infinity)
+        // ideal first: a scroll view would otherwise fill whatever height it is offered
+        let ideal = subview.sizeThatFits(ProposedViewSize(width: proposal.width, height: nil))
+        return subview.sizeThatFits(ProposedViewSize(width: proposal.width, height: min(ideal.height, cap)))
+    }
+
+    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
+        subviews.first?.place(at: bounds.origin, proposal: ProposedViewSize(bounds.size))
+    }
+}
+
+/// Mirrors Compose's `BottomSheetFooter`: a surface band with a soft shadow cast on the content.
+private struct BottomSheetFooter: View {
+    let content: () -> AnyView
+
+    @Environment(\.appTheme) private var theme
+
+    var body: some View {
+        content()
+            .frame(maxWidth: .infinity)
+            .padding(.vertical, Spacing.S)
+            .background(theme.colors.background.surface)
+            .overlay(alignment: .top) {
+                LinearGradient(colors: [.clear, Color.black.opacity(0.05)], startPoint: .top, endPoint: .bottom)
+                    .frame(height: 6)
+                    .offset(y: -6)
+                    .allowsHitTesting(false)
+            }
+    }
+}
+
 private func safeAreaBottomInset() -> CGFloat {
     let bottomInset = UIApplication.shared.connectedScenes
         .compactMap { ($0 as? UIWindowScene)?.keyWindow?.safeAreaInsets.bottom }

package/ios/Navigation/BottomTab/BottomTab.swift

@@ -0,0 +1,332 @@
+//
+//  BottomTab.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `navigation/bottomtab/BottomTab.kt`: tabbed screens, each in
+//  `StackScreen` chrome built from its own `Navigation`, over a `BottomTabBar` (or the iPhone Duo
+//  rail / floating bar). Switching tabs cross-fades + scales the content.
+//
+
+import SwiftUI
+import UIKit
+
+public struct BottomTab: View {
+    private let items: [BottomTabItem]
+    private let floatingButton: BottomTabFloatingButton?
+    private let compressionBehavior: DuoBarCompressionBehavior
+    private let onTabPress: ((_ index: Int, _ switchTab: @escaping () -> Void) -> Void)?
+    private let backToInitialTab: Bool
+
+    @EnvironmentObject private var navigator: Navigator
+    /// The screen hosting the tabs (Compose's `LocalNavigation` in BottomTab).
+    @OptionalEnvironmentObject private var hostNavigation: Navigation?
+    @Environment(\.screenLayout) private var layout
+    @Environment(\.appTheme) private var theme
+    @StateObject private var tabNavigations = TabNavigations()
+    /// Compose's `startRoute`: picked once from `initialRouteName`.
+    @State private var startIndex: Int
+    @State private var selectedIndex: Int
+    @State private var toolbarHeight = DuoBarCompression.defaultToolbarHeight
+    @State private var expandedBar: DuoBar?
+    @State private var openedBar: DuoBar?
+
+    /// `compressionBehavior`: on iPhone Duo, when the side bar can't hold both bars, which one
+    /// starts compressed; tapping the compressed one swaps them.
+    /// `onTabPress` gets every tab press with the switch to perform, e.g. after a login gate.
+    /// `backToInitialTab`: back off another tab returns to the initial one before leaving the screen.
+    public init(
+        items: [BottomTabItem],
+        floatingButton: BottomTabFloatingButton? = nil,
+        compressionBehavior: DuoBarCompressionBehavior = .toolbar,
+        initialRouteName: String? = nil,
+        onTabPress: ((_ index: Int, _ switchTab: @escaping () -> Void) -> Void)? = nil,
+        backToInitialTab: Bool = true
+    ) {
+        self.items = items
+        self.floatingButton = floatingButton
+        self.compressionBehavior = compressionBehavior
+        self.onTabPress = onTabPress
+        self.backToInitialTab = backToInitialTab
+        let start = items.firstIndex { $0.name == initialRouteName } ?? 0
+        _startIndex = State(initialValue: start)
+        _selectedIndex = State(initialValue: start)
+    }
+
+    private var bottomInset: CGFloat { safeAreaBottomInset() }
+    // the Duo bars overlay the content or sit in the side strip, so only the home indicator is kept clear
+    private var reservedBottom: CGFloat {
+        layout.isIPhoneDuo ? layout.insets.bottom : BOTTOM_TAB_BAR_HEIGHT + bottomInset + Spacing.S
+    }
+
+    private var compression: DuoBarCompression {
+        DuoBarCompression.resolve(
+            layout: layout,
+            tabCount: items.count,
+            hasQr: floatingButton != nil,
+            toolbarHeight: toolbarHeight,
+            // 'toolbar' compression keeps the tab bar whole until the toolbar is tapped
+            expanded: Binding(
+                get: { expandedBar ?? (compressionBehavior == .toolbar ? .tabBar : .toolbar) },
+                set: { expandedBar = $0 }
+            ),
+            opened: $openedBar,
+            setToolbarHeight: { height in
+                if toolbarHeight != height { toolbarHeight = height }
+            }
+        )
+    }
+
+    private func duoInsets(_ compression: DuoBarCompression) -> DuoTabBarInsets {
+        layout.duoTabBarInsets(
+            itemCount: items.count,
+            hasFloatingButton: floatingButton != nil,
+            tabBarCompressed: compression.tabBarCompressed
+        )
+    }
+
+    public var body: some View {
+        let compression = compression
+        ZStack(alignment: .bottom) {
+            // Tab content area, inset above the bar.
+            TabHost(selectedIndex: selectedIndex, count: items.count) { index in AnyView(tabScreen(for: index)) }
+                // each tab hosts itself, so it needs the window's safe area to draw its header under the status bar
+                .ignoresSafeArea(.container, edges: [.top, .horizontal])
+                .padding(.bottom, reservedBottom)
+                .environment(\.duoTabBarInsets, duoInsets(compression))
+                .environment(\.duoBarCompression, compression)
+
+            if layout.isIPhoneDuo {
+                DuoTabBar(
+                    items: items,
+                    floatingButton: floatingButton,
+                    selectedIndex: selectedIndex,
+                    onTabSelected: selectTab,
+                    compression: compression
+                )
+            } else {
+                // Tab bar + home-indicator filler.
+                VStack(spacing: 0) {
+                    BottomTabBar(
+                        items: items,
+                        floatingButton: floatingButton,
+                        selectedIndex: selectedIndex,
+                        onTabSelected: selectTab
+                    )
+                    theme.colors.background.surface
+                        .frame(height: bottomInset + Spacing.S)
+                        .ignoresSafeArea(edges: .horizontal)
+                }
+            }
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .ignoresSafeArea(edges: .bottom)
+        .preference(key: IsBottomTabRootKey.self, value: true)
+        .onAppear {
+            hostNavigation?.setOptions {
+                $0.headerType = .none
+                $0.useAvoidKeyboard = false
+            }
+            updateTabBack()
+        }
+        .onChange(of: selectedIndex) { _ in updateTabBack() }
+        .onDisappear {
+            // both live outside this view
+            navigator.tabBackHandler = nil
+            HostBackGestureBridge.shared.shouldUseFloatingArrowBack = false
+        }
+    }
+
+    private func selectTab(_ index: Int) {
+        let switchTab = { if index != selectedIndex { selectedIndex = index } }
+        if let onTabPress { onTabPress(index, switchTab) } else { switchTab() }
+    }
+
+    /// Back off the initial tab returns to it; the host shows its floating arrow there (RN parity).
+    private func updateTabBack() {
+        let isFirstTab = selectedIndex == startIndex || !backToInitialTab
+        HostBackGestureBridge.shared.shouldUseFloatingArrowBack = !isFirstTab
+        navigator.tabBackHandler = isFirstTab ? nil : (hostNavigation?.id ?? -1, { selectedIndex = startIndex })
+    }
+
+    private func tabScreen(for index: Int) -> some View {
+        let item = items[index]
+        return TabScreenHost(
+            navigation: tabNavigations.navigation(for: index, options: item.options),
+            screen: item.screen,
+            goBack: { navigator.onBackSafe() }
+        )
+    }
+}
+
+/// Keeps each tab's `Navigation`, so options a tab set at runtime survive switching away.
+private final class TabNavigations: ObservableObject {
+    private var navigations: [Int: Navigation] = [:]
+
+    func navigation(for index: Int, options: NavigationOptions?) -> Navigation {
+        if let navigation = navigations[index] { return navigation }
+        let navigation = Navigation(bottomTabIndex: index, options: options)
+        navigations[index] = navigation
+        return navigation
+    }
+}
+
+private struct TabScreenHost: View {
+    @ObservedObject var navigation: Navigation
+    let screen: () -> AnyView
+    let goBack: () -> Void
+
+    var body: some View {
+        OptionsStackScreen(
+            options: navigation.options,
+            screenName: navigation.options.screenName ?? "",
+            goBack: goBack,
+            content: screen
+        )
+        .environmentObject(navigation)
+    }
+}
+
+// MARK: - Tab host
+
+/// Compose's tab NavHost with `saveState` / `restoreState`. A tab gets its own UIHostingController
+/// on first selection and keeps it, so its state and scroll survive a switch; while hidden it is
+/// out of the window, so it gets onDisappear / onAppear (and re-runs screen tracking) like a NavHost
+/// destination or a UITabBarController tab. Same scheme as `StackController`.
+private struct TabHost: UIViewControllerRepresentable {
+    let selectedIndex: Int
+    let count: Int
+    let content: (Int) -> AnyView
+
+    func makeUIViewController(context: Context) -> TabController {
+        TabController()
+    }
+
+    func updateUIViewController(_ controller: TabController, context: Context) {
+        controller.update(selectedIndex: selectedIndex, count: count, environment: context.environment, content: content)
+    }
+}
+
+private final class TabController: UIViewController {
+    private final class Tab {
+        let motion = TabMotion()
+        var host: UIHostingController<AnyView>!
+    }
+
+    private static let switchDuration: TimeInterval = 0.2
+
+    private var tabs: [Int: Tab] = [:]
+    private var selectedIndex: Int?
+    private var environment = EnvironmentValues()
+    private var content: (Int) -> AnyView = { _ in AnyView(EmptyView()) }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .clear
+    }
+
+    override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        for subview in view.subviews { subview.frame = view.bounds }
+    }
+
+    func update(
+        selectedIndex index: Int,
+        count: Int,
+        environment: EnvironmentValues,
+        content: @escaping (Int) -> AnyView
+    ) {
+        self.environment = environment
+        self.content = content
+        for (stale, removed) in tabs where stale >= count {
+            tabs[stale] = nil
+            tearDown(removed)
+        }
+        if let selectedIndex, tabs[selectedIndex] == nil { self.selectedIndex = nil }
+        // hidden tabs too, so a tab coming back already shows the latest items and environment
+        for (tabIndex, existing) in tabs { existing.host.rootView = rootView(tabIndex, existing) }
+        guard (0..<count).contains(index), index != selectedIndex else { return }
+
+        let previous = selectedIndex.flatMap { tabs[$0] }
+        selectedIndex = index
+        let selected = tabs[index] ?? makeTab(index)
+        attach(selected)
+
+        guard let previous, view.window != nil else {
+            selected.motion.visible = true
+            previous.map(leave)
+            return
+        }
+        previous.host.view.isUserInteractionEnabled = false
+        // a frame at the start values first, so a tab created just now fades in too
+        DispatchQueue.main.async {
+            selected.motion.visible = true
+            previous.motion.visible = false
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + Self.switchDuration) { [weak self] in
+            self?.leave(previous)
+        }
+    }
+
+    private func makeTab(_ index: Int) -> Tab {
+        let tab = Tab()
+        let host = UIHostingController(rootView: rootView(index, tab))
+        host.view.backgroundColor = .clear
+        addChild(host)
+        host.didMove(toParent: self)
+        tab.host = host
+        tabs[index] = tab
+        return tab
+    }
+
+    private func rootView(_ index: Int, _ tab: Tab) -> AnyView {
+        AnyView(TabCard(motion: tab.motion, content: content(index)).environment(\.self, environment))
+    }
+
+    private func attach(_ tab: Tab) {
+        let hostView: UIView = tab.host.view
+        hostView.isUserInteractionEnabled = true
+        hostView.frame = view.bounds
+        if hostView.superview === view {
+            view.bringSubviewToFront(hostView)
+        } else {
+            view.addSubview(hostView)
+        }
+    }
+
+    /// Off the window once hidden; a tab selected again in the meantime stays.
+    private func leave(_ tab: Tab) {
+        guard selectedIndex.flatMap({ tabs[$0] }) !== tab else { return }
+        tab.host.view.removeFromSuperview()
+    }
+
+    private func tearDown(_ tab: Tab) {
+        tab.host.willMove(toParent: nil)
+        tab.host.view.removeFromSuperview()
+        tab.host.removeFromParent()
+    }
+}
+
+private final class TabMotion: ObservableObject {
+    @Published var visible = false
+}
+
+/// The tab switch: 0.97 scale + fade over 200ms, both ways (Compose's tab enter / exit transitions).
+private struct TabCard: View {
+    @ObservedObject var motion: TabMotion
+    let content: AnyView
+
+    var body: some View {
+        content
+            .opacity(motion.visible ? 1 : 0)
+            .scaleEffect(motion.visible ? 1 : 0.97)
+            .animation(.easeInOut(duration: 0.2), value: motion.visible)
+    }
+}
+
+/// Bottom safe-area inset (home indicator).
+private func safeAreaBottomInset() -> CGFloat {
+    let bottomInset = UIApplication.shared.connectedScenes
+        .compactMap { ($0 as? UIWindowScene)?.keyWindow?.safeAreaInsets.bottom }
+        .first ?? 0
+    return min(bottomInset, 21)
+}