@momo-kits/foundation 0.76.1-beta.1 → 0.77.1-optimize.2

package/Application/Components.tsx

@@ -1,81 +1,85 @@
-import React, {useContext, useEffect, useState} from 'react';
+import React, {
+  Fragment,
+  useCallback,
+  useContext,
+  useEffect,
+  useState,
+} from 'react';
 import {
   Animated,
+  BackHandler,
   DeviceEventEmitter,
   StatusBar,
   StyleSheet,
   TouchableOpacity,
   View,
+  ViewStyle,
 } from 'react-native';
-import {ApplicationContext, NavigationButton} from './index';
+import {ApplicationContext, MiniAppContext} from './index';
 import {Colors, Radius, Spacing, Styles} from '../Consts';
 import {Image} from '../Image';
 import {
+  HeaderAnimatedProps,
   HeaderBackgroundProps,
   HeaderBackProps,
-  HeaderToolkitProps,
+  NavigationButtonProps,
   TitleCustomProps,
 } from './types';
 import {scaleSize, Text} from '../Text';
 import {Icon} from '../Icon';
 import {PopupNotify} from '../Popup';
+import {Badge, BadgeDot} from '../Badge';
 
-const styles = StyleSheet.create({
-  headerBackground: {
-    width: '100%',
-    height: undefined,
-    position: 'absolute',
-    aspectRatio: 375 / 154,
-  },
-  headerTitleContainer: {
-    alignItems: 'center',
-    justifyContent: 'center',
-    width: '100%',
-  },
-  circle: {width: 36, height: 36, borderRadius: 18},
-  square: {width: 36, height: 36, borderRadius: Radius.XS},
-  dotAvatar: {
-    position: 'absolute',
-    width: 12,
-    height: 12,
-    borderRadius: 6,
-    bottom: 0,
-    right: 0,
-    borderWidth: 1,
-    borderColor: Colors.black_01,
-  },
-  headerButton: {paddingHorizontal: 4},
-  headerRightButton: {
-    flexDirection: 'row',
-    overflow: 'hidden',
-    justifyContent: 'center',
-    alignItems: 'center',
-    paddingRight: Spacing.S,
-  },
-  toolkitContainer: {
-    marginLeft: Spacing.S,
-    padding: Spacing.XS,
-    height: 28,
-    borderRadius: 14,
-    borderColor: '#00000066',
-    justifyContent: 'center',
-    alignItems: 'center',
-    flexDirection: 'row',
-  },
-  divider: {
-    width: 1,
-    height: 12,
-    marginHorizontal: 4,
-  },
-  headerLeft: {
-    marginLeft: 12,
-  },
-  title: {
-    fontSize: scaleSize(15),
-    lineHeight: scaleSize(22),
-    fontWeight: 'bold',
-  },
-});
+const NavigationButton: React.FC<NavigationButtonProps> = ({
+  icon,
+  tintColor,
+  onPress,
+  useBorder = true,
+  badgeType,
+  badgeValue,
+  accessibilityLabel = '',
+}) => {
+  const {theme} = useContext(ApplicationContext);
+  let buttonStyle: ViewStyle = {backgroundColor: '#00000066'};
+  if (tintColor != Colors.black_01) {
+    buttonStyle = {
+      backgroundColor: 'transparent',
+      borderColor: '#00000066',
+      borderWidth: useBorder ? 0.5 : 0,
+    };
+  }
+
+  const isNumber = (label: any) => {
+    const numberRegex = /^\d+$/;
+    return numberRegex.test(String(label));
+  };
+
+  const renderBadge = useCallback(() => {
+    if (badgeType === 'dot') {
+      return <BadgeDot size="small" style={styles.badgeDot} />;
+    }
+
+    if (isNumber(badgeValue)) {
+      return <Badge label={badgeValue} style={styles.badge} />;
+    }
+  }, [badgeType, badgeValue]);
+
+  return (
+    <View style={{width: scaleSize(28)}}>
+      <TouchableOpacity
+        accessibilityLabel={accessibilityLabel}
+        style={[styles.navigationButton, buttonStyle]}
+        onPress={onPress}>
+        <Icon
+          source={icon}
+          color={tintColor ?? theme.colors.text.default}
+          size={20}
+        />
+      </TouchableOpacity>
+      {renderBadge()}
+    </View>
+  );
+};
 
 const HeaderTitle: React.FC<any> = props => {
   const {theme} = useContext(ApplicationContext);
@@ -88,7 +92,7 @@ const HeaderTitle: React.FC<any> = props => {
   return (
     <Animated.Text
       {...props}
-      accessibilityLabel={`HeaderTitle/${props.children}`}
+      accessibilityLabel={'title_navigation_header'}
       style={[
         styles.title,
         {fontFamily: `${theme.font}-Bold`, opacity, color: props.tintColor},
@@ -100,47 +104,78 @@ const HeaderTitle: React.FC<any> = props => {
 const HeaderLeft: React.FC<HeaderBackProps> = ({
   tintColor,
   preventBack,
+  onPressLeftHeader,
   useBorder,
-  backgroundColor,
 }) => {
+  const context = useContext<any>(MiniAppContext);
   const {navigator} = useContext(ApplicationContext);
-  const goBack = () => {
-    const canGoBack = navigator?.ref.current?.canGoBack();
-    if (canGoBack) {
-      if (preventBack) {
-        navigator?.showModal({
-          screen: () => (
-            <PopupNotify
-              {...preventBack}
-              primary={{
-                title: preventBack.primary.title,
-                onPress: () => {
-                  preventBack?.primary.onPress();
-                  navigator?.ref.current?.goBack();
-                },
-              }}
-            />
-          ),
-        });
+
+  useEffect(() => {
+    const backHandler = BackHandler.addEventListener(
+      'hardwareBackPress',
+      goBackSafe,
+    );
+
+    return () => backHandler.remove();
+  }, []);
+
+  const goBackSafe = () => {
+    const goBack = () => {
+      const canGoBack = navigator?.ref?.current?.canGoBack?.();
+      const currentRoute = navigator?.ref?.current?.getCurrentRoute?.();
+      const params = {
+        appId: context.appId,
+        code: context.code,
+        screen_name: currentRoute?.params?.screen?.name ?? currentRoute?.name,
+        trigger_id: '111154000000000000',
+        icon_name: 'back',
+      };
+      navigator?.maxApi?.showToastDebug?.({
+        appId: `auto - ${context.appId}`,
+        message: 'service_icon_clicked',
+        params,
+      });
+      navigator?.maxApi?.trackEvent?.('service_icon_clicked', params);
+      if (canGoBack) {
+        navigator?.ref?.current?.goBack?.();
+      } else if (navigator?.maxApi) {
+        navigator?.maxApi?.dismiss?.(navigator?.dismissData);
       } else {
-        navigator?.ref.current?.goBack();
+        const currentTime = new Date().getTime();
+        const requestId = `navigationBackPress#${currentTime}`;
+        DeviceEventEmitter.emit('dismiss', {requestId});
       }
+      onPressLeftHeader?.();
+    };
+
+    if (preventBack) {
+      navigator?.showModal({
+        screen: () => (
+          <PopupNotify
+            {...preventBack}
+            primary={{
+              title: preventBack.primary.title,
+              onPress: () => {
+                preventBack?.primary.onPress();
+                goBack();
+              },
+            }}
+          />
+        ),
+      });
     } else {
-      const currentTime = new Date().getTime();
-      const requestId = `navigationBackPress#${currentTime}`;
-      DeviceEventEmitter.emit('dismiss', {requestId});
+      goBack();
     }
+    return true;
   };
-
   return (
     <View style={styles.headerLeft}>
       <NavigationButton
+        accessibilityLabel="btn_navigation_back"
         icon="ic_back"
         tintColor={tintColor}
-        onPress={goBack}
-        accessibilityLabel={'Back'}
+        onPress={goBackSafe}
         useBorder={useBorder}
-        backgroundColor={backgroundColor}
       />
     </View>
   );
@@ -158,7 +193,7 @@ const HeaderBackground: React.FC<HeaderBackgroundProps> = ({
     headerImage = undefined;
   }
   const opacity = animatedValue?.interpolate({
-    inputRange: [0, 200],
+    inputRange: [0, 114],
     outputRange: [0, 1],
     extrapolate: 'clamp',
   });
@@ -177,9 +212,15 @@ const HeaderBackground: React.FC<HeaderBackgroundProps> = ({
       ]}>
       <StatusBar
         barStyle={headerImage || theme.dark ? 'light-content' : 'dark-content'}
+        translucent={true}
+        backgroundColor={'transparent'}
       />
       {!!headerImage && (
-        <Image style={styles.headerBackground} source={{uri: headerImage}} />
+        <Image
+          style={styles.headerBackground}
+          source={{uri: headerImage}}
+          loading={false}
+        />
       )}
     </Animated.View>
   );
@@ -203,11 +244,14 @@ const HeaderCustom: React.FC<TitleCustomProps> = ({
           <View style={[styles.dotAvatar, {backgroundColor: dotColor}]} />
         )}
       </View>
-      <View style={[Styles.flex, Styles.paddingHorizontal8]}>
-        <Text typography="title_xs" color={tintColor}>
+      <View style={[Styles.flex, {paddingHorizontal: 8}]}>
+        <Text
+          accessibilityLabel={'title_navigation_header'}
+          typography="header_default_bold"
+          color={tintColor}>
           {title}
         </Text>
-        <Text typography="description_s" color={tintColor}>
+        <Text typography="description_default_regular" color={tintColor}>
           {subTitle}
         </Text>
       </View>
@@ -217,40 +261,46 @@ const HeaderCustom: React.FC<TitleCustomProps> = ({
 };
 
 const HeaderRightAction: React.FC<any> = ({children, ...restProps}) => {
-  const validType = (item: any) => {
-    if (__DEV__ && item.type !== NavigationButton) {
+  const validateType = (child: React.ReactElement) => {
+    const valid = child?.type === NavigationButton || child?.type == Fragment;
+    if (__DEV__ && !valid) {
       console.warn(
-        'element type of NavigationButton, Please migrate to use NavigationButton of kits.',
+        'HeaderRightAction contains element type of NavigationButton, Please check again.',
       );
-      return <View />;
     }
+    return child;
   };
+
   const renderAction = () => {
     if (Array.isArray(children)) {
       return children.map((child, index) => {
-        validType(child);
         return (
-          <View key={index} style={styles.headerButton}>
-            {React.cloneElement(child, {...restProps})}
+          <View key={`HeaderRightAction ${index}`} style={styles.headerButton}>
+            {React.cloneElement(validateType(child), {...restProps})}
           </View>
         );
       });
     }
 
-    validType(children);
     return (
       <View style={styles.headerButton}>
-        {React.cloneElement(children, {...restProps})}
+        {React.cloneElement(validateType(children), {...restProps})}
       </View>
     );
   };
   return <View style={styles.headerRightButton}>{renderAction()}</View>;
 };
 
-const HeaderToolkitAction: React.FC<any> = ({tintColor}) => {
+const HeaderToolkitAction: React.FC<any> = ({
+  tintColor,
+  pinnedTool,
+  runtimeTools = [],
+  preventClose,
+}) => {
   const {theme, navigator} = useContext(ApplicationContext);
-  const [toolConfig, setToolConfig] = useState<HeaderToolkitProps>();
-  const {appCode, hidden, type, onAction} = toolConfig ?? {};
+  const miniContext = useContext<any>(MiniAppContext);
+  const [toolConfig, setToolConfig] = useState<any>();
+  const {onAction} = toolConfig ?? {};
 
   let backgroundColor;
   if (tintColor != Colors.black_01) {
@@ -258,81 +308,94 @@ const HeaderToolkitAction: React.FC<any> = ({tintColor}) => {
   }
 
   useEffect(() => {
-    navigator?.getToolkit().then((toolConfig: any) => {
-      setToolConfig(toolConfig);
-    });
-  }, []);
-
-  useEffect(() => {
-    let addFavorite: any;
-    let removeFavorite: any;
-    if (appCode) {
-      const addSchema = `observerToolkit_addFavorite_${appCode}`;
-      const removeSchema = `observerToolkit_removeFavorite_${appCode}`;
-      addFavorite = navigator?.requestApi(
-        'observer',
-        [addSchema],
-        (data: any) => {
-          if (data?.status) {
-            setToolConfig({
-              ...(toolConfig as HeaderToolkitProps),
-              hidden: true,
-            });
-          }
-        },
-      );
-      addFavorite = navigator?.requestApi(
-        'observer',
-        [removeSchema],
-        (data: any) => {
-          if (data?.status) {
-            setToolConfig({
-              ...(toolConfig as HeaderToolkitProps),
-              hidden: false,
-            });
-          }
-        },
-      );
+    if (miniContext?.toolkitConfig?.hidden === false) {
+      if (navigator?.toolkitConfig) {
+        setToolConfig(navigator?.toolkitConfig);
+      } else {
+        getToolkitConfig();
+      }
     }
+  }, []);
 
-    return () => {
-      addFavorite?.();
-      removeFavorite?.();
-    };
-  }, [appCode]);
-
-  const onUtilityTool = () => {
-    onAction?.('onUtilityTool');
-    navigator?.requestApi(type, undefined, undefined);
+  const getToolkitConfig = () => {
+    navigator?.maxApi?.dispatchFunction?.(
+      'getToolsConfig',
+      [undefined],
+      (config: any) => {
+        navigator.toolkitConfig = config;
+        setToolConfig(navigator?.toolkitConfig);
+      },
+    );
   };
 
   const onMore = () => {
     onAction?.('onMore');
-    navigator?.requestApi('showToolkit', [toolConfig], undefined);
+    navigator?.maxApi?.dispatchFunction?.(
+      'showTools',
+      {runtimeTools},
+      (res: {item: {action?: string; key: string}}) => {
+        const {item} = res;
+        navigator?.toolkitCallback?.(item);
+        getToolkitConfig();
+      },
+    );
   };
 
   const onClose = () => {
-    onAction?.('onClose');
-    navigator?.requestApi('dismiss', undefined, undefined);
+    if (preventClose) {
+      navigator?.showModal({
+        screen: () => (
+          <PopupNotify
+            {...preventClose}
+            primary={{
+              title: preventClose.primary.title,
+              onPress: () => {
+                preventClose?.primary.onPress();
+                navigator?.maxApi?.dispatchFunction?.(
+                  'dismiss',
+                  undefined,
+                  undefined,
+                );
+              },
+            }}
+          />
+        ),
+      });
+    } else {
+      navigator?.maxApi?.dispatchFunction?.('dismiss', undefined, undefined);
+    }
   };
 
-  const renderUtilityTool = () => {
-    if (hidden === false) {
+  const renderPinnedTool = () => {
+    const pinKey = pinnedTool?.key || toolConfig?.pinnedTool?.key;
+    const pinTool = toolConfig?.tools?.find((i: any) => i.key === pinKey);
+    const {badgeValue, badgeType} = pinnedTool ?? {};
+
+    if (pinTool)
       return (
         <NavigationButton
-          accessibilityLabel={'UtilityTool'}
-          icon={type as string}
+          accessibilityLabel="btn_navigation_pin"
+          icon={pinTool.icon as string}
           tintColor={tintColor}
-          onPress={onUtilityTool}
+          badgeValue={badgeValue}
+          badgeType={badgeType}
+          onPress={() => {
+            navigator?.maxApi?.dispatchFunction?.(
+              'onToolAction',
+              [pinTool?.key],
+              () => {
+                getToolkitConfig();
+              },
+            );
+            navigator?.toolkitCallback?.(pinTool.key);
+          }}
         />
       );
-    }
   };
-
   if (toolConfig) {
     return (
       <View style={styles.headerRightButton}>
-        {renderUtilityTool()}
+        {renderPinnedTool()}
         <View
           style={[
             styles.toolkitContainer,
@@ -342,13 +405,13 @@ const HeaderToolkitAction: React.FC<any> = ({tintColor}) => {
             },
           ]}>
           <TouchableOpacity
-            accessibilityLabel={'Toolkit/More'}
+            accessibilityLabel={'btn_navigation_more'}
             onPress={onMore}>
             <Icon color={tintColor} source="navigation_more_horiz" size={20} />
           </TouchableOpacity>
           <View style={[styles.divider, {backgroundColor: tintColor}]} />
           <TouchableOpacity
-            accessibilityLabel={`Toolkit/Close`}
+            accessibilityLabel={'btn_navigation_close'}
             onPress={onClose}>
             <Icon
               color={tintColor}
@@ -364,11 +427,126 @@ const HeaderToolkitAction: React.FC<any> = ({tintColor}) => {
   return <View />;
 };
 
+const HeaderAnimated: React.FC<HeaderAnimatedProps> = ({
+  animatedValue,
+  image,
+  children,
+}) => {
+  const scale = animatedValue.interpolate({
+    inputRange: [-300, 0, 300],
+    outputRange: [4, 1, 1],
+    extrapolate: 'clamp',
+  });
+  const opacity = animatedValue.interpolate({
+    inputRange: [0, 150, 300],
+    outputRange: [1, 0.5, 0],
+    extrapolate: 'clamp',
+  });
+  const translateY = animatedValue.interpolate({
+    inputRange: [-300, 0],
+    outputRange: [-80, -2],
+    extrapolate: 'clamp',
+  });
+
+  return (
+    <Animated.View
+      style={{
+        height: 210,
+        opacity: opacity,
+        transform: [{scale}, {translateY}],
+      }}>
+      {children ?? (
+        <Image
+          source={{
+            uri: image,
+          }}
+          style={{width: '100%', height: '100%'}}
+        />
+      )}
+    </Animated.View>
+  );
+};
+
+const styles = StyleSheet.create({
+  navigationButton: {
+    height: 28,
+    width: 28,
+    borderRadius: 14,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+  headerBackground: {
+    width: '100%',
+    height: undefined,
+    position: 'absolute',
+    aspectRatio: 375 / 154,
+  },
+  headerTitleContainer: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    width: '100%',
+  },
+  circle: {width: 36, height: 36, borderRadius: 18},
+  square: {width: 36, height: 36, borderRadius: Radius.XS},
+  dotAvatar: {
+    position: 'absolute',
+    width: 12,
+    height: 12,
+    borderRadius: 6,
+    bottom: 0,
+    right: 0,
+    borderWidth: 1,
+    borderColor: Colors.black_01,
+  },
+  headerButton: {paddingHorizontal: 4},
+  headerRightButton: {
+    flexDirection: 'row',
+    justifyContent: 'center',
+    alignItems: 'center',
+    paddingRight: Spacing.S,
+  },
+  toolkitContainer: {
+    marginLeft: Spacing.S,
+    padding: Spacing.XS,
+    height: 28,
+    borderRadius: 14,
+    borderColor: '#00000066',
+    justifyContent: 'center',
+    alignItems: 'center',
+    flexDirection: 'row',
+  },
+  divider: {
+    width: 1,
+    height: 12,
+    marginHorizontal: 4,
+  },
+  headerLeft: {
+    marginLeft: 12,
+  },
+  title: {
+    fontSize: scaleSize(15),
+    lineHeight: scaleSize(22),
+    fontWeight: 'bold',
+  },
+  badge: {
+    position: 'absolute',
+    top: -Spacing.S,
+    right: -6,
+  },
+  badgeDot: {
+    position: 'absolute',
+    top: -Spacing.XS,
+    right: -Spacing.XS,
+  },
+});
+
 export {
+  NavigationButton,
   HeaderTitle,
   HeaderLeft,
   HeaderBackground,
   HeaderRightAction,
   HeaderToolkitAction,
   HeaderCustom,
+  HeaderAnimated,
 };