@momo-kits/foundation 0.167.2-beta.1 → 0.168.1-beta.2

package/Application/BottomSheet.tsx

@@ -1,14 +1,24 @@
-import React, { useCallback, useContext, useEffect, useRef } from 'react';
+import React, {
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState,
+} from 'react';
 import {
   BackHandler,
   Dimensions,
+  Keyboard,
   KeyboardAvoidingView,
+  KeyboardEvent,
+  LayoutAnimation,
   Modal,
   PanResponder,
   Platform,
   Pressable,
   StyleSheet,
   TouchableOpacity,
+  useWindowDimensions,
   View,
 } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
@@ -22,22 +32,37 @@ import Animated, {
   Easing,
   Extrapolation,
   interpolate,
-  runOnJS,
   useAnimatedStyle,
   useSharedValue,
   withSpring,
   withTiming,
 } from 'react-native-reanimated';
+import { scheduleOnRN } from 'react-native-worklets';
 import layoutStyles from '../Layout/styles';
+import { getDuoTopInset, isIPhoneDuo } from './device';
+
+// iPhone Duo inner display: center the sheet instead of spanning the width
+const DUO_REGULAR_MIN_WIDTH = 600;
 
 const BottomSheet: React.FC<BottomSheetParams> = props => {
   const { theme, navigator } = useContext(ApplicationContext);
   const context = useContext<any>(MiniAppContext);
-  const heightDevice = Dimensions.get('screen').height;
+  const windowSize = useWindowDimensions();
+  const isDuo = isIPhoneDuo();
+  const isDuoCentered = isDuo && windowSize.width >= DUO_REGULAR_MIN_WIDTH;
+  const isPortrait = windowSize.height > windowSize.width;
+  // 'screen' is the outer display on iPhone Duo, even when unfolded
+  const screenHeight = Dimensions.get('screen').height;
+  const heightDevice = isDuo ? windowSize.height : screenHeight;
   const action = useRef<undefined | string>(undefined);
   const insets = useSafeAreaInsets();
   const heightHeader = useHeaderHeight();
-  const bottomInset = Platform.OS === 'ios' ? Math.min(insets.bottom, 21) : insets.bottom;
+  const topGap = Math.max(
+    getDuoTopInset(insets, windowSize.width, windowSize.height),
+    Spacing.XL,
+  );
+  const isIOS = Platform.OS === 'ios';
+  const bottomInset = isIOS ? Math.min(insets.bottom, 21) : insets.bottom;
   const keyboardOffset = heightHeader - bottomInset;
 
   const showBaseLineDebug = context?.features?.showBaseLineDebug ?? false;
@@ -58,6 +83,43 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
   }: BottomSheetParams = props.route.params;
 
   const translateY = useSharedValue(heightDevice);
+  const [keyboardLift, setKeyboardLift] = useState(0);
+
+  // KeyboardAvoidingView lifts the whole sheet past the top on iPhone Duo,
+  // so lift it here and shrink maxHeight by the same amount instead
+  useEffect(() => {
+    if (!isDuo || !useKeyboardAvoidingView) {
+      return;
+    }
+    const onKeyboardChange = (e: KeyboardEvent) => {
+      const overlap = windowSize.height - e.endCoordinates.screenY;
+      const lift = Math.max(
+        overlap - bottomInset - (keyboardVerticalOffset ?? 0),
+        0,
+      );
+      if (e.duration) {
+        LayoutAnimation.configureNext({
+          duration: e.duration,
+          update: {
+            duration: e.duration,
+            type: LayoutAnimation.Types[e.easing] || 'keyboard',
+          },
+        });
+      }
+      setKeyboardLift(lift);
+    };
+    const subscriptions = [
+      Keyboard.addListener('keyboardWillChangeFrame', onKeyboardChange),
+      Keyboard.addListener('keyboardWillHide', onKeyboardChange),
+    ];
+    return () => subscriptions.forEach(sub => sub.remove());
+  }, [
+    bottomInset,
+    isDuo,
+    keyboardVerticalOffset,
+    useKeyboardAvoidingView,
+    windowSize.height,
+  ]);
 
   const openAnimation = useCallback(() => {
     translateY.value = withTiming(0, {
@@ -74,7 +136,7 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
           duration: 200,
           easing: Easing.bezier(0.3, 0.0, 0.8, 0.15),
         },
-        () => runOnJS(callback)(),
+        () => scheduleOnRN(callback),
       );
     },
     [heightDevice, translateY],
@@ -137,9 +199,9 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
       }
       closeAnimation(() => {
         navigator?.pop();
-        runOnJS(() => {
+        scheduleOnRN(() => {
           callback?.();
-        })();
+        });
       });
     },
     [barrierDismissible, closeAnimation, navigator],
@@ -248,6 +310,22 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
     };
   });
 
+  // landscape side buttons span the full height, so inset the content; in
+  // portrait the side status bar only covers the top corner
+  const needsSideInset = isDuo && !isDuoCentered && !isPortrait;
+  const sideInsetStyle = needsSideInset && {
+    paddingLeft: insets.left,
+    paddingRight: insets.right,
+  };
+
+  const screen = (
+    <Screen
+      {...props}
+      {...props.route.params}
+      onRequestClose={onRequestClose}
+    />
+  );
+
   return (
     <Container
       transparent
@@ -264,7 +342,7 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
           android: undefined,
         })}
         keyboardVerticalOffset={keyboardVerticalOffset ?? keyboardOffset}
-        enabled={useKeyboardAvoidingView}
+        enabled={useKeyboardAvoidingView && !isDuo}
         contentContainerStyle={styles.container}
         style={styles.container}
       >
@@ -287,15 +365,34 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
               borderTopRightRadius: Radius.M,
               overflow: 'hidden',
             },
+            isDuo && {
+              maxHeight: windowSize.height - topGap - keyboardLift,
+              marginBottom: keyboardLift,
+            },
+            isDuoCentered && {
+              // keeps the portrait width in landscape, like system sheets
+              width: Math.min(
+                Math.min(windowSize.width, windowSize.height) - Spacing.L * 2,
+                windowSize.width -
+                  Math.max(insets.left, insets.right, Spacing.L) * 2,
+              ),
+              alignSelf: 'center',
+            },
             showBaseLineDebug && styles.debugBaseLine,
           ]}
         >
-          {renderHeader()}
-          <Screen
-            {...props}
-            {...props.route.params}
-            onRequestClose={onRequestClose}
-          />
+          {isDuo ? (
+            // content shrinks so a tall sheet keeps its header and footer
+            <View style={[styles.shrink, sideInsetStyle]}>
+              {renderHeader()}
+              <View style={styles.shrink}>{screen}</View>
+            </View>
+          ) : (
+            <>
+              {renderHeader()}
+              {screen}
+            </>
+          )}
           {footerComponent && (
             <View
               style={[
@@ -304,6 +401,7 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
                   paddingBottom: Spacing.S,
                   backgroundColor: theme.colors.background.surface,
                 },
+                sideInsetStyle,
               ]}
             >
               {footerComponent}
@@ -353,6 +451,7 @@ const styles = StyleSheet.create({
     justifyContent: 'center',
     marginHorizontal: Spacing.M,
   },
+  shrink: { flexShrink: 1 },
   debugBaseLine: { borderWidth: 1, borderColor: Colors.green_06 },
 });
 

package/Application/BottomTab/BottomTabBar.tsx

@@ -58,11 +58,13 @@ export default function BottomTabBar({
   const { theme } = useContext(ApplicationContext);
   const { routes } = state;
   const widthDevice = useWindowDimensions()?.width;
+  const insets = useSafeAreaInsets();
   const useFloating = floatingButton && state.routes.length % 2 === 0;
-  const itemWidth = widthDevice / (state.routes.length + (useFloating ? 1 : 0));
+  const itemWidth =
+    (widthDevice - insets.left - insets.right) /
+    (state.routes.length + (useFloating ? 1 : 0));
   // const buildLink = useLinkBuilder();
   const indicatorAnimated = useSharedValue(0);
-  const insets = useSafeAreaInsets();
 
   const indicatorStyle = useAnimatedStyle(() => ({
     width: itemWidth,
@@ -246,7 +248,8 @@ export default function BottomTabBar({
         },
         {
           paddingBottom: paddingBottom,
-          paddingHorizontal: Math.max(insets.left, insets.right),
+          paddingLeft: insets.left,
+          paddingRight: insets.right,
         },
         style,
       ]}

package/Application/BottomTab/CustomBottomTabItem.tsx

@@ -116,17 +116,15 @@ const CustomBottomTabItem: React.FC<CustomBottomTabItemProps> = ({
     });
   };
 
+  const background = focused ? activeBackgroundColor : inactiveBackgroundColor;
+
   return (
     <TouchableOpacity
       onPress={onPress}
       onLongPress={onLongPress}
       style={[
         styles.container,
-        {
-          backgroundColor: focused
-            ? activeBackgroundColor
-            : inactiveBackgroundColor,
-        },
+        { backgroundColor: background },
         style,
         showBaseLineDebug && styles.debugBaseLine,
       ]}

package/Application/BottomTab/DuoBarCompression.tsx

@@ -0,0 +1,135 @@
+import React, {
+  createContext,
+  ReactNode,
+  useContext,
+  useMemo,
+  useState,
+} from 'react';
+import { Spacing } from '../../Consts';
+import { useScreenLayout } from '../../Layout';
+import { DuoMetrics } from '../../Layout/utils';
+
+export type DuoBarCompressionBehavior = 'toolbar' | 'tabBar';
+
+type DuoBarCompression = {
+  toolbarCompressed: boolean;
+  tabBarCompressed: boolean;
+  // the open rail needs the toolbar button slot too: only Back stays
+  toolbarHidden?: boolean;
+  // tapping the compressed bar expands it and compresses the other one
+  expandToolbar?: () => void;
+  expandTabBar?: () => void;
+  // a rail opened from the compressed state closes once a tab is picked
+  onTabSelected?: () => void;
+  // header buttons report their full height so the tab bar knows what is left
+  setToolbarHeight?: (height: number) => void;
+};
+
+const RAIL_PADDING = 6;
+const RAIL_GAP = Spacing.XXS;
+// space kept between the top and the bottom groups (HIG Vertical controls)
+const GROUP_GAP = Spacing.M;
+// Back, then the right toolkit: help + home capsule
+const DEFAULT_TOOLBAR_HEIGHT =
+  DuoMetrics.controlSize + Spacing.M + 2 * DuoMetrics.itemPitch;
+// Back, then the single button the toolbar folds into
+const COMPRESSED_TOOLBAR_HEIGHT = 2 * DuoMetrics.controlSize + Spacing.M;
+
+const NO_COMPRESSION: DuoBarCompression = {
+  toolbarCompressed: false,
+  tabBarCompressed: false,
+};
+
+const DuoBarCompressionContext =
+  createContext<DuoBarCompression>(NO_COMPRESSION);
+
+/**
+ * height of the vertical tab rail, plus the QR button under it
+ */
+const getRailHeight = (tabCount: number, hasQr: boolean) =>
+  2 * RAIL_PADDING +
+  tabCount * DuoMetrics.controlSize +
+  Math.max(tabCount - 1, 0) * RAIL_GAP +
+  (hasQr ? Spacing.M + DuoMetrics.controlSize : 0);
+
+/**
+ * keeps the side bar's toolbar and tab bar clear of each other (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)
+ */
+const DuoBarCompressionProvider: React.FC<{
+  behavior?: DuoBarCompressionBehavior;
+  tabCount: number;
+  hasQr: boolean;
+  children: ReactNode;
+}> = ({ behavior = 'toolbar', tabCount, hasQr, children }) => {
+  const { height, sideBar } = useScreenLayout();
+  const [toolbarHeight, setToolbarHeight] = useState(DEFAULT_TOOLBAR_HEIGHT);
+  // 'toolbar' compression keeps the tab bar whole until the toolbar is tapped
+  const [expanded, setExpanded] = useState<'toolbar' | 'tabBar'>(
+    behavior === 'toolbar' ? 'tabBar' : 'toolbar',
+  );
+  // bar opened for a moment while both rest compressed
+  const [opened, setOpened] = useState<'toolbar' | 'tabBar'>();
+
+  const value = useMemo(() => {
+    if (!sideBar) {
+      return NO_COMPRESSION;
+    }
+    const room = height - sideBar.bottom - sideBar.top - GROUP_GAP;
+    const tabBar = getRailHeight(tabCount, hasQr);
+    const compressedTabBar = getRailHeight(1, hasQr) - 2 * RAIL_PADDING;
+    const fits = (toolbar: number, tabs: number) => toolbar + tabs <= room;
+
+    if (fits(toolbarHeight, tabBar)) {
+      return { ...NO_COMPRESSION, setToolbarHeight };
+    }
+    const canSwap =
+      fits(COMPRESSED_TOOLBAR_HEIGHT, tabBar) &&
+      fits(toolbarHeight, compressedTabBar);
+    if (canSwap) {
+      return {
+        toolbarCompressed: expanded === 'tabBar',
+        tabBarCompressed: expanded === 'toolbar',
+        expandToolbar: () => setExpanded('toolbar'),
+        expandTabBar: () => setExpanded('tabBar'),
+        setToolbarHeight,
+      };
+    }
+
+    const open = {
+      expandToolbar: () => setOpened('toolbar'),
+      expandTabBar: () => setOpened('tabBar'),
+      setToolbarHeight,
+    };
+    // an opened rail always shows, even when only the gap between the groups is short:
+    // it closes again once a tab is picked
+    if (opened === 'tabBar') {
+      return {
+        ...open,
+        toolbarCompressed: true,
+        toolbarHidden: true,
+        tabBarCompressed: false,
+        onTabSelected: () => setOpened(undefined),
+      };
+    }
+    return {
+      ...open,
+      toolbarCompressed: opened !== 'toolbar',
+      tabBarCompressed: true,
+    };
+  }, [expanded, opened, hasQr, height, sideBar, tabCount, toolbarHeight]);
+
+  return (
+    <DuoBarCompressionContext.Provider value={value}>
+      {children}
+    </DuoBarCompressionContext.Provider>
+  );
+};
+
+const useDuoBarCompression = () => useContext(DuoBarCompressionContext);
+
+export { DuoBarCompressionProvider, useDuoBarCompression };