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

package/Input/InputMoney.tsx

@@ -1,4 +1,10 @@
-import React, {FC, useContext, useRef, useState} from 'react';
+import React, {
+  forwardRef,
+  useContext,
+  useImperativeHandle,
+  useRef,
+  useState,
+} from 'react';
 import {
   NativeSyntheticEvent,
   TextInput,
@@ -6,128 +12,185 @@ import {
   TouchableOpacity,
   View,
 } from 'react-native';
-import {ApplicationContext} from '../Application';
-import styles from './styles';
+import {ApplicationContext, ComponentContext} from '../Application';
+import {Icon} from '../Icon';
 import {ErrorView, FloatingView, getBorderColor, getSizeStyle} from './common';
 import {InputMoneyProps} from './index';
-import {Icon} from '../Icon';
+import styles from './styles';
 import {formatMoneyToNumber, formatNumberToMoney} from './utils';
 
-const InputMoney: FC<InputMoneyProps> = ({
-  onChangeText,
-  floatingValue,
-  floatingIcon,
-  size = 'small',
-  onBlur,
-  onFocus,
-  errorMessage,
-  icon,
-  disabled,
-  floatingIconColor,
-  iconColor,
-  required,
-  ...props
-}) => {
-  const {theme} = useContext(ApplicationContext);
-  const [focused, setFocused] = useState(false);
-  const inputRef = useRef<any>(null);
-  const [value, setValue] = useState('');
-  const onClearText = () => {
-    inputRef?.current?.clear();
-    setValue('');
-    onChangeText?.('');
-  };
-  const _onChangeText = (text: string) => {
-    if (text.length < value.length && value.indexOf(text) === 0) {
-      text = value.slice(0, -2) + 'đ';
+const InputMoney = forwardRef(
+  (
+    {
+      onChangeText,
+      floatingValue,
+      floatingIcon,
+      size = 'small',
+      onBlur,
+      onFocus,
+      errorMessage,
+      icon,
+      disabled = false,
+      floatingIconColor,
+      iconColor,
+      required = false,
+      errorSpacing,
+      style,
+      params,
+      defaultValue = '',
+      accessibilityLabel,
+      hintText,
+      ...props
+    }: InputMoneyProps,
+    ref,
+  ) => {
+    const {theme} = useContext(ApplicationContext);
+    const [focused, setFocused] = useState(false);
+    const inputRef = useRef<TextInput>(null);
+
+    const validateText = (text: string) => {
+      const valueFormat = formatMoneyToNumber(text, 'đ');
+      return formatNumberToMoney(valueFormat, 'đ');
+    };
+
+    const [value, setValue] = useState(
+      defaultValue ? validateText(defaultValue) : '',
+    );
+
+    const onClearText = () => {
+      inputRef?.current?.clear();
+      setValue('');
+      onChangeText?.('');
+    };
+
+    const _onChangeText = (text: string) => {
+      if (text.length < value.length && value.indexOf(text) === 0) {
+        text = value.slice(0, -2) + 'đ';
+      }
+      setValue(validateText(text));
+      onChangeText?.(formatMoneyToNumber(text, 'đ').toString());
+    };
+
+    useImperativeHandle(ref, () => {
+      return {
+        clear: onClearText,
+        focus: () => inputRef.current?.focus(),
+        blur: () => inputRef.current?.blur(),
+        changeText: (text: string) => _onChangeText(text),
+        setText: _onChangeText,
+      };
+    });
+
+    const _onFocus = (e: NativeSyntheticEvent<TextInputFocusEventData>) => {
+      setFocused(true);
+      onFocus?.(e);
+    };
+
+    const _onBlur = (e: NativeSyntheticEvent<TextInputFocusEventData>) => {
+      setFocused(false);
+      onBlur?.(e);
+    };
+
+    const renderInputView = () => {
+      const disabledColor = theme.colors.text.disable;
+      let textColor = theme.colors.text.default;
+      let placeholderColor = theme.colors.text.hint;
+      let iconTintColor = iconColor;
+
+      if (disabled) {
+        textColor = disabledColor;
+        placeholderColor = disabledColor;
+        iconTintColor = disabledColor;
+      }
+
+      return (
+        <View
+          style={[
+            styles.inputWrapper,
+            {backgroundColor: theme.colors.background.surface},
+            getSizeStyle(size),
+            getBorderColor(theme, focused, errorMessage, disabled),
+          ]}>
+          <FloatingView
+            floatingValue={floatingValue}
+            floatingIconColor={floatingIconColor}
+            disabled={disabled}
+            required={required}
+            floatingIcon={floatingIcon}
+          />
+          <View style={styles.inputView}>
+            <TextInput
+              {...props}
+              accessibilityLabel={accessibilityLabel}
+              editable={!disabled}
+              ref={inputRef}
+              keyboardType={'number-pad'}
+              style={[
+                styles.moneyInput,
+                {
+                  color: textColor,
+                },
+              ]}
+              value={value}
+              onChangeText={_onChangeText}
+              onFocus={_onFocus}
+              onBlur={_onBlur}
+              selectionColor={theme.colors.primary}
+              placeholderTextColor={placeholderColor}
+              placeholder={'0đ'}
+            />
+          </View>
+          <View style={styles.iconView}>
+            {focused && (
+              <TouchableOpacity
+                style={styles.iconWrapper}
+                onPress={onClearText}>
+                <Icon
+                  source="24_navigation_close_circle_full"
+                  size={16}
+                  color={theme.colors.text.hint}
+                />
+              </TouchableOpacity>
+            )}
+            {!!icon && <Icon color={iconTintColor} source={icon} />}
+          </View>
+        </View>
+      );
+    };
+
+    let inputState = 'active';
+
+    if (value && value?.length > 0) {
+      inputState = 'filled';
+    }
+    if (errorMessage && errorMessage?.length > 0) {
+      inputState = 'error';
     }
-    const valueFormat = formatMoneyToNumber(text, 'đ');
-    setValue(formatNumberToMoney(valueFormat, 'đ'));
-    onChangeText?.(formatMoneyToNumber(text, 'đ').toString());
-  };
-
-  const _onFocus = (e: NativeSyntheticEvent<TextInputFocusEventData>) => {
-    setFocused(true);
-    onFocus?.(e);
-  };
-
-  const _onBlur = (e: NativeSyntheticEvent<TextInputFocusEventData>) => {
-    setFocused(false);
-    onBlur?.(e);
-  };
-
-  const renderInputView = () => {
-    const disabledColor = theme.colors.text.disable;
-    let textColor = theme.colors.text.default;
-    let placeholderColor = theme.colors.text.hint;
-    let iconTintColor = iconColor;
 
     if (disabled) {
-      textColor = disabledColor;
-      placeholderColor = disabledColor;
-      iconTintColor = disabledColor;
+      inputState = 'disabled';
     }
 
     return (
-      <View
-        style={[
-          getSizeStyle(size),
-          getBorderColor(focused, errorMessage, disabled),
-          styles.inputWrapper,
-          {backgroundColor: theme.colors.background.surface},
-        ]}>
-        <FloatingView
-          floatingValue={floatingValue}
-          floatingIconColor={floatingIconColor}
-          disabled={disabled}
-          required={required}
-          floatingIcon={floatingIcon}
-        />
-        <View style={styles.inputView}>
-          <TextInput
-            {...props}
-            accessibilityLabel={`TextInput`}
-            editable={!disabled}
-            textAlignVertical="top"
-            ref={inputRef}
-            keyboardType={'number-pad'}
-            style={[
-              styles.moneyInput,
-              {
-                color: textColor,
-              },
-            ]}
-            value={value}
-            onChangeText={_onChangeText}
-            onFocus={_onFocus}
-            onBlur={_onBlur}
-            selectionColor={theme.colors.primary}
-            placeholderTextColor={placeholderColor}
-            placeholder={'0đ'}
+      <ComponentContext.Provider
+        value={{
+          componentName: 'InputMoney',
+          params,
+          componentLabel: floatingValue,
+          state: inputState,
+          componentId: accessibilityLabel,
+        }}>
+        <View style={[style, styles.wrapper]}>
+          {renderInputView()}
+          <ErrorView
+            errorMessage={errorMessage}
+            errorSpacing={errorSpacing}
+            hintText={hintText}
           />
         </View>
-        <View style={styles.iconView}>
-          {focused && (
-            <TouchableOpacity style={styles.iconWrapper} onPress={onClearText}>
-              <Icon
-                source="24_navigation_close_circle_full"
-                size={16}
-                color={theme.colors.text.hint}
-              />
-            </TouchableOpacity>
-          )}
-          {!!icon && <Icon color={iconTintColor} source={icon} />}
-        </View>
-      </View>
+      </ComponentContext.Provider>
     );
-  };
-
-  return (
-    <View style={styles.wrapper} accessibilityLabel={`InputMoney`}>
-      {renderInputView()}
-      <ErrorView errorMessage={errorMessage} />
-    </View>
-  );
-};
+  },
+);
 
 export default InputMoney;

package/Input/InputOTP.tsx

@@ -0,0 +1,257 @@
+import React, {
+  FC,
+  forwardRef,
+  useContext,
+  useEffect,
+  useImperativeHandle,
+  useRef,
+  useState,
+} from 'react';
+import {
+  Animated,
+  NativeSyntheticEvent,
+  TextInput,
+  TextInputFocusEventData,
+  TouchableOpacity,
+  View,
+} from 'react-native';
+import {ApplicationContext, ComponentContext} from '../Application';
+import {Spacing} from '../Consts';
+import {scaleSize, Text} from '../Text';
+import {ErrorView, getBorderColor} from './common';
+import {CaretProps, InputOTPProps} from './index';
+import styles from './styles';
+
+const OTPCaret: FC<CaretProps> = ({index, length}) => {
+  const DURATION = 300;
+  const {theme} = useContext(ApplicationContext);
+  const opacity = useRef(new Animated.Value(0)).current;
+
+  useEffect(() => {
+    Animated.loop(
+      Animated.sequence([
+        Animated.timing(opacity, {
+          toValue: 1,
+          duration: DURATION,
+          useNativeDriver: true,
+        }),
+        Animated.delay(DURATION * 2),
+        Animated.timing(opacity, {
+          toValue: 0,
+          duration: DURATION,
+          useNativeDriver: true,
+        }),
+      ]),
+    ).start();
+  }, []);
+  const spacingStyle = !isNaN(Number(length)) &&
+    index !== Number(length) - 1 && {marginRight: Spacing.L};
+
+  return (
+    <View style={[{flexDirection: 'row', alignItems: 'center'}, spacingStyle]}>
+      <Animated.View
+        style={{
+          height: scaleSize(12),
+          width: 1,
+          backgroundColor: theme.colors.primary,
+          opacity,
+        }}
+      />
+      <Text color={theme.colors.text.hint} typography={'body_default_regular'}>
+        -
+      </Text>
+    </View>
+  );
+};
+
+const InputOTP = forwardRef(
+  (
+    {
+      length,
+      errorMessage,
+      errorSpacing,
+      floatingValue = 'Label',
+      floatingIconColor,
+      floatingIcon,
+      placeholder,
+      onChangeText,
+      onFocus,
+      onBlur,
+      dataType = 'number',
+      params,
+      style,
+      accessibilityLabel,
+      hintText,
+      ...props
+    }: InputOTPProps,
+    ref,
+  ) => {
+    const MAX_LENGTH = 10;
+    const [value, setValue] = useState('');
+    const [focused, setFocused] = useState(false);
+    const inputRef = useRef<TextInput | null>(null);
+    const {theme} = useContext(ApplicationContext);
+
+    useImperativeHandle(ref, () => ({
+      onChangeText: (text: string) => {
+        _onChangeText(text);
+      },
+      focus: () => inputRef.current?.focus(),
+      blur: () => inputRef.current?.blur(),
+      setText: (text: string) => _onChangeText(text),
+    }));
+
+    const onFocusInput = () => {
+      setFocused(true);
+      inputRef.current?.focus();
+    };
+
+    const onBlurInput = (e: NativeSyntheticEvent<TextInputFocusEventData>) => {
+      setFocused(false);
+      onBlur?.(e);
+    };
+
+    const _onChangeText = (text: string) => {
+      if (text.length > MAX_LENGTH) return;
+      if (dataType === 'number' && isNaN(Number(text))) return;
+      if (
+        !isNaN(Number(text)) &&
+        value.length >= Number(length) &&
+        text.length >= value.length
+      )
+        return;
+
+      setValue(text);
+      onChangeText?.(text);
+    };
+
+    const renderInputs = (length: number) => {
+      const TextInputs: React.ReactNode[] = [];
+      for (let i = 0; i < length; i++) {
+        TextInputs.push(
+          <View>
+            {focused && value.length === i ? (
+              <OTPCaret index={i} length={length} />
+            ) : (
+              <Text
+                style={i !== length - 1 && {marginRight: Spacing.L}}
+                color={
+                  !!value[i]
+                    ? theme.colors.text.default
+                    : theme.colors.text.hint
+                }
+                typography={
+                  !!value[i] ? 'header_m_bold' : 'body_default_regular'
+                }>
+                {value[i] || '-'}
+              </Text>
+            )}
+          </View>,
+        );
+      }
+      return TextInputs;
+    };
+
+    const renderUnidentifiedInputs = () => {
+      const splitValue = value.split('');
+
+      if (!focused && value.length === 0 && !!placeholder) {
+        return (
+          <Text
+            color={theme.colors.text.hint}
+            typography={'description_default_regular'}>
+            {placeholder}
+          </Text>
+        );
+      }
+
+      return (
+        <View style={{flexDirection: 'row'}}>
+          {splitValue.map((letter, index) => {
+            return (
+              <Text
+                style={
+                  (index !== value.length - 1 ||
+                    (focused && value.length !== MAX_LENGTH)) && {
+                    marginRight: Spacing.L,
+                  }
+                }
+                typography={'header_m_bold'}>
+                {letter}
+              </Text>
+            );
+          })}
+          {focused && value.length !== MAX_LENGTH && <OTPCaret />}
+        </View>
+      );
+    };
+
+    const renderInputView = () => {
+      return (
+        <View
+          style={[
+            styles.otpInput,
+            {backgroundColor: theme.colors.background.surface},
+            getBorderColor(theme, focused, errorMessage),
+          ]}>
+          {!!floatingValue && (
+            <View
+              style={[
+                styles.otpFloatingView,
+                {backgroundColor: theme.colors.background.surface},
+              ]}>
+              <Text
+                typography={'description_default_regular'}
+                color={theme.colors.text.hint}>
+                {floatingValue}
+              </Text>
+            </View>
+          )}
+          <View style={styles.otpInputsView}>
+            {length ? renderInputs(length) : renderUnidentifiedInputs()}
+          </View>
+          <View style={styles.inputView}>
+            <TextInput
+              {...props}
+              accessibilityLabel={accessibilityLabel}
+              ref={inputRef}
+              value={value}
+              onChangeText={_onChangeText}
+              keyboardType={dataType === 'number' ? 'number-pad' : 'default'}
+              onFocus={onFocusInput}
+              onBlur={onBlurInput}
+              style={{opacity: 0}}
+              selectionColor={theme.colors.primary}
+              placeholderTextColor={theme.colors.text.hint}
+            />
+          </View>
+        </View>
+      );
+    };
+
+    return (
+      <ComponentContext.Provider
+        value={{
+          componentName: 'InputOTP',
+          params,
+          componentLabel: floatingValue,
+          state: 'enabled',
+          componentId: accessibilityLabel,
+        }}>
+        <TouchableOpacity
+          activeOpacity={1}
+          onPress={onFocusInput}
+          style={[style, styles.otpWrapper]}>
+          {renderInputView()}
+          <ErrorView
+            errorMessage={errorMessage}
+            errorSpacing={errorSpacing}
+            hintText={hintText}
+          />
+        </TouchableOpacity>
+      </ComponentContext.Provider>
+    );
+  },
+);
+
+export default InputOTP;