@momo-kits/foundation 0.169.6-beta.1 → 0.169.6

package/Application/BottomSheet.hooks.ts

@@ -51,8 +51,10 @@ export const useBottomSheetLayout = () => {
   };
 };
 
-// KeyboardAvoidingView lifts the whole sheet past the top on iPhone Duo,
-// so lift it here and shrink maxHeight by the same amount instead
+/**
+ * Keyboard lift of the sheet on iPhone Duo, where KeyboardAvoidingView pushes
+ * the whole sheet past the top; the sheet lifts by it and shrinks its maxHeight.
+ */
 export const useDuoKeyboardLift = (
   isDuo: boolean,
   useKeyboardAvoidingView: boolean,
@@ -136,6 +138,10 @@ type SheetDismissParams = {
   action: MutableRefObject<undefined | string>;
 };
 
+/**
+ * Close handlers of a bottom sheet. A non-forced dismiss (scrim tap, hardware
+ * back) is ignored while `barrierDismissible` is set.
+ */
 export const useSheetDismiss = ({
   barrierDismissible,
   closeAnimation,
@@ -143,9 +149,6 @@ export const useSheetDismiss = ({
   leftOptions,
   action,
 }: SheetDismissParams) => {
-  /**
-   * handler dismiss
-   */
   const onDismiss = useCallback(
     (force = false, callback?: () => void) => {
       if (barrierDismissible && !force) {
@@ -161,9 +164,6 @@ export const useSheetDismiss = ({
     [barrierDismissible, closeAnimation, navigator],
   );
 
-  /**
-   * on request close
-   */
   const onRequestClose = useCallback(
     (callback?: () => void) => {
       onDismiss(true, callback);

package/Application/BottomSheet.parts.tsx

@@ -34,42 +34,52 @@ export const renderSheetHeader = ({
   iconBack,
   options,
   leftOptions,
-}: SheetHeaderParams) => (
-  <View {...panHandlers}>
-    <View style={{ height: INDICATOR_HEIGHT }}>
-      <View style={styles.indicator} />
-    </View>
-    <View
-      style={[
-        styles.header,
-        useDivider && styles.headerDivider,
-        useDivider && {
-          borderBottomColor: theme.colors.border.default,
-        },
-      ]}
-    >
-      {showBack ? (
-        <ModalIconButton icon={iconBack} onPress={onPressBack} />
-      ) : null}
+}: SheetHeaderParams) => {
+  let backButton: React.ReactNode = null;
+  if (showBack) {
+    backButton = <ModalIconButton icon={iconBack} onPress={onPressBack} />;
+  }
 
-      {options.header ? (
-        <View style={Styles.flex}>{options.header}</View>
-      ) : (
-        <>
-          {!leftOptions ? <View style={styles.iconButtonSpace} /> : null}
-          <Text
-            style={[Styles.flex, styles.title]}
-            numberOfLines={1}
-            typography="header_default_bold"
-          >
-            {options.title ?? ''}
-          </Text>
-        </>
-      )}
-      <ModalIconButton icon="navigation_close" onPress={onPressClose} />
+  let headerContent: React.ReactNode;
+  if (options.header) {
+    headerContent = <View style={Styles.flex}>{options.header}</View>;
+  } else {
+    headerContent = (
+      <>
+        {!leftOptions ? <View style={styles.iconButtonSpace} /> : null}
+        <Text
+          style={[Styles.flex, styles.title]}
+          numberOfLines={1}
+          typography="header_default_bold"
+        >
+          {options.title ?? ''}
+        </Text>
+      </>
+    );
+  }
+
+  return (
+    <View {...panHandlers}>
+      <View style={{ height: INDICATOR_HEIGHT }}>
+        <View style={styles.indicator} />
+      </View>
+      <View
+        style={[
+          styles.header,
+          useDivider && styles.headerDivider,
+          useDivider && {
+            borderBottomColor: theme.colors.border.default,
+          },
+        ]}
+      >
+        {backButton}
+
+        {headerContent}
+        <ModalIconButton icon="navigation_close" onPress={onPressClose} />
+      </View>
     </View>
-  </View>
-);
+  );
+};
 
 /**
  * Footer pinned under the sheet content, `null` when the sheet has none.

package/Application/BottomSheet.tsx

@@ -30,6 +30,10 @@ import {
   renderSheetHeader,
 } from './BottomSheet.parts';
 
+/**
+ * Bottom sheet route of the modal stack: slides the given screen up under a
+ * drag handle and header, and reports how it was closed through `onDismiss`.
+ */
 const BottomSheet: React.FC<BottomSheetParams> = props => {
   const { theme, navigator } = useContext(ApplicationContext);
   const context = useContext<any>(MiniAppContext);
@@ -98,8 +102,9 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
   const panResponder = useRef(
     PanResponder.create({
       onStartShouldSetPanResponder: () => draggable,
-      onMoveShouldSetPanResponder: (_, gestureState) =>
-        draggable && gestureState.dy > 0,
+      onMoveShouldSetPanResponder: (_, gestureState) => {
+        return draggable && gestureState.dy > 0;
+      },
       onPanResponderMove: (_, gestureState) => {
         if (gestureState.dy > 0) {
           translateY.value = gestureState.dy;
@@ -131,10 +136,7 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
     backgroundColor = theme.colors.background.surface;
   }
 
-  /**
-   * emit dismiss event, once: folding or rotating iPhone Duo changes the
-   * window height while the sheet stays open
-   */
+  // Mount only, so folding or rotating iPhone Duo doesn't emit a dismiss.
   useEffect(() => {
     openAnimation();
     return () => {
@@ -142,14 +144,14 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
     };
   }, [openAnimation]);
 
-  const { onDismiss, onRequestClose, onPressBack, onPressClose } =
-    useSheetDismiss({
-      barrierDismissible,
-      closeAnimation,
-      navigator,
-      leftOptions,
-      action,
-    });
+  const handlers = useSheetDismiss({
+    barrierDismissible,
+    closeAnimation,
+    navigator,
+    leftOptions,
+    action,
+  });
+  const { onDismiss, onRequestClose, onPressBack, onPressClose } = handlers;
 
   const showBack = !!leftOptions?.onPressIconLeft;
   const iconBack = leftOptions?.iconLeft ?? 'ic_back';
@@ -180,6 +182,24 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
     />
   );
 
+  let content: React.ReactNode;
+  if (isFoldable) {
+    // Content shrinks so a tall sheet keeps its header and footer.
+    content = (
+      <View style={styles.shrink}>
+        {renderSheetHeader(headerParams)}
+        <View style={styles.shrink}>{screen}</View>
+      </View>
+    );
+  } else {
+    content = (
+      <>
+        {renderSheetHeader(headerParams)}
+        {screen}
+      </>
+    );
+  }
+
   return (
     <Container
       transparent
@@ -225,18 +245,7 @@ const BottomSheet: React.FC<BottomSheetParams> = props => {
             }),
           ]}
         >
-          {isFoldable ? (
-            // content shrinks so a tall sheet keeps its header and footer
-            <View style={styles.shrink}>
-              {renderSheetHeader(headerParams)}
-              <View style={styles.shrink}>{screen}</View>
-            </View>
-          ) : (
-            <>
-              {renderSheetHeader(headerParams)}
-              {screen}
-            </>
-          )}
+          {content}
           {renderSheetFooter({ footerComponent, theme })}
           {useBottomInset && (
             <View

package/Application/BottomTab/ActiveIndicator.tsx

@@ -19,8 +19,8 @@ type Props = {
 };
 
 /**
- * one active indicator per bar (Background/tonal with its inner shadows) sliding to the
- * selected item; it lands in place on the first measure and slides from then on
+ * The single active indicator of a bar (Background/tonal with inner shadows) that slides
+ * to the selected item. It lands in place on the first measure and slides from then on.
  */
 const ActiveIndicator: React.FC<Props> = ({
   axis,
@@ -49,18 +49,19 @@ const ActiveIndicator: React.FC<Props> = ({
     position.value = withTiming(offset, TabBarMotion.indicator);
   }, [offset, extent, position, size, visible]);
 
-  const animatedStyle = useAnimatedStyle(() =>
-    axis === 'x'
-      ? {
-          opacity: visible.value,
-          width: size.value,
-          transform: [{ translateX: position.value }],
-        }
-      : {
-          opacity: visible.value,
-          transform: [{ translateY: position.value }],
-        },
-  );
+  const animatedStyle = useAnimatedStyle(() => {
+    if (axis === 'x') {
+      return {
+        opacity: visible.value,
+        width: size.value,
+        transform: [{ translateX: position.value }],
+      };
+    }
+    return {
+      opacity: visible.value,
+      transform: [{ translateY: position.value }],
+    };
+  });
 
   return (
     <Animated.View

package/Application/BottomTab/BottomTabBar.styles.ts

@@ -2,20 +2,6 @@ import { StyleSheet } from 'react-native';
 import { Colors, Spacing } from '../../Consts';
 import { CTA_SHADOW, TabBarMetrics } from './metrics';
 
-const ITEM_HEIGHT =
-  TabBarMetrics.indicatorHeight +
-  TabBarMetrics.itemIconLabelGap +
-  TabBarMetrics.labelHeight;
-const CONTENT_HEIGHT = TabBarMetrics.height - 2 * TabBarMetrics.paddingVertical;
-// the items are centered in the content, so their label starts this far below the content top
-const ITEM_LABEL_TOP =
-  (CONTENT_HEIGHT - ITEM_HEIGHT) / 2 +
-  TabBarMetrics.indicatorHeight +
-  TabBarMetrics.itemIconLabelGap;
-// the center action column is placed so its label starts on the same line as the tab labels
-const CTA_TOP =
-  ITEM_LABEL_TOP - TabBarMetrics.ctaLabelGap - TabBarMetrics.ctaSize;
-
 export const styles = StyleSheet.create({
   bar: {
     position: 'absolute',
@@ -51,7 +37,7 @@ export const styles = StyleSheet.create({
     position: 'absolute',
     left: 0,
     right: 0,
-    top: CTA_TOP,
+    top: -TabBarMetrics.ctaLift - TabBarMetrics.paddingVertical,
     alignItems: 'center',
     gap: TabBarMetrics.ctaLabelGap,
   },
@@ -60,9 +46,6 @@ export const styles = StyleSheet.create({
     width: TabBarMetrics.ctaSize,
     height: TabBarMetrics.ctaSize,
     borderRadius: TabBarMetrics.ctaSize / 2,
-    // Figma Icon Button border: white 60% hairline
-    borderWidth: 1,
-    borderColor: `rgba(255, 255, 255, ${TabBarMetrics.ctaBorderOpacity})`,
     alignItems: 'center',
     justifyContent: 'center',
   },

package/Application/BottomTab/BottomTabBar.tsx

@@ -26,24 +26,28 @@ type Props = BottomTabBarProps & {
 };
 
 /**
- * the center action needs a tab on each side: Special type takes 2 or 4 tabs
+ * Whether the bar shows the center action. It needs a tab on each side, so the
+ * Special type takes 2 or 4 tabs.
  */
-const hasCenterAction = (floatingButton: unknown, tabCount: number) =>
-  !!floatingButton && tabCount % 2 === 0;
+const hasCenterAction = (floatingButton: unknown, tabCount: number) => {
+  return !!floatingButton && tabCount % 2 === 0;
+};
 
 /**
- * gap under the container: the home indicator / gesture bar area
+ * Gap under the bar container for the home indicator / gesture bar area, at
+ * least `Spacing.S`; iOS caps it at the indicator height.
  */
-const getSystemIndicatorHeight = (bottomInset: number) =>
-  Math.max(
-    Platform.OS === 'ios'
-      ? Math.min(bottomInset, TabBarMetrics.systemIndicatorHeight)
-      : bottomInset,
-    Spacing.S,
-  );
+const getSystemIndicatorHeight = (bottomInset: number) => {
+  let height = bottomInset;
+  if (Platform.OS === 'ios') {
+    height = Math.min(bottomInset, TabBarMetrics.systemIndicatorHeight);
+  }
+  return Math.max(height, Spacing.S);
+};
 
 /**
- * center action press: the button shrinks while held; the label stays plain text
+ * Press feedback of the center action: the button shrinks while held, the label
+ * stays still.
  */
 const useCenterActionPress = () => {
   const scale = useSharedValue(1);
@@ -63,25 +67,27 @@ const useCenterActionPress = () => {
 };
 
 /**
- * center action (.Nav/CTA): button rising out of the notch, label under it
+ * Center action (.Nav/CTA): a button rising out of the notch, its label below
+ * (growing downward when scaled).
  */
-const CenterAction: React.FC<{
-  floatingButton: FloatingButtonProps;
-}> = ({ floatingButton }) => {
+const CenterAction: React.FC<{ floatingButton: FloatingButtonProps }> = ({
+  floatingButton,
+}) => {
   const { theme } = useContext(ApplicationContext);
   const context = useContext<any>(MiniAppContext);
   const showBaseLineDebug = context?.features?.showBaseLineDebug ?? false;
   const { icon, label, onPress, labelContent } = floatingButton;
   const { buttonStyle, onPressIn, onPressOut } = useCenterActionPress();
-  const labelText = (
-    <Text
-      numberOfLines={1}
-      typography={'label_s_medium'}
-      color={theme.colors.text.secondary}
-    >
-      {label}
-    </Text>
-  );
+  let iconNode = icon;
+  if (typeof icon === 'string') {
+    iconNode = (
+      <Icon
+        source={icon}
+        size={TabBarMetrics.ctaIconSize}
+        color={Colors.black_01}
+      />
+    );
+  }
 
   return (
     <View style={[styles.ctaSlot, showBaseLineDebug && styles.debugBaseLine]}>
@@ -100,18 +106,16 @@ const CenterAction: React.FC<{
             buttonStyle,
           ]}
         >
-          {typeof icon === 'string' ? (
-            <Icon
-              source={icon}
-              size={TabBarMetrics.ctaIconSize}
-              color={Colors.black_01}
-            />
-          ) : (
-            icon
-          )}
+          {iconNode}
         </Animated.View>
         <View style={styles.ctaLabel}>
-          {labelText}
+          <Text
+            numberOfLines={1}
+            typography={'label_s_medium'}
+            color={theme.colors.text.secondary}
+          >
+            {label}
+          </Text>
           {labelContent && (
             <View pointerEvents={'none'} style={styles.ctaLabelOverlay}>
               {labelContent}
@@ -124,8 +128,8 @@ const CenterAction: React.FC<{
 };
 
 /**
- * horizontal navigation bar: floating container, items split evenly, Special type puts
- * the center action in a notch in the middle
+ * Horizontal navigation bar: a floating container with evenly split items; the
+ * Special type puts the center action in a notch in the middle.
  */
 const HorizontalTabBar: React.FC<{
   items: TabItem[];
@@ -133,21 +137,15 @@ const HorizontalTabBar: React.FC<{
   activeTintColor: string;
   inactiveTintColor: string;
   floatingButton?: FloatingButtonProps;
-}> = ({
-  items,
-  width,
-  activeTintColor,
-  inactiveTintColor,
-  floatingButton,
-}) => {
+}> = ({ items, width, activeTintColor, inactiveTintColor, floatingButton }) => {
   const withCta = hasCenterAction(floatingButton, items.length);
   const [layouts, setLayouts] = useState<
     Record<string, { x: number; y: number; width: number }>
   >({});
   const selected = layouts[items.find(item => item.focused)?.route.key ?? ''];
 
-  const renderItems = (data: TabItem[]) =>
-    data.map(item => (
+  const renderItems = (data: TabItem[]) => {
+    return data.map(item => (
       <CustomBottomTabItem
         key={item.route.key}
         onLayout={e => {
@@ -167,6 +165,7 @@ const HorizontalTabBar: React.FC<{
         inactiveTintColor={inactiveTintColor}
       />
     ));
+  };
 
   const renderContent = () => {
     if (withCta && floatingButton) {
@@ -182,17 +181,21 @@ const HorizontalTabBar: React.FC<{
     return renderItems(items);
   };
 
+  const customContainer = withCta && floatingButton?.container;
+
   return (
     <View
       style={[styles.container, { width }]}
       accessibilityLabel={'bottom_tab_bar'}
     >
-      <CurvedContainer
-        width={width}
-        height={TabBarMetrics.height}
-        radius={TabBarMetrics.height / 2}
-        notchCenterX={withCta ? width / 2 : undefined}
-      />
+      {customContainer || (
+        <CurvedContainer
+          width={width}
+          height={TabBarMetrics.height}
+          radius={TabBarMetrics.height / 2}
+          notchCenterX={withCta ? width / 2 : undefined}
+        />
+      )}
       <View style={styles.content}>
         <ActiveIndicator
           axis={'x'}
@@ -211,9 +214,9 @@ const HorizontalTabBar: React.FC<{
 };
 
 /**
- * phone tab bar: the horizontal navigation bar floating over the tab content above the home
- * indicator, so the content shows around it and through the notch. The transparent strip
- * above it keeps the rising center action touchable
+ * Phone tab bar: the horizontal bar floats over the tab content above the home indicator,
+ * so content shows around it and through the notch. The transparent strip above it keeps
+ * the rising center action touchable.
  */
 export default function BottomTabBar(props: Props) {
   const { state, floatingButton, activeTintColor, inactiveTintColor } = props;
@@ -225,8 +228,6 @@ export default function BottomTabBar(props: Props) {
     window.height,
     insets.left,
     insets.right,
-    state.routes.length,
-    withCta,
   );
 
   return (

package/Application/BottomTab/BottomTabInset.tsx

@@ -1,11 +1,15 @@
 import { createContext } from 'react';
 
 type BottomTabInset = {
-  // space the floating tab bar takes over the bottom of a tab's content (bar + home
-  // indicator area, plus the rising center action when shown); 0 on the iPhone Duo rail
+  /**
+   * Space the floating tab bar takes over the bottom of a tab's content (bar + home
+   * indicator area, plus the rising center action when shown); 0 on the iPhone Duo rail.
+   */
   inset: number;
-  // a Screen in the tab keeps its content clear of the bar itself (inside its scroll view,
-  // or above the bar when static), so the tab stops padding its content
+  /**
+   * Called by a Screen in the tab that keeps its content clear of the bar itself (inside
+   * its scroll view, or above the bar when static), so the tab stops padding its content.
+   */
   claim?: () => void;
 };
 

package/Application/BottomTab/CurvedContainer.tsx

@@ -3,7 +3,7 @@ import { StyleSheet } from 'react-native';
 import Svg, { Defs, FeGaussianBlur, Filter, Path } from 'react-native-svg';
 import { Colors } from '../../Consts';
 import { ApplicationContext } from '../../Context';
-import { NOTCH_CURVES, NOTCH_HALF_WIDTH, TabBarMetrics } from './metrics';
+import { NOTCH_CURVES, NOTCH_HALF_WIDTH } from './metrics';
 
 type Props = {
   width: number;
@@ -15,16 +15,18 @@ type Props = {
 
 // room for the floating shadow around the shape: the key shadow reaches 12 + 3 × 16 below it
 const SHADOW_PADDING = 64;
-// Figma Shadow/floating: 12% blur 24, plus 4% blur 32 spread -16 offset 12; svg blur takes
-// half the CSS blur radius, the spread shrinks the shape the key shadow is cast from
+/**
+ * Figma Shadow/floating: 12% blur 24, plus 4% blur 32 spread -16 offset 12. SVG blur takes
+ * half the CSS blur radius; the spread shrinks the shape the key shadow is cast from.
+ */
 const AMBIENT_BLUR = 12;
 const KEY_BLUR = 16;
 const KEY_SPREAD = 16;
 const KEY_OFFSET_Y = 12;
 
 /**
- * rounded container path placed at (`x`, `y`) on the canvas, with the notch dipped into the
- * top edge around `notchCenterX`
+ * SVG path of the rounded container placed at (`x`, `y`) on the canvas, with the notch
+ * dipped into the top edge around `notchCenterX`.
  */
 const getContainerPath = (
   width: number,
@@ -43,11 +45,10 @@ const getContainerPath = (
   if (notchCenterX !== undefined) {
     const cx = x + notchCenterX;
     const point = ([dx, dy]: [number, number]) => `${cx + dx} ${top + dy}`;
-    notch =
-      ` L ${cx - NOTCH_HALF_WIDTH} ${top}` +
-      NOTCH_CURVES.map(
-        ([c1, c2, end]) => ` C ${point(c1)} ${point(c2)} ${point(end)}`,
-      ).join('');
+    const curves = NOTCH_CURVES.map(([c1, c2, end]) => {
+      return ` C ${point(c1)} ${point(c2)} ${point(end)}`;
+    });
+    notch = ` L ${cx - NOTCH_HALF_WIDTH} ${top}${curves.join('')}`;
   }
   return (
     `M ${left + r} ${top}` +
@@ -64,8 +65,8 @@ const getContainerPath = (
 };
 
 /**
- * navigation bar container: surface fill with the floating shadow, drawn as a shape so
- * the shadow follows the notch
+ * Navigation bar container: surface fill with the floating shadow, drawn as an SVG shape
+ * so the shadow follows the notch.
  */
 const CurvedContainer: React.FC<Props> = ({
   width,
@@ -87,6 +88,7 @@ const CurvedContainer: React.FC<Props> = ({
     SHADOW_PADDING,
     notchCenterX,
   );
+  const hasKeyShadow = width > 2 * KEY_SPREAD && height > 2 * KEY_SPREAD;
 
   return (
     <Svg
@@ -123,7 +125,7 @@ const CurvedContainer: React.FC<Props> = ({
         fillOpacity={0.12}
         filter={'url(#ambientShadow)'}
       />
-      {width > 2 * KEY_SPREAD && height > 2 * KEY_SPREAD && (
+      {hasKeyShadow && (
         <Path
           d={getContainerPath(
             width - 2 * KEY_SPREAD,
@@ -137,13 +139,7 @@ const CurvedContainer: React.FC<Props> = ({
           filter={'url(#keyShadow)'}
         />
       )}
-      <Path
-        d={path}
-        fill={theme.colors.background.surface}
-        fillOpacity={TabBarMetrics.backgroundOpacity}
-        stroke={theme.colors.border.default}
-        strokeWidth={1}
-      />
+      <Path d={path} fill={theme.colors.background.surface} />
     </Svg>
   );
 };