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

package/Application/Navigator.ts

@@ -1,4 +1,4 @@
-import {StackActions} from '@react-navigation/native';
+import {CommonActions, StackActions} from '@react-navigation/native';
 import {
   BottomSheetParams,
   HeaderToolkitProps,
@@ -8,74 +8,143 @@ import {
 
 class Navigator {
   ref?: any;
+  isReady?: any;
   toolkitConfig?: HeaderToolkitProps;
   maxApi?: any;
+  dismissData?: any;
+  toolkitCallback?: (item: any) => void;
 
-  constructor(navigation: any) {
+  constructor(navigation: any, isReady: any) {
     this.ref = navigation;
+    this.isReady = isReady;
   }
 
+  /**
+   * push new stack screen
+   * @param params
+   */
   push = (params: ScreenParams) => {
-    this.ref.current.dispatch(StackActions.push('Stack', params));
+    if (this.isReady.current) {
+      this.ref.current.dispatch(StackActions.push('Stack', params));
+    }
   };
 
+  /**
+   * replace current screen with new screen
+   * @param params
+   */
   replace = (params: ScreenParams) => {
-    this.ref.current.dispatch(StackActions.replace('Stack', params));
+    if (this.isReady.current) {
+      this.ref.current.dispatch(StackActions.replace('Stack', params));
+    }
   };
-
+  /**
+   * pop to dismiss a screen
+   * @param count
+   */
   pop = (count?: number) => {
-    this.ref.current.dispatch(StackActions.pop(count ?? 1));
+    if (this.isReady.current) {
+      this.ref.current.dispatch(StackActions.pop(count ?? 1));
+    }
   };
 
+  /**
+   * present a new screen, show from bottom iOS
+   * @param params
+   */
   present = (params: ScreenParams) => {
-    this.ref.current.dispatch(StackActions.push('Dialog', params));
+    if (this.isReady.current) {
+      this.ref.current.dispatch(StackActions.push('Dialog', params));
+    }
   };
 
+  /**
+   * show a modal popup
+   * @param params
+   */
   showModal = (params: ModalParams) => {
-    this.ref.current.dispatch(StackActions.push('Modal', params));
+    if (this.isReady.current) {
+      this.ref.current.dispatch(StackActions.push('Modal', params));
+    }
   };
 
+  /**
+   * show a bottom sheet
+   * @param params
+   */
   showBottomSheet = (params: BottomSheetParams) => {
-    this.ref.current.dispatch(
-      StackActions.push('Modal', {
-        ...params,
-        isBottomSheet: true,
-      }),
-    );
+    if (this.isReady.current) {
+      this.ref.current.dispatch(
+        StackActions.push('Modal', {
+          ...params,
+          isBottomSheet: true,
+        }),
+      );
+    }
   };
 
+  /**
+   * pop all screen route
+   */
   popToTop = () => {
-    this.ref.current.dispatch(StackActions.popToTop());
+    if (this.isReady.current) {
+      this.ref.current.dispatch(StackActions.popToTop());
+    }
+  };
+
+  /**
+   * navigate
+   * @param name
+   * @param params
+   */
+  navigate = (name: string, params: any) => {
+    if (this.isReady.current) {
+      this.ref.current.dispatch(
+        CommonActions.navigate({
+          name,
+          params,
+        }),
+      );
+    }
   };
 
-  requestApi = (func: any, args: any = [], callback: any) => {
-    if (this.maxApi) {
-      this.maxApi[func]?.(...args, callback);
-    } else {
-      const instance: any = global;
-      instance?.miniAppApi?.dispatch?.(func, ...args, callback);
+  /**
+   * reset a navigation flow with new screen
+   * @param params
+   */
+  reset = (params: ScreenParams) => {
+    if (this.isReady.current) {
+      this.ref.current.dispatch(
+        CommonActions.reset({
+          index: 0,
+          routes: [
+            {
+              name: 'Stack',
+              key: `Stack_${new Date().getTime()}`,
+              params,
+            },
+          ],
+        }),
+      );
     }
   };
-  getToolkit = async (): Promise<HeaderToolkitProps | undefined> => {
-    return new Promise(resolve => {
-      if (this.toolkitConfig) {
-        resolve(this.toolkitConfig);
-        return;
-      }
-      this.requestApi('getToolkit', [undefined], (result: boolean) => {
-        if (result) {
-          this.requestApi('getToolkitConfig', [undefined], (config: any) => {
-            this.toolkitConfig = {
-              ...config?.utilityToolConfig,
-              appCode: config?.appCode,
-            };
-            resolve(this.toolkitConfig);
-          });
-        } else {
-          resolve(undefined);
-        }
-      });
-    });
+
+  /**
+   * dismiss a feature data
+   * @param data
+   */
+  setDismissData = (data: any) => {
+    this.dismissData = data;
+  };
+
+  /**
+   * set callback function for toolkit
+   * @param callback
+   */
+  setToolkitCallback = (
+    callback: (item: {key: string; action: string}) => void,
+  ) => {
+    this.toolkitCallback = callback;
   };
 }
 

package/Application/StackScreen.tsx

@@ -1,27 +1,148 @@
-import React, {useContext, useEffect} from 'react';
+import React, {useContext, useEffect, useLayoutEffect, useRef} from 'react';
 import {ScreenParams} from './types';
 import Navigation from './Navigation';
-import {ApplicationContext} from './index';
+import {ApplicationContext, MiniAppContext, ScreenContext} from './index';
+import {GridSystem} from '../Layout';
+import {useHeaderHeight} from '@react-navigation/stack';
+import {Alert, InteractionManager} from 'react-native';
 
 const StackScreen: React.FC<ScreenParams> = props => {
-  const {screen: Component, options}: ScreenParams = props.route.params;
-  const {theme, navigator} = useContext(ApplicationContext);
+  const {theme, showGrid, navigator} = useContext(ApplicationContext);
+  const startTime = useRef(Date.now());
+  const endTime = useRef(Date.now());
+  const timeLoad = useRef(0);
+  const timeInteraction = useRef(0);
+  const timeoutLoad = useRef<any>();
+  const tracked = useRef<any>({
+    releaseLoad: undefined,
+    releaseInteraction: undefined,
+    timeoutLoad: undefined,
+    timeoutInteraction: undefined,
+  });
+  const interaction = useRef<any>();
+  const context = useContext<any>(MiniAppContext);
+
+  const {screen: Component, options, initialParams} = props.route.params;
   const navigation = new Navigation(props.navigation, theme);
+  const heightHeader = useHeaderHeight();
 
-  const params = {
+  const data = {
+    ...initialParams,
     ...props.route.params,
     navigation,
   };
 
-  delete params.screen;
+  delete data.screen;
+  delete data.initialParams;
 
-  useEffect(() => {
+  const screenName = Component?.name || Component?.type?.name || 'Invalid';
+
+  /**
+   * set options for screen
+   */
+  useLayoutEffect(() => {
     if (options) {
       navigation.setOptions(options);
     }
   }, [options]);
 
-  return <Component {...params} />;
+  /**
+   * tracking for screen
+   */
+  useEffect(() => {
+    if (__DEV__ && (!screenName || screenName == 'Invalid')) {
+      Alert.alert('Design system', `Unvalidated screen name "${screenName}" !`);
+    }
+
+    navigator?.maxApi?.of?.({screenName});
+
+    tracked.current.timeoutLoad = setTimeout(() => {
+      onScreenLoad();
+    }, 5000);
+    tracked.current.timeoutInteraction = setTimeout(() => {
+      onScreenInteraction();
+    }, 5000);
+
+    return () => {
+      onScreenLoad();
+      onScreenInteraction();
+    };
+  }, []);
+
+  /**
+   * tracking for screen load
+   */
+  const onScreenLoad = () => {
+    clearTimeout(tracked.current.timeoutLoad);
+    if (!tracked.current?.releaseLoad) {
+      context.autoTracking?.({
+        appId: context.appId,
+        code: context.code,
+        buildNumber: context.buildNumber,
+        screenName,
+        componentName: 'Screen',
+        state: 'load',
+        duration: timeLoad.current,
+      });
+      navigator?.maxApi?.showToastDebug?.({
+        appId: `auto - ${context.appId}`,
+        message: `${screenName} screen_load_time ${timeLoad.current}`,
+      });
+      tracked.current.releaseLoad = true;
+    }
+  };
+
+  /**
+   * tracking for screen load
+   */
+  const onScreenInteraction = () => {
+    clearTimeout(tracked.current.timeoutInteraction);
+    if (!tracked.current?.releaseInteraction) {
+      context.autoTracking?.({
+        appId: context.appId,
+        code: context.code,
+        buildNumber: context.buildNumber,
+        screenName,
+        componentName: 'Screen',
+        state: 'interaction',
+        duration: timeInteraction.current - timeLoad.current,
+      });
+
+      navigator?.maxApi?.showToastDebug?.({
+        appId: `auto - ${context.appId}`,
+        message: `${screenName} screen_interaction_time ${timeInteraction.current}`,
+      });
+      tracked.current.releaseInteraction = true;
+    }
+  };
+
+  return (
+    <ScreenContext.Provider
+      value={{
+        screenName,
+        onElementLoad: () => {
+          endTime.current = Date.now();
+          interaction.current?.cancel?.();
+          interaction.current = InteractionManager.runAfterInteractions(() => {
+            timeInteraction.current = Date.now() - startTime.current;
+          });
+          clearTimeout(timeoutLoad.current);
+          timeoutLoad.current = setTimeout(() => {
+            if (timeLoad.current === 0) {
+              timeLoad.current = endTime.current - startTime.current;
+            }
+          }, 2000);
+        },
+      }}>
+      <Component
+        heightHeader={heightHeader}
+        {...data}
+        onScreenLoad={onScreenLoad}
+        onScreenInteraction={onScreenInteraction}
+      />
+      {showGrid && <GridSystem />}
+    </ScreenContext.Provider>
+  );
 };
 
 export default StackScreen;

package/Application/index.ts

@@ -1,18 +1,37 @@
+import {Platform} from 'react-native';
 import {NavigationContainer} from './NavigationContainer';
 import Screen from '../Layout/Screen';
-import NavigationButton from './NavigationButton';
-import {HeaderRightAction} from './Components';
+import {
+  HeaderAnimated,
+  HeaderBackground,
+  HeaderCustom,
+  HeaderRightAction,
+  HeaderTitle,
+  NavigationButton,
+} from './Components';
 import BottomTab from './BottomTab';
 import {createContext} from 'react';
 import {defaultContext} from '../Consts';
 
+const Context = createContext({});
 const ApplicationContext = createContext(defaultContext);
 
+const MiniAppContext = (Platform as any).MiniAppContext ?? createContext({});
+const ScreenContext = (Platform as any).ScreenContext ?? createContext({});
+const ComponentContext = (Platform as any).ComponentContext ?? Context;
+
 export {
-  NavigationContainer,
   ApplicationContext,
+  MiniAppContext,
+  ScreenContext,
+  ComponentContext,
+  NavigationContainer,
   Screen,
+  BottomTab,
   NavigationButton,
+  HeaderTitle,
+  HeaderBackground,
   HeaderRightAction,
-  BottomTab,
+  HeaderCustom,
+  HeaderAnimated,
 };

package/Application/types.ts

@@ -1,8 +1,11 @@
+import {StackNavigationOptions} from '@react-navigation/stack';
+import React from 'react';
 import {Animated, ScrollViewProps, ViewProps} from 'react-native';
-import React, {ReactNode} from 'react';
-import Navigator from './Navigator';
 import {PopupNotifyProps} from '../Popup/types';
 import Navigation from './Navigation';
+import Navigator from './Navigator';
+
+type Screen = React.ComponentType<NavigationScreenProps>;
 
 export type Theme = {
   dark: boolean;
@@ -60,15 +63,39 @@ export type Theme = {
 };
 
 export type Context = {
+  [key: string]: any;
   theme: Theme;
   navigator?: Navigator;
+  showGrid?: boolean;
+  translate?: (key: string) => string;
+};
+
+export type MiniAppInfo = {
+  [key: string]: any;
+  code: string;
+  appId: string;
+  buildNumber: number;
+  flowPartnerId?: string;
+  toolkitConfig?: any;
+  fromCode?: string;
+};
+
+export type LocalizationObject = {
+  vi: {
+    [key: string]: string;
+  };
+  en: {
+    [key: string]: string;
+  };
 };
 
 export type NavigationContainerProps = {
-  screen: React.ElementType;
+  screen: Screen;
   options?: NavigationOptions;
   theme: Theme;
-  maxApi?: any;
+  maxApi: any;
+  localization?: LocalizationObject;
+  initialParams?: any;
 };
 
 export type NavigationScreenProps = {
@@ -77,27 +104,14 @@ export type NavigationScreenProps = {
   navigation: Navigation;
 };
 
-export interface ScreenProps extends ViewProps {
-  navigation?: Navigation;
-  enableKeyboardAvoidingView?: boolean;
-  headerBackground?: string;
-  scrollable?: boolean;
-  useAnimatedHeader?: boolean;
-  useExtendedHeader?: boolean;
-  scrollViewProps?: ScrollViewProps;
-  footerComponent?: ReactNode;
-  marginHeader?: number;
-}
-
 export type ScreenParams = {
   [key: string]: any;
-  screen: React.ElementType;
+  screen: Screen;
   options?: NavigationOptions;
 };
 
 export interface ModalParams extends ScreenParams {
   [key: string]: any;
-  screen: React.ElementType;
   onDismiss?: () => void;
   barrierDismissible?: boolean;
 }
@@ -105,38 +119,55 @@ export interface ModalParams extends ScreenParams {
 export interface BottomSheetParams extends ScreenParams {
   [key: string]: any;
   onDismiss?: () => void;
+  surface?: boolean;
+  footerComponent?: React.ReactNode;
+  scrollViewProps?: ScrollViewProps;
 }
 
 export type NavigationButtonProps = {
   icon: string;
   tintColor?: string;
-  backgroundColor?: string;
   useBorder?: boolean;
   onPress: () => void;
+  badgeType?: 'dot' | 'number';
+  badgeValue?: number;
   accessibilityLabel?: string;
 };
 
-export type NavigationOptions = {
+export type PinnedToolType = {
+  key: string;
+  badgeValue?: number;
+  badgeType?: 'number' | 'dot';
+};
+
+export type RuntimeToolType = {
+  title: {vi: string; en: string};
+  icon: string;
+  key: string;
+};
+
+export interface NavigationOptions extends StackNavigationOptions {
   preventBack?: PopupNotifyProps;
+  onPressLeftHeader?: () => void;
   surface?: boolean;
-  headerTransparent?: boolean;
-  title?: string;
-  headerTitle?: (props?: any) => React.ReactElement;
-  headerTitleAlign?: 'left' | 'center';
+  hiddenBack?: boolean;
   customTitle?: TitleCustomProps;
-  headerRight?: (props?: any) => React.ReactElement;
-  animatedValue?: Animated.Value;
-};
+  toolkitParams?: {
+    pinnedTool?: PinnedToolType;
+    runtimeTools?: RuntimeToolType[];
+    preventClose?: PopupNotifyProps;
+  };
+}
 
 export interface HeaderBackProps extends NavigationButtonProps {
   preventBack?: PopupNotifyProps;
+  onPressLeftHeader?: () => void;
 }
 
 export type HeaderBackgroundProps = {
   image?: string | null;
-  backgroundColor?: string | null;
   animatedValue?: Animated.Value;
-  useBorder?: boolean;
+  useSurface?: boolean;
 };
 
 export type TitleCustomProps = {
@@ -152,24 +183,45 @@ export type TitleCustomProps = {
 export type HeaderToolkitProps = {
   [key: string]: any;
   appCode: string;
-  hidden: boolean;
-  type: string;
-  onAction?: (action: string) => void;
+  configs: any[];
 };
 
+export interface HeaderAnimatedProps extends ViewProps {
+  animatedValue: Animated.Value;
+  image: string;
+}
+
 export type BottomTabItemProps = {
   name: string;
   label: string;
   icon: string;
   showDot?: boolean;
-  badgeLabel?: string;
-  screen: React.ComponentType<any>;
+  badgeLabel?: string | number;
+  screen: Screen;
+  options: NavigationOptions;
 };
 
 export type BottomTabProps = {
+  nested?: boolean;
   tabs: BottomTabItemProps[];
+  initialRouteName?: string;
+  navigation: Navigation;
   listeners?: {
     tabPress?: any;
     focus?: any;
   };
+  floatingButton?: FloatingButtonProps;
+};
+
+export type FloatingButtonProps = {
+  container?: React.ReactNode;
+  icon: string | React.ReactNode;
+  label: string;
+  onPress: () => void;
+};
+
+export type AnimatedHeader = {
+  type: 'default' | 'surface';
+  component?: (props?: any) => React.ReactElement;
+  headerTitle?: (props?: any) => React.ReactElement;
 };