@momo-kits/foundation 0.92.21-beta.0 → 0.92.21-beta.2

package/Input/InputSearch.tsx

@@ -1,5 +1,6 @@
 import React, {
   forwardRef,
+  ForwardRefRenderFunction,
   useContext,
   useImperativeHandle,
   useRef,
@@ -15,177 +16,195 @@ import {
 import {ApplicationContext, ComponentContext} from '../Application';
 import {Icon} from '../Icon';
 import {Text} from '../Text';
-import {InputSearchProps} from './index';
+import {InputSearchProps, InputSearchRef} from './index';
 import styles from './styles';
 import {checkTyping} from './utils';
+import TextTyping from './TextTyping';
 
-const InputSearch = forwardRef(
-  (
-    {
-      placeholder,
-      onFocus,
-      onBlur,
-      iconColor,
-      value,
-      onChangeText,
-      icon,
-      buttonText = 'Hủy',
-      showButtonText = true,
-      style,
-      defaultValue,
-      onPressButtonText,
-      params,
-      hasColorBG = false,
-      accessibilityLabel,
-      ...props
-    }: InputSearchProps,
-    ref,
-  ) => {
-    const {theme} = useContext(ApplicationContext);
-    const [focused, setFocused] = useState(false);
-    const [haveValue, setHaveValue] = useState(!!value || !!defaultValue);
-    const inputRef = useRef<TextInput | null>(null);
+const InputSearch: ForwardRefRenderFunction<
+  InputSearchRef,
+  InputSearchProps
+> = (
+  {
+    placeholder,
+    onFocus,
+    onBlur,
+    iconColor,
+    value,
+    onChangeText,
+    icon,
+    buttonText = 'Hủy',
+    showButtonText = true,
+    style,
+    defaultValue,
+    onPressButtonText,
+    params,
+    hasColorBG = false,
+    accessibilityLabel,
+    typingData = [],
+    onPress,
+    ...props
+  },
+  ref
+) => {
+  const {theme} = useContext(ApplicationContext);
+  const [focused, setFocused] = useState(false);
+  const [haveValue, setHaveValue] = useState(!!value || !!defaultValue);
+  const inputRef = useRef<TextInput | null>(null);
 
-    const _onFocus = (e: NativeSyntheticEvent<TextInputFocusEventData>) => {
-      setFocused(true);
-      onFocus?.(e);
-    };
+  const _onFocus = (e: NativeSyntheticEvent<TextInputFocusEventData>) => {
+    setFocused(true);
+    onFocus?.(e);
+  };
 
-    const _onBlur = (e: NativeSyntheticEvent<TextInputFocusEventData>) => {
-      setFocused(false);
-      onBlur?.(e);
-    };
+  const _onBlur = (e: NativeSyntheticEvent<TextInputFocusEventData>) => {
+    setFocused(false);
+    onBlur?.(e);
+  };
 
-    const onClearText = () => {
-      inputRef?.current?.clear();
-      _onChangeText('');
-    };
+  const onClearText = () => {
+    inputRef?.current?.clear();
+    _onChangeText('');
+  };
 
-    const _onChangeText = (text: string) => {
-      checkTyping(text, haveValue, setHaveValue);
-      onChangeText?.(text);
-    };
+  const _onChangeText = (text: string) => {
+    checkTyping(text, haveValue, setHaveValue);
+    onChangeText?.(text);
+  };
 
-    useImperativeHandle(ref, () => {
-      return {
-        clear: onClearText,
-        focus: () => inputRef.current?.focus(),
-        blur: () => inputRef.current?.blur(),
-        setText: (text: string) => _onChangeText(text),
-      };
-    });
+  useImperativeHandle(ref, () => {
+    return {
+      clear: onClearText,
+      focus: () => inputRef.current?.focus(),
+      blur: () => inputRef.current?.blur(),
+      setText: (text: string) => _onChangeText(text),
+    };
+  });
 
-    const renderInputView = () => {
+  const renderInputView = () => {
+    if (typingData?.length > 0) {
       return (
-        <TextInput
-          {...props}
-          accessibilityLabel={accessibilityLabel}
-          textAlignVertical="center"
-          ref={inputRef}
+        <TouchableOpacity
           style={[
             styles.searchInput,
             {
-              color: theme.colors.text.default,
+              justifyContent: 'center',
             },
           ]}
-          value={value}
-          onChangeText={_onChangeText}
-          onFocus={_onFocus}
-          onBlur={_onBlur}
-          placeholder={placeholder}
-          selectionColor={theme.colors.primary}
-          placeholderTextColor={theme.colors.text.hint}
-        />
+          onPress={onPress}
+          activeOpacity={onPress ? 0.6 : 1}>
+          <TextTyping data={typingData} />
+        </TouchableOpacity>
       );
-    };
-
-    const renderIconView = () => {
-      return (
-        <View
-          style={{
-            flexDirection: 'row',
-          }}>
-          {focused && haveValue && (
-            <TouchableOpacity style={styles.iconWrapper} onPress={onClearText}>
-              <Icon
-                source="24_navigation_close_circle_full"
-                size={16}
-                color={theme.colors.text.hint}
-              />
-            </TouchableOpacity>
-          )}
-          {!!icon && (
-            <View style={{flexDirection: 'row'}}>
-              <View
-                style={[
-                  styles.divider,
-                  {
-                    backgroundColor: theme.colors.primary,
-                  },
-                ]}
-              />
-              <Icon
-                color={iconColor}
-                source={icon}
-                style={styles.iconSearchInput}
-              />
-            </View>
-          )}
-        </View>
-      );
-    };
-
-    let inputState = 'empty';
-
-    if (focused) {
-      inputState = 'focus';
-    }
-
-    if (value && value?.length > 0) {
-      inputState = 'filled';
     }
 
-    const backgroundColor = hasColorBG
-      ? theme.colors.background.default
-      : theme.colors.background.surface;
+    return (
+      <TextInput
+        {...props}
+        accessibilityLabel={accessibilityLabel}
+        textAlignVertical="center"
+        ref={inputRef}
+        style={[
+          styles.searchInput,
+          {
+            color: theme.colors.text.default,
+          },
+        ]}
+        value={value}
+        onChangeText={_onChangeText}
+        onFocus={_onFocus}
+        onBlur={_onBlur}
+        placeholder={placeholder}
+        selectionColor={theme.colors.primary}
+        placeholderTextColor={theme.colors.text.hint}
+      />
+    );
+  };
 
+  const renderIconView = () => {
     return (
-      <ComponentContext.Provider
-        value={{
-          componentName: 'InputSearch',
-          params,
-          state: inputState,
-          componentId: accessibilityLabel,
+      <View
+        style={{
+          flexDirection: 'row',
         }}>
-        <View style={[style, styles.searchInputContainer]}>
-          <View
-            style={[
-              styles.searchInputWrapper,
-              {
-                backgroundColor,
-              },
-            ]}>
+        {focused && haveValue && (
+          <TouchableOpacity style={styles.iconWrapper} onPress={onClearText}>
             <Icon
-              source={'navigation_search'}
-              size={24}
+              source="24_navigation_close_circle_full"
+              size={16}
               color={theme.colors.text.hint}
             />
-            {renderInputView()}
-            {renderIconView()}
+          </TouchableOpacity>
+        )}
+        {!!icon && (
+          <View style={{flexDirection: 'row'}}>
+            <View
+              style={[
+                styles.divider,
+                {
+                  backgroundColor: theme.colors.primary,
+                },
+              ]}
+            />
+            <Icon
+              color={iconColor}
+              source={icon}
+              style={styles.iconSearchInput}
+            />
           </View>
-          {showButtonText && (
-            <TouchableOpacity onPress={onPressButtonText}>
-              <Text
-                typography={'action_default_bold'}
-                style={styles.textButton}>
-                {buttonText}
-              </Text>
-            </TouchableOpacity>
-          )}
-        </View>
-      </ComponentContext.Provider>
+        )}
+      </View>
     );
-  },
-);
+  };
+
+  let inputState = 'empty';
+
+  if (focused) {
+    inputState = 'focus';
+  }
+
+  if (value && value?.length > 0) {
+    inputState = 'filled';
+  }
+
+  const backgroundColor = hasColorBG
+    ? theme.colors.background.default
+    : theme.colors.background.surface;
+
+  return (
+    <ComponentContext.Provider
+      value={{
+        componentName: 'InputSearch',
+        params,
+        state: inputState,
+        componentId: accessibilityLabel,
+      }}>
+      <View style={[style, styles.searchInputContainer]}>
+        <View
+          style={[
+            styles.searchInputWrapper,
+            {
+              backgroundColor,
+            },
+          ]}>
+          <Icon
+            source={'navigation_search'}
+            size={24}
+            color={theme.colors.text.hint}
+          />
+          {renderInputView()}
+          {renderIconView()}
+        </View>
+        {showButtonText && (
+          <TouchableOpacity onPress={onPressButtonText}>
+            <Text typography={'action_default_bold'} style={styles.textButton}>
+              {buttonText}
+            </Text>
+          </TouchableOpacity>
+        )}
+      </View>
+    </ComponentContext.Provider>
+  );
+};
 
-export default InputSearch;
+export default forwardRef(InputSearch);

package/Input/TextTyping.tsx

@@ -0,0 +1,113 @@
+import React, {FC, memo, useEffect, useRef} from 'react';
+import {Platform, StyleSheet, TextInput, TextStyle} from 'react-native';
+import {Colors} from '../Consts';
+import {scaleSize} from '../Text';
+
+export interface TextTypingProps {
+  data: string[];
+  timeDelayEnd?: number;
+  timeDelayNextChar?: number;
+  inputStyle?: TextStyle;
+}
+
+const TextTyping: FC<TextTypingProps> = ({
+  data = [],
+  timeDelayEnd = 2000,
+  timeDelayNextChar = 20,
+  inputStyle = {},
+}) => {
+  const textRef = useRef<TextInput>(null);
+
+  const currentIndex = useRef<number>(0);
+  const currentCharIndex = useRef<number>(0);
+  const currentText = useRef('');
+
+  useEffect(() => {
+    setTimeout(() => {
+      playAnimation();
+    }, 1000);
+  }, []);
+
+  const playAnimation = () => {
+    const handleResetList = () => {
+      currentIndex.current = 0;
+      handleAnimation();
+    };
+
+    const handleAnimation = () => {
+      const listChar = data?.[currentIndex.current]?.split('') || [];
+      listChar.length !== 0 && showChar(listChar?.[currentCharIndex.current]);
+    };
+
+    currentIndex.current >= data?.length
+      ? handleResetList()
+      : handleAnimation();
+  };
+
+  const showChar = (char?: string) => {
+    const handleResetString = () => {
+      setTimeout(() => {
+        reset();
+      }, timeDelayEnd);
+    };
+
+    const handleShowChar = () => {
+      setTimeout(() => {
+        textRef.current?.setNativeProps?.({
+          text: currentText.current + char,
+        });
+        currentText.current += char;
+        currentCharIndex.current++;
+        playAnimation();
+      }, timeDelayNextChar);
+    };
+
+    currentCharIndex.current >= (data?.[currentIndex.current]?.length || 0)
+      ? handleResetString()
+      : handleShowChar();
+  };
+
+  const reset = () => {
+    const handleNextString = () => {
+      currentIndex.current++;
+      playAnimation();
+    };
+
+    const handleReset = () => {
+      setTimeout(() => {
+        textRef.current?.setNativeProps?.({
+          text: currentText.current.slice(0, -1),
+        });
+        currentText.current = currentText.current.slice(0, -1);
+        currentCharIndex.current--;
+        reset();
+      }, timeDelayNextChar);
+    };
+
+    currentCharIndex.current <= 0 ? handleNextString() : handleReset();
+  };
+
+  return (
+    <TextInput
+      style={[styles.inputStyle, inputStyle]}
+      ref={textRef}
+      editable={false}
+      autoCorrect={false}
+      pointerEvents={'none'}
+      numberOfLines={1}
+    />
+  );
+};
+
+export default memo(TextTyping);
+
+const styles = StyleSheet.create({
+  inputStyle: {
+    color: Colors.black_12,
+    fontSize: scaleSize(12),
+    height: Platform.select({
+      android: 60,
+      ios: 36,
+    }),
+  },
+});

package/Input/index.tsx

@@ -1,4 +1,4 @@
-import {TextInputProps, ViewStyle} from 'react-native';
+import {GestureResponderEvent, TextInputProps, ViewStyle} from 'react-native';
 import Input from './Input';
 import InputDropDown from './InputDropDown';
 import InputMoney from './InputMoney';
@@ -143,6 +143,9 @@ export interface InputSearchProps extends TextInputProps {
    * Optional. Represents the style of the InputSearch component.
    */
   params?: any;
+
+  typingData?: string[];
+  onPress?: (e: GestureResponderEvent) => void;
 }
 
 export interface InputMoneyProps extends Omit<InputProps, 'placeholder'> {}
@@ -282,4 +285,11 @@ export interface InputDropDownProps extends InputProps {
   style?: ViewStyle | ViewStyle[];
 }
 
+export type InputSearchRef = {
+  clear: () => void;
+  focus: () => void | undefined;
+  blur: () => void | undefined;
+  setText: (text: string) => void;
+};
+
 export {Input, InputDropDown, InputMoney, InputOTP, InputSearch, InputTextArea};

package/Layout/AnimatedInputSearch.tsx

@@ -0,0 +1,58 @@
+import React, {FC, useEffect, useRef} from 'react';
+import {InputSearch} from '../Input';
+import {Animated, Dimensions} from 'react-native';
+import {AnimatedInputSearchProps} from './types';
+import {Spacing} from '../Consts';
+import {scaleSize} from '../Text';
+
+const {width: screenWidth} = Dimensions.get('window');
+const SCREEN_PADDING = 12;
+const BACK_WIDTH = scaleSize(28);
+
+const AnimatedInputSearch: FC<AnimatedInputSearchProps> = ({
+  animatedValue,
+  headerRightWidth,
+  inputSearchProps,
+  inputRef,
+}) => {
+  const widthAnimated = useRef(new Animated.Value(0));
+
+  useEffect(() => {
+    const listener = animatedValue.addListener(({value}) => {
+      widthAnimated.current.setValue(value);
+    });
+    return () => {
+      animatedValue?.removeListener(listener);
+    };
+  }, []);
+
+  const translateX = widthAnimated.current.interpolate({
+    inputRange: [0, 100],
+    outputRange: [SCREEN_PADDING, BACK_WIDTH + SCREEN_PADDING * 2],
+    extrapolate: 'clamp',
+  });
+
+  return (
+    <Animated.View
+      style={{
+        transform: [{translateX}],
+        marginVertical: Spacing.S,
+        width: widthAnimated.current.interpolate({
+          inputRange: [0, 100],
+          outputRange: [
+            screenWidth - SCREEN_PADDING * 2,
+            screenWidth - SCREEN_PADDING * 3 - BACK_WIDTH - headerRightWidth,
+          ],
+          extrapolate: 'clamp',
+        }),
+      }}>
+      <InputSearch
+        ref={inputRef}
+        {...inputSearchProps}
+        showButtonText={false}
+      />
+    </Animated.View>
+  );
+};
+
+export default AnimatedInputSearch;