@momo-kits/foundation 0.75.1-beta.9 → 0.75.3-beta.0

package/Application/Components.tsx

@@ -0,0 +1,555 @@
+import React, {
+  Fragment,
+  useCallback,
+  useContext,
+  useEffect,
+  useState,
+} from 'react';
+import {
+  Animated,
+  BackHandler,
+  DeviceEventEmitter,
+  StatusBar,
+  StyleSheet,
+  TouchableOpacity,
+  View,
+  ViewStyle,
+} from 'react-native';
+import {ApplicationContext, MiniAppContext} from './index';
+import {Colors, Radius, Spacing, Styles} from '../Consts';
+import {Image} from '../Image';
+import {
+  HeaderAnimatedProps,
+  HeaderBackgroundProps,
+  HeaderBackProps,
+  NavigationButtonProps,
+  TitleCustomProps,
+} from './types';
+import {scaleSize, Text} from '../Text';
+import {Icon} from '../Icon';
+import {PopupNotify} from '../Popup';
+import {Badge, BadgeDot} from '../Badge';
+
+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);
+  const opacity = props.animatedValue?.interpolate({
+    inputRange: [0, 200],
+    outputRange: [0, 1],
+    extrapolate: 'clamp',
+  });
+
+  return (
+    <Animated.Text
+      {...props}
+      accessibilityLabel={'title_navigation_header'}
+      style={[
+        styles.title,
+        {fontFamily: `${theme.font}-Bold`, opacity, color: props.tintColor},
+      ]}
+    />
+  );
+};
+
+const HeaderLeft: React.FC<HeaderBackProps> = ({
+  tintColor,
+  preventBack,
+  onPressLeftHeader,
+  useBorder,
+}) => {
+  const context = useContext<any>(MiniAppContext);
+  const {navigator} = useContext(ApplicationContext);
+
+  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 {
+        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 {
+      goBack();
+    }
+    return true;
+  };
+  return (
+    <View style={styles.headerLeft}>
+      <NavigationButton
+        accessibilityLabel="btn_navigation_back"
+        icon="ic_back"
+        tintColor={tintColor}
+        onPress={goBackSafe}
+        useBorder={useBorder}
+      />
+    </View>
+  );
+};
+
+const HeaderBackground: React.FC<HeaderBackgroundProps> = ({
+  image,
+  animatedValue,
+  useSurface = false,
+}) => {
+  const {theme} = useContext(ApplicationContext);
+  let headerImage = theme.assets?.headerBackground;
+  let backgroundColor;
+  if (image === null) {
+    headerImage = undefined;
+  }
+  if (useSurface) {
+    backgroundColor = theme.colors.background.surface;
+  }
+  const opacity = animatedValue?.interpolate({
+    inputRange: [0, 114],
+    outputRange: [0, 1],
+    extrapolate: 'clamp',
+  });
+
+  return (
+    <Animated.View
+      style={[
+        Styles.flex,
+        {
+          backgroundColor,
+          overflow: 'hidden',
+          borderBottomWidth: useSurface ? 1 : 0,
+          borderColor: theme.colors.border.default,
+          opacity,
+        },
+      ]}>
+      <StatusBar
+        barStyle={headerImage || theme.dark ? 'light-content' : 'dark-content'}
+        translucent={true}
+        backgroundColor={'transparent'}
+      />
+      {!!headerImage && (
+        <Image
+          style={styles.headerBackground}
+          source={{uri: headerImage}}
+          loading={false}
+        />
+      )}
+    </Animated.View>
+  );
+};
+
+const HeaderCustom: React.FC<TitleCustomProps> = ({
+  title,
+  subTitle,
+  image,
+  imageShape = 'circle',
+  content,
+  tintColor,
+  dotColor,
+}) => {
+  const avatarStyle = imageShape == 'circle' ? styles.circle : styles.square;
+  const header = (
+    <View style={Styles.row}>
+      <View>
+        <Image source={{uri: image}} style={avatarStyle} />
+        {!!dotColor && (
+          <View style={[styles.dotAvatar, {backgroundColor: dotColor}]} />
+        )}
+      </View>
+      <View style={[Styles.flex, {paddingHorizontal: 8}]}>
+        <Text
+          accessibilityLabel={'title_navigation_header'}
+          typography="header_default_bold"
+          color={tintColor}>
+          {title}
+        </Text>
+        <Text typography="description_default_regular" color={tintColor}>
+          {subTitle}
+        </Text>
+      </View>
+    </View>
+  );
+  return <View style={styles.headerTitleContainer}>{content ?? header}</View>;
+};
+
+const HeaderRightAction: React.FC<any> = ({children, ...restProps}) => {
+  const validateType = (child: React.ReactElement) => {
+    const valid = child?.type === NavigationButton || child?.type == Fragment;
+    if (__DEV__ && !valid) {
+      console.warn(
+        'HeaderRightAction contains element type of NavigationButton, Please check again.',
+      );
+    }
+    return child;
+  };
+
+  const renderAction = () => {
+    if (Array.isArray(children)) {
+      return children.map((child, index) => {
+        return (
+          <View key={`HeaderRightAction ${index}`} style={styles.headerButton}>
+            {React.cloneElement(validateType(child), {...restProps})}
+          </View>
+        );
+      });
+    }
+
+    return (
+      <View style={styles.headerButton}>
+        {React.cloneElement(validateType(children), {...restProps})}
+      </View>
+    );
+  };
+  return <View style={styles.headerRightButton}>{renderAction()}</View>;
+};
+
+const HeaderToolkitAction: React.FC<any> = ({
+  tintColor,
+  pinnedTool,
+  runtimeTools = [],
+  preventClose,
+}) => {
+  const {navigator} = useContext(ApplicationContext);
+  const miniContext = useContext<any>(MiniAppContext);
+  const [toolConfig, setToolConfig] = useState<any>();
+  const {onAction} = toolConfig ?? {};
+
+  let backgroundColor;
+  if (tintColor != Colors.black_01) {
+    backgroundColor = 'transparent';
+  }
+
+  useEffect(() => {
+    if (miniContext?.toolkitConfig?.hidden === false) {
+      if (navigator?.toolkitConfig) {
+        setToolConfig(navigator?.toolkitConfig);
+      } else {
+        getToolkitConfig();
+      }
+    }
+  }, []);
+
+  const getToolkitConfig = () => {
+    navigator?.maxApi?.dispatchFunction?.(
+      'getToolsConfig',
+      [undefined],
+      (config: any) => {
+        navigator.toolkitConfig = config;
+        setToolConfig(navigator?.toolkitConfig);
+      },
+    );
+  };
+
+  const onMore = () => {
+    onAction?.('onMore');
+    navigator?.maxApi?.dispatchFunction?.(
+      'showTools',
+      {runtimeTools},
+      (res: {item: {action?: string; key: string}}) => {
+        const {item} = res;
+        navigator?.toolkitCallback?.(item);
+        getToolkitConfig();
+      },
+    );
+  };
+
+  const onClose = () => {
+    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 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="btn_navigation_pin"
+          icon={pinTool.icon as string}
+          tintColor={tintColor}
+          badgeValue={badgeValue}
+          badgeType={badgeType}
+          onPress={() => {
+            navigator?.maxApi?.dispatchFunction?.(
+              'onToolAction',
+              [pinTool?.key],
+              () => {
+                getToolkitConfig();
+              },
+            );
+            navigator?.toolkitCallback?.(pinTool.key);
+          }}
+        />
+      );
+  };
+  if (toolConfig) {
+    return (
+      <View style={styles.headerRightButton}>
+        {renderPinnedTool()}
+        <View
+          style={[
+            styles.toolkitContainer,
+            {
+              backgroundColor: backgroundColor ?? '#00000066',
+              borderWidth: backgroundColor ? 0.5 : 0,
+            },
+          ]}>
+          <TouchableOpacity
+            accessibilityLabel={'btn_navigation_more'}
+            onPress={onMore}>
+            <Icon color={tintColor} source="navigation_more_horiz" size={20} />
+          </TouchableOpacity>
+          <View style={[styles.divider, {backgroundColor: tintColor}]} />
+          <TouchableOpacity
+            accessibilityLabel={'btn_navigation_close'}
+            onPress={onClose}>
+            <Icon
+              color={tintColor}
+              source="16_navigation_close_circle"
+              size={20}
+            />
+          </TouchableOpacity>
+        </View>
+      </View>
+    );
+  }
+
+  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.M,
+  },
+  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,
+};

package/Application/ModalScreen.tsx

@@ -0,0 +1,97 @@
+import React, {useContext, useEffect, useRef} from 'react';
+import {
+  KeyboardAvoidingView,
+  Platform,
+  Pressable,
+  StyleSheet,
+  View,
+} from 'react-native';
+
+import {ApplicationContext} from './index';
+import {Styles} from '../Consts';
+import Navigation from './Navigation';
+import {ModalParams} from './types';
+import BottomSheet from './BottomSheet';
+
+const ModalScreen: React.FC<any> = props => {
+  if (props.route?.params?.isBottomSheet) {
+    return <BottomSheet {...props} />;
+  }
+  return <Modal {...props} />;
+};
+
+const Modal: React.FC<ModalParams> = props => {
+  const {theme, navigator} = useContext(ApplicationContext);
+  const {screen, barrierDismissible} = props.route.params;
+  const Component = useRef(screen).current;
+  const navigation = new Navigation(props.navigation, theme);
+  const params = {
+    ...props.route.params,
+    navigation,
+  };
+  delete params.screen;
+
+  useEffect(() => {
+    return () => {
+      props.route.params?.onDismiss?.();
+    };
+  }, []);
+
+  const onDismiss = () => {
+    if (barrierDismissible) {
+      return;
+    }
+    navigator?.pop();
+  };
+
+  return (
+    <KeyboardAvoidingView
+      style={Styles.flex}
+      behavior={Platform.OS === 'ios' ? 'padding' : 'height'}>
+      <View style={styles.container}>
+        <Pressable
+          style={styles.modalSpaceHorizontal}
+          onPress={() => onDismiss()}
+        />
+        <View style={styles.modalCenterStage}>
+          <Pressable
+            style={styles.modalSpaceVertical}
+            onPress={() => onDismiss()}
+          />
+          <View style={styles.modalContent}>
+            <Component {...params} />
+          </View>
+          <Pressable
+            style={styles.modalSpaceVertical}
+            onPress={() => onDismiss()}
+          />
+        </View>
+        <Pressable
+          style={styles.modalSpaceHorizontal}
+          onPress={() => onDismiss()}
+        />
+      </View>
+    </KeyboardAvoidingView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {flex: 1, flexDirection: 'row'},
+  modalContent: {
+    maxWidth: '100%',
+    maxHeight: '80%',
+  },
+  modalCenterStage: {
+    maxWidth: '90%',
+  },
+  modalSpaceHorizontal: {
+    flex: 1,
+    minWidth: '5%',
+  },
+  modalSpaceVertical: {
+    flex: 1,
+    minHeight: '10%',
+  },
+});
+
+export default ModalScreen;

package/Application/Navigation.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import {NavigationProp} from '@react-navigation/native';
+import {NavigationOptions, Theme} from './types';
+import {HeaderRightAction} from './index';
+import {getOptions} from './utils';
+import {HeaderToolkitAction} from './Components';
+
+class Navigation {
+  instance: NavigationProp<any>;
+  readonly theme: Theme;
+
+  constructor(instance: any, theme: Theme) {
+    this.instance = instance;
+    this.theme = theme;
+  }
+
+  /**
+   * navigation options filter by design system rule
+   * @param params
+   */
+  private filterParams = (params: NavigationOptions) => {
+    if (params.headerRight) {
+      const headerRight = params.headerRight?.({}) as React.ReactElement;
+      const type = headerRight?.type;
+      if (type !== HeaderRightAction && type !== HeaderToolkitAction) {
+        console.warn(
+          'headerRight contains element type of HeaderRightAction | HeaderToolkitAction, Please check again.',
+        );
+      }
+    }
+
+    if (params.headerLeft) {
+      console.warn('headerLeft not allow override render by design system!');
+      delete params.headerLeft;
+    }
+
+    return params;
+  };
+
+  /**
+   * navigation setOptions support props NavigationOptions base on react-navigation options
+   * @param params
+   */
+  setOptions = (params: NavigationOptions) => {
+    params = getOptions(this.filterParams(params), this.theme);
+    this.instance.setOptions(params);
+  };
+}
+
+export default Navigation;