@momo-kits/foundation 0.89.6 → 0.92.1-rc.1

package/Application/BottomTab/BottomTabBar.tsx

@@ -0,0 +1,507 @@
+import {BottomTabBarProps} from '@react-navigation/bottom-tabs';
+import {LabelPosition} from '@react-navigation/bottom-tabs/src/types';
+import BottomTabBarHeightCallbackContext from '@react-navigation/bottom-tabs/src/utils/BottomTabBarHeightCallbackContext';
+import BottomTabBarItem from '@react-navigation/bottom-tabs/src/views/BottomTabItem';
+import {
+  CommonActions,
+  NavigationContext,
+  NavigationRouteContext,
+  ParamListBase,
+  TabNavigationState,
+  useLinkBuilder,
+  useTheme,
+} from '@react-navigation/native';
+import React, {useCallback} from 'react';
+import {
+  Animated,
+  Dimensions,
+  LayoutChangeEvent,
+  Platform,
+  StyleProp,
+  StyleSheet,
+  TouchableOpacity,
+  useWindowDimensions,
+  View,
+  ViewStyle,
+} from 'react-native';
+import {EdgeInsets, useSafeAreaInsets} from 'react-native-safe-area-context';
+import {Radius} from '../../Consts';
+import {Icon} from '../../Icon';
+import {Text} from '../../Text';
+import {CurvedViewComponent} from './CurvedView';
+import {getPathUp} from './path';
+import {FloatingButtonProps} from '../types';
+const {width} = Dimensions.get('window');
+
+type Props = BottomTabBarProps & {
+  activeTintColor?: string;
+  inactiveTintColor?: string;
+  floatingButton?: FloatingButtonProps;
+};
+
+type Options = {
+  state: TabNavigationState<ParamListBase>;
+  layout: {height: number; width: number};
+  dimensions: {height: number; width: number};
+  tabStyle: StyleProp<ViewStyle>;
+  labelPosition: LabelPosition | undefined;
+  adaptive: boolean | undefined;
+};
+
+const DEFAULT_MAX_TAB_ITEM_WIDTH = 125;
+const DEFAULT_TABBAR_HEIGHT = 49;
+const COMPACT_TABBAR_HEIGHT = 32;
+
+const shouldUseHorizontalLabels = ({
+  state,
+  layout,
+  dimensions,
+  adaptive = true,
+  labelPosition,
+  tabStyle,
+}: Options) => {
+  if (labelPosition) {
+    return labelPosition === 'beside-icon';
+  }
+
+  if (!adaptive) {
+    return false;
+  }
+
+  if (layout.width >= 768) {
+    // Screen size matches a tablet
+    let maxTabItemWidth = DEFAULT_MAX_TAB_ITEM_WIDTH;
+
+    const flattenedStyle = StyleSheet.flatten(tabStyle);
+
+    if (flattenedStyle) {
+      if (typeof flattenedStyle.width === 'number') {
+        maxTabItemWidth = flattenedStyle.width;
+      } else if (typeof flattenedStyle.maxWidth === 'number') {
+        maxTabItemWidth = flattenedStyle.maxWidth;
+      }
+    }
+
+    return state.routes.length * maxTabItemWidth <= layout.width;
+  } else {
+    return dimensions.width > dimensions.height;
+  }
+};
+const getPaddingBottom = (insets: EdgeInsets) =>
+  Math.max(insets.bottom - Platform.select({ios: 4, default: 0}), 0);
+
+export const getTabBarHeight = ({
+  dimensions,
+  insets,
+  style,
+  ...rest
+}: Options & {
+  insets: EdgeInsets;
+  style: Animated.WithAnimatedValue<StyleProp<ViewStyle>>;
+}) => {
+  // @ts-ignore
+  const customHeight = StyleSheet.flatten(style)?.height;
+
+  if (typeof customHeight === 'number') {
+    return customHeight;
+  }
+
+  const isLandscape = dimensions.width > dimensions.height;
+  const horizontalLabels = shouldUseHorizontalLabels({dimensions, ...rest});
+  const paddingBottom = getPaddingBottom(insets);
+
+  if (
+    Platform.OS === 'ios' &&
+    !Platform.isPad &&
+    isLandscape &&
+    horizontalLabels
+  ) {
+    return COMPACT_TABBAR_HEIGHT + paddingBottom;
+  }
+
+  return DEFAULT_TABBAR_HEIGHT + paddingBottom;
+};
+
+export default function BottomTabBar({
+  state,
+  navigation,
+  descriptors,
+  activeBackgroundColor,
+  activeTintColor,
+  adaptive,
+  allowFontScaling,
+  inactiveBackgroundColor,
+  inactiveTintColor,
+  keyboardHidesTabBar = false,
+  labelPosition,
+  labelStyle,
+  iconStyle,
+  safeAreaInsets,
+  showLabel,
+  style,
+  tabStyle,
+  floatingButton,
+}: Props) {
+  const {routes} = state;
+  const dimensions = useWindowDimensions();
+  const isFloating = floatingButton?.icon && state.routes.length == 4;
+  const itemWidth = isFloating
+    ? dimensions.width / 5
+    : dimensions.width / state.routes.length;
+
+  const [layout, setLayout] = React.useState({
+    height: 0,
+    width: dimensions.width,
+  });
+  const buildLink = useLinkBuilder();
+  const {colors} = useTheme();
+
+  const hasHorizontalLabels = shouldUseHorizontalLabels({
+    state,
+    dimensions,
+    layout,
+    adaptive,
+    labelPosition,
+    tabStyle,
+  });
+  const focusedRoute = state.routes[state.index] as any;
+  const focusedDescriptor = descriptors[focusedRoute.key] as any;
+  const focusedOptions = focusedDescriptor.options;
+  const shouldShowTabBar =
+    focusedOptions.tabBarVisible !== false && !keyboardHidesTabBar;
+  const [visible] = React.useState(
+    () => new Animated.Value(shouldShowTabBar ? 1 : 0),
+  );
+
+  const indicatorAnimated = React.useRef(new Animated.Value(0)).current;
+
+  const visibilityAnimationConfigRef = React.useRef(
+    focusedOptions.tabBarVisibilityAnimationConfig,
+  );
+  const onHeightChange = React.useContext(BottomTabBarHeightCallbackContext);
+  const [isTabBarHidden, setIsTabBarHidden] = React.useState(!shouldShowTabBar);
+  React.useEffect(() => {
+    visibilityAnimationConfigRef.current =
+      focusedOptions.tabBarVisibilityAnimationConfig;
+  });
+
+  const handleLayout = (e: LayoutChangeEvent) => {
+    const {height, width} = e.nativeEvent.layout;
+
+    onHeightChange?.(height);
+
+    setLayout(layout => {
+      if (height === layout.height && width === layout.width) {
+        return layout;
+      } else {
+        return {
+          height,
+          width,
+        };
+      }
+    });
+  };
+
+  React.useEffect(() => {
+    const visibilityAnimationConfig = visibilityAnimationConfigRef.current;
+
+    if (shouldShowTabBar) {
+      const animation =
+        visibilityAnimationConfig?.show?.animation === 'spring'
+          ? Animated.spring
+          : Animated.timing;
+
+      animation(visible, {
+        toValue: 1,
+        useNativeDriver: true,
+        duration: 250,
+        ...visibilityAnimationConfig?.show?.config,
+      }).start(({finished}) => {
+        if (finished) {
+          setIsTabBarHidden(false);
+        }
+      });
+    } else {
+      setIsTabBarHidden(true);
+
+      const animation =
+        visibilityAnimationConfig?.hide?.animation === 'spring'
+          ? Animated.spring
+          : Animated.timing;
+
+      animation(visible, {
+        toValue: 0,
+        useNativeDriver: true,
+        duration: 200,
+        ...visibilityAnimationConfig?.hide?.config,
+      }).start();
+    }
+  }, [visible, shouldShowTabBar]);
+  const defaultInsets = useSafeAreaInsets();
+
+  const insets = {
+    top: safeAreaInsets?.top ?? defaultInsets.top,
+    right: safeAreaInsets?.right ?? defaultInsets.right,
+    bottom: safeAreaInsets?.bottom ?? defaultInsets.bottom,
+    left: safeAreaInsets?.left ?? defaultInsets.left,
+  };
+  const paddingBottom = getPaddingBottom(insets);
+
+  const leftArr = routes.slice(0, 2);
+  const rightArr = routes.slice(2, routes.length);
+  const focusedTab = state?.routes[state.index]?.name || routes[0]?.params;
+  const tabBarHeight = getTabBarHeight({
+    state,
+    insets,
+    dimensions,
+    layout,
+    adaptive,
+    labelPosition,
+    tabStyle,
+    style,
+  });
+
+  const renderTabItem = useCallback(
+    (data: any[]) => {
+      return data?.map((route, index) => {
+        const focused = route.params.name === focusedTab;
+        const {options} = descriptors[route.key] as any;
+        const onPress = () => {
+          const event = navigation.emit({
+            type: 'tabPress',
+            target: route.key,
+            canPreventDefault: true,
+          });
+
+          if (!focused && !event.defaultPrevented) {
+            navigation.dispatch({
+              ...CommonActions.navigate(route.name),
+              target: state.key,
+            });
+          }
+        };
+
+        const onLongPress = () => {
+          navigation.emit({
+            type: 'tabLongPress',
+            target: route.key,
+          });
+        };
+
+        const label =
+          options.tabBarLabel !== undefined
+            ? options.tabBarLabel
+            : options.title !== undefined
+            ? options.title
+            : route.name;
+
+        const accessibilityLabel =
+          options.tabBarAccessibilityLabel !== undefined
+            ? options.tabBarAccessibilityLabel
+            : typeof label === 'string'
+            ? `${label}, tab, ${index + 1} of ${routes.length}`
+            : undefined;
+
+        return (
+          <NavigationContext.Provider
+            key={route.key}
+            value={(descriptors as any)[route.key].navigation}>
+            <NavigationRouteContext.Provider value={route}>
+              <BottomTabBarItem
+                route={route}
+                focused={focused}
+                horizontal={hasHorizontalLabels}
+                onPress={onPress}
+                onLongPress={onLongPress}
+                accessibilityLabel={accessibilityLabel}
+                to={buildLink(route.name, route.params)}
+                testID={options.tabBarTestID}
+                allowFontScaling={allowFontScaling}
+                activeTintColor={activeTintColor}
+                inactiveTintColor={inactiveTintColor}
+                activeBackgroundColor={activeBackgroundColor}
+                inactiveBackgroundColor={inactiveBackgroundColor}
+                button={options.tabBarButton}
+                icon={options.tabBarIcon}
+                badge={options.tabBarBadge}
+                badgeStyle={options.tabBarBadgeStyle}
+                label={label}
+                showLabel={showLabel}
+                labelStyle={labelStyle}
+                iconStyle={iconStyle}
+                style={tabStyle}
+              />
+            </NavigationRouteContext.Provider>
+          </NavigationContext.Provider>
+        );
+      });
+    },
+    [JSON.stringify(routes), state, descriptors, focusedTab],
+  );
+
+  const renderCenterComponent = useCallback(() => {
+    const renderFloatingButton = () => {
+      if (typeof floatingButton?.icon == 'string') {
+        return <Icon source={floatingButton?.icon} size={32} color={'white'} />;
+      } else if (floatingButton?.icon) {
+        return floatingButton?.icon;
+      } else {
+        return null;
+      }
+    };
+    if (floatingButton?.icon && state.routes.length !== 4) {
+      console.warn(
+        "Can't render floating button with icon when routes length is not 4",
+      );
+      return null;
+    }
+    return (
+      <View style={{flex: 1}}>
+        <TouchableOpacity
+          onPress={floatingButton?.onPress}
+          style={styles.floatingContainer}>
+          <View
+            style={{
+              ...styles.floatingContent,
+              backgroundColor: activeTintColor ?? colors.primary,
+            }}>
+            {renderFloatingButton()}
+          </View>
+          <View
+            style={{
+              top: -6,
+              backgroundColor: activeTintColor ?? colors.primary,
+              borderRadius: Radius.XL,
+              paddingHorizontal: 6,
+            }}>
+            <Text
+              numberOfLines={1}
+              typography={'description_xs_regular'}
+              color={'white'}>
+              {floatingButton?.label}
+            </Text>
+          </View>
+        </TouchableOpacity>
+      </View>
+    );
+  }, [floatingButton]);
+
+  React.useEffect(() => {
+    Animated.timing(indicatorAnimated, {
+      toValue:
+        isFloating && state.index > 1
+          ? itemWidth * (state.index + 1)
+          : itemWidth * state.index,
+      useNativeDriver: false,
+      duration: 200,
+    }).start();
+  }, [state.index, itemWidth, indicatorAnimated, isFloating]);
+
+  return (
+    <Animated.View
+      style={[
+        styles.tabBar,
+        {
+          backgroundColor: colors.card,
+          borderTopColor: colors.border,
+        },
+        {
+          transform: [
+            {
+              translateY: visible.interpolate({
+                inputRange: [0, 1],
+                outputRange: [
+                  layout.height + paddingBottom + StyleSheet.hairlineWidth,
+                  0,
+                ],
+              }),
+            },
+          ],
+          // Absolutely position the tab bar so that the content is below it
+          // This is needed to avoid gap at bottom when the tab bar is hidden
+          position: isTabBarHidden ? 'absolute' : (null as any),
+        },
+        {
+          // height: tabBarHeight,
+          paddingBottom: paddingBottom - 0,
+          paddingHorizontal: Math.max(insets.left, insets.right),
+        },
+        style,
+      ]}
+      pointerEvents={isTabBarHidden ? 'none' : 'auto'}
+      onLayout={handleLayout}>
+      <View style={styles.content}>
+        {isFloating && (
+          <CurvedViewComponent
+            width={width}
+            height={61 + Math.min(insets.bottom, 21)}
+            style={styles.curved}
+            bgColor="white"
+            path={getPathUp(width, tabBarHeight, 50, false, 'CENTER')}
+          />
+        )}
+        <Animated.View
+          style={{
+            width: itemWidth,
+            position: 'absolute',
+            top: 0,
+            transform: [{translateX: indicatorAnimated}],
+          }}>
+          <View
+            style={[
+              styles.indicator,
+              {backgroundColor: activeTintColor ?? colors.primary},
+            ]}
+          />
+        </Animated.View>
+
+        {renderTabItem(leftArr)}
+        {renderCenterComponent()}
+        {renderTabItem(rightArr)}
+      </View>
+    </Animated.View>
+  );
+}
+
+const styles = StyleSheet.create({
+  curved: {
+    position: 'absolute',
+    bottom: 0,
+    // backgroundColor: 'red',
+  },
+  content: {
+    flex: 1,
+    flexDirection: 'row',
+    // backgroundColor: 'red',
+  },
+  tabBar: {
+    left: 0,
+    right: 0,
+    bottom: 0,
+    borderTopWidth: StyleSheet.hairlineWidth,
+    elevation: 8,
+  },
+  floatingContainer: {
+    position: 'absolute',
+    alignItems: 'center',
+    left: 0,
+    right: 0,
+    bottom: -6,
+  },
+  floatingContent: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    height: 48,
+    width: 48,
+
+    borderRadius: 100,
+    top: -12,
+  },
+  indicator: {
+    height: 2,
+    width: 44,
+    alignSelf: 'center',
+    borderBottomLeftRadius: 1,
+    borderBottomRightRadius: 1,
+  },
+});

package/Application/BottomTab/CurvedView.tsx

@@ -0,0 +1,27 @@
+import React from 'react';
+import {StyleProp, View, ViewStyle} from 'react-native';
+import {Path, Svg} from 'react-native-svg';
+
+interface ICurvedView {
+  style?: StyleProp<ViewStyle>;
+  width: number;
+  height: number;
+  bgColor: string;
+  path: any;
+}
+
+export type CurvedView = React.FC<ICurvedView>;
+
+const CurvedContainer: CurvedView = props => {
+  const {style, width, height, bgColor, path} = props;
+
+  return (
+    <View style={style} pointerEvents="none">
+      <Svg width={width} height={height}>
+        <Path fill={bgColor} {...{d: path}} />
+      </Svg>
+    </View>
+  );
+};
+
+export const CurvedViewComponent: CurvedView = React.memo(CurvedContainer);

package/Application/{BottomTab.tsx → BottomTab/index.tsx}

@@ -1,15 +1,16 @@
-import React, {useContext, useEffect} from 'react';
-import {Platform} from 'react-native';
-import {BottomTabProps, NavigationScreenProps} from './types';
 import {createBottomTabNavigator} from '@react-navigation/bottom-tabs';
+import {NavigationContainer} from '@react-navigation/native';
 import {createStackNavigator} from '@react-navigation/stack';
+import React, {useContext, useEffect} from 'react';
+import {Platform} from 'react-native';
 import {useSafeAreaInsets} from 'react-native-safe-area-context';
-import {NavigationContainer} from '@react-navigation/native';
-import {Icon} from '../Icon';
-import {Text} from '../Text';
-import {ApplicationContext} from './index';
-import {getStackOptions} from './utils';
-import StackScreen from './StackScreen';
+import BottomTabBar from './BottomTabBar';
+import {Icon} from '../../Icon';
+import {Text} from '../../Text';
+import {ApplicationContext} from '../index';
+import {getAccessibilityID, getStackOptions} from '../utils';
+import StackScreen from '../StackScreen';
+import {BottomTabProps, NavigationScreenProps} from '../types';
 
 const Tab = createBottomTabNavigator();
 const Stack = createStackNavigator();
@@ -40,12 +41,14 @@ const TabScreen: React.FC<NavigationScreenProps> = ({route}) => {
     </NavigationContainer>
   );
 };
+
 const BottomTab: React.FC<BottomTabProps> = ({
   nested,
   tabs,
   listeners,
   navigation,
   initialRouteName,
+  floatingButton,
 }) => {
   const {theme} = useContext(ApplicationContext);
   const insets = useSafeAreaInsets();
@@ -60,8 +63,12 @@ const BottomTab: React.FC<BottomTabProps> = ({
 
   return (
     <Tab.Navigator
+      {...getAccessibilityID('tbr_main_bottom')}
       initialRouteName={initialRouteName}
       backBehavior={'firstRoute'}
+      tabBar={props => (
+        <BottomTabBar {...props} floatingButton={floatingButton} />
+      )}
       tabBarOptions={{
         style: {
           height: 68 + Math.min(insets.bottom, 21),
@@ -74,6 +81,7 @@ const BottomTab: React.FC<BottomTabProps> = ({
       {tabs.map(item => {
         return (
           <Tab.Screen
+            {...getAccessibilityID(`btn_tabbar_${item.name}`)}
             key={item.name}
             name={item.name}
             component={TabScreen}