ব্লগ

React Native-এ পরের স্তরের ফর্ম হ্যান্ডলিং

২৮ জুন, ২০২৩ ১০ মিনিটের পড়া

React Native-এ উন্নত ফর্ম হ্যান্ডলিং কৌশল। ভ্যালিডেশন, পারফরম্যান্স অপ্টিমাইজেশন আর reusable ফর্ম কম্পোনেন্ট তৈরি সম্পর্কে জানুন।

React Native-এ পরের স্তরের ফর্ম হ্যান্ডলিং
React Nativeফর্মভ্যালিডেশনপারফরম্যান্সReact Hook FormZod

React Native-এ পরের স্তরের ফর্ম হ্যান্ডলিং

Zod আর React Hook Form দিয়ে React Native-এ ফর্ম হ্যান্ডলিং আরও উন্নত করুন

ব্যবহারকারীর ইনপুট লাগে এমন যেকোনো অ্যাপ্লিকেশনের মৌলিক অংশ হলো ফর্ম হ্যান্ডলিং, আর সঠিক টুল ও লাইব্রেরি থাকলে এটি সহজ আর নির্বিঘ্ন একটি প্রক্রিয়া হতে পারে। এই আর্টিকেলে দেখাব কীভাবে react-hook-form আর zod ব্যবহার করে একটি react-native অ্যাপে ফর্ম হ্যান্ডেল করা যায়। এই দুটিকে মিলিয়ে আমরা একটি কার্যকর ফর্ম হ্যান্ডলিং ব্যবস্থা পাব। এটি বোঝাতে চলুন একটি সাধারণ signup ফর্ম তৈরি করি।

সম্পূর্ণ সোর্স কোড আর্টিকেলের শেষে দেওয়া থাকবে।

Zod দিয়ে Schema ঘোষণা

শুরুতে আমরা zod দিয়ে আমাদের schema ঘোষণা করি। এই schema আমাদের ফর্ম ডেটার প্রত্যাশিত আকার ঠিক করে দেবে আর প্রতিটি ফিল্ডের জন্য validation সেট করবে। এই নিয়মগুলো ডিফাইন করার জন্য Zod অনেকগুলো শক্তিশালী validation ফাংশন দেয়।

এখানে সম্পূর্ণ zod schema:

এই আর্টিকেল ধরে নিচ্ছে যে আপনি zod-এর মূল বিষয়গুলো জানেন।

import z from "zod";

const phoneNumberRegexp = new RegExp(
  /^[\+]?([0-9][\s]?|[0-9]?)([(][0-9]{3}[)][\s]?|[0-9]{3}[-\s\.]?)[0-9]{3}[-\s\.]?[0-9]{4,6}$/im
);
const FIELD_REQUIRED_STR = "This field is required";
export const GENDER_OPTIONS = ["Male", "Female", "Other"] as const;

export const signUpFormSchema = z.object({
  name: z
    .string({
      invalid_type_error: "Name must be a string",
      required_error: FIELD_REQUIRED_STR,
    })
    .min(3, "Minimum 3 characters")
    .max(20, "Maximum 20 characters")
    .trim(),

  surname: z
    .string({
      invalid_type_error: "Surname must be a string",
      required_error: FIELD_REQUIRED_STR,
    })
    .min(3, "Minimum 3 characters")
    .max(20, "Maximum 20 characters")
    .trim(),

  phoneNumber: z
    .string({
      invalid_type_error: "Phone number must be a number",
      required_error: FIELD_REQUIRED_STR,
    })
    .regex(phoneNumberRegexp, "Invalid phone number"),

  email: z
    .string({
      invalid_type_error: "Email must be a string",
      required_error: FIELD_REQUIRED_STR,
    })
    .email("Email is invalid"),

  gender: z.enum(GENDER_OPTIONS, {
    required_error: FIELD_REQUIRED_STR,
    invalid_type_error: `Invalid gender, must be one of the followings: ${GENDER_OPTIONS.join(
      ", "
    )}`,
  }),

  birthDate: z
    .date({
      invalid_type_error: "Birth date must be a date",
      required_error: FIELD_REQUIRED_STR,
    })
    .min(new Date("1900-01-01"), "Invalid date time, too old")
    .max(new Date("2023-01-01"), "Invalid date time, too young")
    .default(new Date()),
});

export type SignUpFormSchema = z.infer<typeof signUpFormSchema>;

এই schema-তে আমরা zod দিয়ে ঠিক করে দিই প্রতিটি ফিল্ডে কী থাকা উচিত। যেমন name আর surname ফিল্ড ৩ থেকে ২০ অক্ষরের string হওয়া উচিত, আর phoneNumber ফিল্ড একটি number হওয়া উচিত।

কিছু ফিল্ডের জন্য আরও জটিল নিয়মও আছে। যেমন email ফিল্ড একটি string হবে এবং শুধু বৈধ email ঠিকানাই গ্রহণ করবে। gender ফিল্ড আগে থেকে ঠিক করা gender অপশনগুলোর একটি হবে ('Male', 'Female' বা 'Other')।

সবশেষে birthDate ফিল্ড date টাইপের, এবং 1900-01-01 থেকে 2023-01-01-এর মধ্যে একটি বৈধ তারিখ হতে হবে। কিছু দেওয়া না হলে ডিফল্টভাবে এটি বর্তমান তারিখ নেয়।

zod দিয়ে আমরা সহজেই জটিল validation নিয়ম তৈরি করতে পারি। এভাবে ফর্ম থেকে পাওয়া ডেটা নিশ্চিতভাবে আমাদের প্রত্যাশার সাথে মিলবে।

পরের ধাপ হলো schema-র টাইপ infer করা। Zod একটি infer মেথড দেয়, যেটি একটি নির্দিষ্ট zod schema থেকে TypeScript টাইপ বের করে।

export type SignUpFormSchema = z.infer<typeof signUpFormSchema>;

এই infer করা টাইপ পরে useForm-এ ব্যবহার হয়, যাতে আমাদের ফর্ম ডেটা schema-র সাথে মেলে তা নিশ্চিত হয়।

React Hook Form দিয়ে ফর্ম সেটআপ

এরপর আমরা 'react-hook-form'-এর useForm hook দিয়ে ফর্ম সেটআপ করি। ফর্ম validation resolve করতে এই hook আমাদের zod schema-কে (zodResolver-এর মাধ্যমে) আর্গুমেন্ট হিসেবে নেয়।

const methods = useForm<SignUpFormSchema>({
  resolver: zodResolver(signUpFormSchema),
  defaultValues: {
    birthDate: new Date(),
  },
  mode: "onBlur",
});

resolver-এ আমরা আমাদের schema পাঠাই। defaultValues প্রপার্টি দিয়ে ফর্ম ফিল্ডের ডিফল্ট ভ্যালু দেওয়া যায়। এই ক্ষেত্রে আমরা ডিফল্ট birthDate হিসেবে বর্তমান তারিখ সেট করছি। mode প্রপার্টি ঠিক করে validation কখন হবে। এই ক্ষেত্রে validation হবে onBlur-এ, অর্থাৎ ব্যবহারকারী যখন কোনো ফিল্ড ছেড়ে যান।

ফিল্ড রেন্ডারিং আর Validation

প্রতিটি ফর্ম ফিল্ড ম্যানেজ করতে আমরা react-hook-form-এর Controller কম্পোনেন্ট ব্যবহার করি। এটি আমাদের field আর fieldState props দেয়, যা দিয়ে আমরা ফিল্ডের ভ্যালু, error state আর validation ম্যানেজ করি।

যেমন name ফিল্ড আমরা এভাবে সেটআপ করি:

<Controller
  control={methods.control}
  name="name"
  render={({ field: { onChange, onBlur, value }, fieldState: { error } }) => {
    return (
      <TextInput
        label="Name"
        onBlur={onBlur}
        value={value}
        onChangeText={onChange}
        errorMessage={error?.message}
      />
    );
  }}
/>

প্রতিটি prop কী করে:

  • control: এখানে useForm hook থেকে পাওয়া control prop পাঠাতে হয়। ফর্ম state-এর সাথে Controller-এর যোগাযোগের জন্য এটি দরকার।

  • name: এটি ফর্মের ভেতরে ইনপুটের ভ্যালু পাওয়ার key। ফর্মের ভ্যালু পড়া বা সেট করার সময় এই key-ই ব্যবহার হবে। সব ফর্ম ফিল্ডের মধ্যে এটি অনন্য হতে হবে।

  • render: এটি একটি ফাংশন যা আপনার ইনপুট এলিমেন্ট ফেরত দেয়। ফাংশনটি field আর fieldState props দেয়।

  • field: এতে onChange, onBlur আর value props থাকে। এগুলো সরাসরি আপনার controlled কম্পোনেন্টের সাথে যুক্ত থাকা উচিত। এই ক্ষেত্রে onChange যুক্ত আছে TextInput-এর onChangeText-এর সাথে, যা ব্যবহারকারীর ইনপুট ধরে ফর্ম state-এ রাখবে।

  • fieldState: এতে error prop থাকে, যা এই ফিল্ডের validation error সম্পর্কে তথ্য দেয়।

render prop-এর ভেতরে TextInput কাস্টমাইজ করা হয়। onBlur আর onChangeText field-এর সংশ্লিষ্ট মেথডের সাথে যুক্ত, আর value prop এই ইনপুটের বর্তমান ফর্ম ভ্যালুর সাথে যুক্ত। validation ব্যর্থ হলে errorMessage prop error মেসেজের সাথে যুক্ত থাকে।

তাই ফর্ম সাবমিট বা রিয়েল-টাইম validation-এর সময় ‘name’ ফিল্ড যদি Zod schema-তে ডিফাইন করা validation শর্ত পূরণ না করে, তাহলে এই TextInput ফিল্ডে error মেসেজ দেখানো হবে।

React Hook Form দিয়ে কাস্টম Validation ট্রিগার

birthDate ফিল্ডের ক্ষেত্রে একটি বিশেষ পরিস্থিতি তৈরি হয়, কারণ এটি একটি date picker কম্পোনেন্ট (এই ক্ষেত্রে RNDateTimePicker) ব্যবহার করে। এখানে validation প্রক্রিয়ায় বিশেষ ব্যবস্থা লাগে, কারণ date picker-এর সাথে ব্যবহারকারীর ইন্টারঅ্যাকশন সাধারণ টেক্সট ইনপুট থেকে আলাদা।

<Controller
  control={methods.control}
  name="birthDate"
  render={({ field: { onChange, onBlur, value }, fieldState: { error } }) => {
    return (
      <View>
        <Text>Birth date</Text>
        <RNDateTimePicker
          value={value}
          mode="date"
          onChange={(e) => {
            if (e.type === "set" && e.nativeEvent.timestamp) {
              onChange(new Date(e.nativeEvent.timestamp));
              methods.trigger("birthDate");
            }
          }}
        />
        {!!error?.message && <Text>{error.message}</Text>}
      </View>
    );
  }}
/>

ব্যবহারকারী একটি তারিখ বেছে নিলে onChange ইভেন্ট ট্রিগার হয়। এই event handler-এর ভেতরে আমরা প্রথমে দেখি ইভেন্টের টাইপ 'set' কি না, যার মানে ব্যবহারকারী একটি তারিখ সেট করেছেন। এরপর দেখি timestamp আছে কি না, যাতে নিশ্চিত হই একটি তারিখ বেছে নেওয়া হয়েছে।

এই শর্তগুলো নিশ্চিত হলে আমরা new Date(e.nativeEvent.timestamp) দিয়ে timestamp-কে একটি JavaScript Date অবজেক্টে রূপান্তর করি। তারপর এই নতুন ভ্যালু onChange-এ পাঠানো হয়, যা ফর্মে birthDate ফিল্ডের ভ্যালু আপডেট করে।

তবে সাধারণ টেক্সট ইনপুট যেমন পরিবর্তনের সাথে সাথে স্বয়ংক্রিয়ভাবে validation ট্রিগার করে, date picker তেমনভাবে করে না। তাই ভ্যালু আপডেট হওয়ার পরে আমাদের হাতে validation ট্রিগার করতে হয়। এটা আমরা করি methods.trigger('birthDate') কল করে।

react-hook-form-এর দেওয়া এই trigger মেথড একটি নির্দিষ্ট ফিল্ডের validation শুরু করে। এখানে তারিখ সেট হওয়ার সঙ্গে সঙ্গে এটি birthDate ফিল্ডের validation ট্রিগার করে, ফলে আমাদের validation নিয়ম সঙ্গে সঙ্গে প্রয়োগ হয়।

সবশেষে কোনো validation error থাকলে তা {!!error?.message && {error.message}} দিয়ে দেখানো হবে, যেখানে error?.message-এ আমাদের zod schema-তে ডিফাইন করা validation error মেসেজ থাকে।

ফর্ম সাবমিশন: React Hook Form

ফর্ম সাবমিশন আর error হ্যান্ডলিংয়ের জন্য react-hook-form প্যাকেজ কার্যকর মেথড দেয়।

const onSubmit: SubmitHandler<SignUpFormSchema> = (data) => {
  console.log(JSON.stringify(data));
};

const onError: SubmitErrorHandler<SignUpFormSchema> = (errors, e) => {
  console.log(JSON.stringify(errors));
};

<Button
  onPress={methods.handleSubmit(onSubmit, onError)}
  title="Submit Form"
  color={"#007BFF"}
/>;

চলুন প্রক্রিয়াটি ভেঙে দেখি:

onSubmit handler আর্গুমেন্ট হিসেবে ফর্ম ডেটা পায়। এই পরিস্থিতিতে আমরা শুধু ডেটাটি লগ করছি, কিন্তু বাস্তব অ্যাপ্লিকেশনে এটি সার্ভারে পাঠানো যেতে পারে বা অ্যাপ্লিকেশনের প্রয়োজন অনুযায়ী আরও প্রক্রিয়া করা যেতে পারে।

অন্যদিকে onError ফাংশন কল হয় যখন ফর্ম সাবমিটের সময় validation error থাকে। errors অবজেক্টে validation-এ ব্যর্থ সব ফিল্ড সম্পর্কে বিস্তারিত তথ্য থাকে। এই উদাহরণে আমরা শুধু এই error-গুলো লগ করছি।

প্রতিটি ফিল্ডে error থাকলে error অবজেক্টটি হবে এরকম:

    {
      "name": {
        "message": "This field is required",
        "type": "invalid_type",
        "ref": {
          "name": "name"
        }
      },
      "surname": {
        "message": "This field is required",
        "type": "invalid_type",
        "ref": {
          "name": "surname"
        }
      },
      "phoneNumber": {
        "message": "This field is required",
        "type": "invalid_type",
        "ref": {
          "name": "phoneNumber"
        }
      },
      "email": {
        "message": "This field is required",
        "type": "invalid_type",
        "ref": {
          "name": "email"
        }
      },
      "gender": {
        "message": "This field is required",
        "type": "invalid_type",
        "ref": {
          "name": "gender"
        }
      },
      "birthDate": {
        "message": "Invalid date time, too young",
        "type": "too_big",
        "ref": {
          "name": "birthDate"
        }
      }
    }

Zod দিয়ে আগাম Validation

নিচের কোড ব্লকে ফর্ম সাবমিশন ইভেন্টের আগে Zod-এর safeParse মেথড দিয়ে হাতে ফর্ম ডেটার আগাম validation করার একটি পদ্ধতি দেখানো হয়েছে। React Hook Form-এর handleSubmit মেথড ইতিমধ্যে ফর্ম validation সামলায়, তবু আগাম validation ডেভেলপারদের ফর্ম validation প্রক্রিয়ার ওপর বেশি নিয়ন্ত্রণ দিতে পারে।

<Button
  title="Submit Form"
  onPress={() => {
    // get current form values
    const currFormValues = methods.getValues();

    // Prevalidate using zod's safeParse
    const result = signUpFormSchema.safeParse(currFormValues);

    // If prevalidation is failed, display the error
    if (!result.success) {
      Alert.alert(JSON.stringify(result.error));
    } else {
      // If prevalidation is successful, notify the user
      Alert.alert("Validation is successful with zod");
    }
  }}
/>

চলুন ওপরের কোডটি বিশ্লেষণ করি:

  • Button-এর onPress ইভেন্ট ব্যবহার করা হচ্ছে এমন একটি ফাংশন চালাতে যা ফর্ম সাবমিশনের আগে আগাম validation করে।

  • methods (যা React Hook Form দেয়) থেকে getValues মেথড ব্যবহার করে বর্তমান ফর্ম ভ্যালুগুলো পড়া হয়।

  • এরপর এই ভ্যালুগুলো signUpFormSchema-র (শুরুতে তৈরি করা zod schema) safeParse মেথডে পাঠানো হয়। এই ধাপেই zod-এর আগাম validation হয়। zod-এর parse মেথডের মতো safeParse validation ব্যর্থ হলে error throw করে না। বরং এটি একটি অবজেক্ট ফেরত দেয়, যাতে success boolean থাকে আর validation ব্যর্থ হলে একটি error অবজেক্ট থাকে।

  • একটি শর্ত দেখে result.success false কি না (অর্থাৎ validation ব্যর্থ হয়েছে)। false হলে এটি validation error দেখিয়ে একটি alert ট্রিগার করে।

  • result.success true হলে (অর্থাৎ validation সফল), এটি zod দিয়ে validation সফল হয়েছে জানিয়ে একটি alert ট্রিগার করে।

React Hook Form-এর handleSubmit যেহেতু zod-এর দেওয়া schema দিয়ে ইতিমধ্যে ফর্ম validation করে, তাই এই পদ্ধতি বাড়তি মনে হতে পারে, তবু নির্দিষ্ট কিছু পরিস্থিতিতে এটি কাজের। যেমন আপনি হয়তো হাতে validation-এর পরেই কিছু অ্যাকশন চালাতে চান, অথবা ব্যবহারকারী ফর্ম পূরণ করার সাথে সাথে রিয়েল-টাইমে ইনপুট যাচাই করতে চান। এমন ক্ষেত্রে zod-এর safeParse মেথড দিয়ে আগাম validation বেশ কাজে আসে।

আর zod error অবজেক্ট দেখতে এমন হবে:

    {
      "issues": [
        {
          "code": "invalid_type",
          "expected": "string",
          "received": "undefined",
          "path": [
            "name"
          ],
          "message": "This field is required"
        },
        {
          "code": "invalid_type",
          "expected": "string",
          "received": "undefined",
          "path": [
            "surname"
          ],
          "message": "This field is required"
        },
        {
          "code": "invalid_type",
          "expected": "string",
          "received": "undefined",
          "path": [
            "phoneNumber"
          ],
          "message": "This field is required"
        },
        {
          "code": "invalid_type",
          "expected": "string",
          "received": "undefined",
          "path": [
            "email"
          ],
          "message": "This field is required"
        },
        {
          "expected": "'Male' | 'Female' | 'Other'",
          "received": "undefined",
          "code": "invalid_type",
          "path": [
            "gender"
          ],
          "message": "This field is required"
        },
        {
          "code": "too_big",
          "message": "Invalid date time, too young",
          "inclusive": true,
          "exact": false,
          "maximum": 1672531200000,
          "type": "date",
          "path": [
            "birthDate"
          ]
        }
      ],
      "name": "ZodError"
    }

এটি আসলেই একটি বড় অবজেক্ট, আর আমাদের ক্ষেত্রে এতে অপ্রয়োজনীয় ফিল্ডও থাকতে পারে। ভাগ্য ভালো, zod error ফরম্যাট করার একটি মেথড দেয়।

আমরা শুধু result.error.format() ব্যবহার করতে পারি, বাকিটা zod ভেতরে ভেতরে সামলাবে।

if (!result.success) {
  // Format errors using result.error.format()
  const formattedError = result.error.format();
  Alert.alert(JSON.stringify(formattedError));
} else {
  Alert.alert("Validation is successful with zod");
}

ফরম্যাট করা error অবজেক্টটি দেখতে এমন হবে:

    {
      "name": {
        "_errors": [
          "This field is required"
        ]
      },
      "surname": {
        "_errors": [
          "This field is required"
        ]
      },
      "phoneNumber": {
        "_errors": [
          "This field is required"
        ]
      },
      "email": {
        "_errors": [
          "This field is required"
        ]
      },
      "gender": {
        "_errors": [
          "This field is required"
        ]
      },
      "birthDate": {
        "_errors": [
          "Invalid date time, too young"
        ]
      }
    }

সর্বশেষ কোড

নিচে সবচেয়ে সাম্প্রতিক কোড দেওয়া হলো (import আর style বাদে)। সম্পূর্ণ সোর্স কোড দেখতে চাইলে আর্টিকেলের শেষ অংশ দেখুন।

// imports...

export const SignupForm: React.FC = () => {
  const [shouldValidateWithZod, setShouldValidateWithZod] =
    React.useState<boolean>(false);

  const [isCalendarOpenForAndroid, setIsCalendarOpenForAndroid] =
    React.useState<boolean>(false);

  const methods = useForm<SignUpFormSchema>({
    resolver: zodResolver(signUpFormSchema),
    defaultValues: {
      birthDate: new Date(),
    },
    mode: "onBlur",
  });

  const onSubmit: SubmitHandler<SignUpFormSchema> = (data) => {
    console.log(JSON.stringify(data));
  };

  const onError: SubmitErrorHandler<SignUpFormSchema> = (errors, e) => {
    console.log(JSON.stringify(errors));
    Alert.alert("Warning", getReadableValidationErrorMessage(errors));
  };

  return (
    <SafeAreaView edges={["top", "bottom"]} style={styles.safeArea}>
      <ScrollView>
        <Text style={styles.title}>Sign Up Form</Text>
        <View style={styles.root}>
          <FormProvider {...methods}>
            <Controller
              control={methods.control}
              name="name"
              render={({
                field: { onChange, onBlur, value },
                fieldState: { error },
              }) => {
                return (
                  <TextInput
                    label="Name"
                    onBlur={onBlur}
                    value={value}
                    onChangeText={onChange}
                    errorMessage={error?.message}
                  />
                );
              }}
            />
            <View style={styles.spacing} />
            <Controller
              control={methods.control}
              name="surname"
              render={({
                field: { onChange, onBlur, value },
                fieldState: { error },
              }) => {
                return (
                  <TextInput
                    label="Surname"
                    onBlur={onBlur}
                    value={value}
                    onChangeText={onChange}
                    errorMessage={error?.message}
                  />
                );
              }}
            />
            <View style={styles.spacing} />

            <Controller
              control={methods.control}
              name="email"
              render={({
                field: { onChange, onBlur, value },
                fieldState: { error },
              }) => {
                return (
                  <TextInput
                    label="Email"
                    onBlur={onBlur}
                    value={value}
                    onChangeText={onChange}
                    errorMessage={error?.message}
                  />
                );
              }}
            />

            <View style={styles.spacing} />

            <Controller
              control={methods.control}
              name="phoneNumber"
              render={({
                field: { onChange, onBlur, value },
                fieldState: { error },
              }) => {
                return (
                  <TextInput
                    label="Phone number"
                    onBlur={onBlur}
                    keyboardType="decimal-pad"
                    value={value}
                    onChangeText={(val) => onChange(val.toString())}
                    errorMessage={error?.message}
                  />
                );
              }}
            />

            <View style={styles.spacing} />

            <Controller
              control={methods.control}
              name="birthDate"
              render={({
                field: { onChange, value },
                fieldState: { error },
              }) => {
                return (
                  <View style={styles.dateWrapper}>
                    <Text style={styles.label}>Birth date</Text>

                    {Platform.OS === "android" && (
                      <Button
                        onPress={() => {
                          setIsCalendarOpenForAndroid(true);
                        }}
                        title={value.toString()}
                      />
                    )}

                    {(isCalendarOpenForAndroid ||
                      Platform.OS !== "android") && (
                      <RNDateTimePicker
                        value={value}
                        style={styles.dateTimePicker}
                        mode={"date"}
                        onChange={(e) => {
                          if (Platform.OS === "android") {
                            setIsCalendarOpenForAndroid(false);
                          }

                          if (e.type === "set" && e.nativeEvent.timestamp) {
                            onChange(new Date(e.nativeEvent.timestamp));
                            methods.trigger("birthDate");
                          }
                        }}
                      />
                    )}

                    {!!error?.message && (
                      <Text style={styles.errorMessageText}>
                        {error.message}
                      </Text>
                    )}
                  </View>
                );
              }}
            />

            <View style={styles.spacing} />

            <Controller
              control={methods.control}
              name="gender"
              render={({
                field: { onChange, onBlur, value, ref },
                fieldState: { error },
              }) => {
                return (
                  <View style={styles.genderWrapper}>
                    <Text style={styles.label}>Gender</Text>
                    <View style={styles.genderOptionsWrapper}>
                      {GENDER_OPTIONS.map((genderOption) => (
                        <Pressable
                          key={genderOption}
                          style={[
                            styles.genderOptionPressable,
                            {
                              backgroundColor:
                                value === genderOption ? "#007BFF" : "#F2F2F2",
                            },
                          ]}
                          onPress={() => onChange(genderOption)}
                        >
                          <Text
                            style={[
                              styles.genderOptionText,
                              {
                                color: value === genderOption ? "#fff" : "#000",
                              },
                            ]}
                          >
                            {genderOption}
                          </Text>
                        </Pressable>
                      ))}
                    </View>
                    {!!error?.message && (
                      <Text style={styles.errorMessageText}>
                        {error.message}
                      </Text>
                    )}
                  </View>
                );
              }}
            />

            <View style={styles.spacing} />

            <Text style={styles.label}>Should validate with zod</Text>

            <Switch
              value={shouldValidateWithZod}
              onChange={(e) => setShouldValidateWithZod(e.nativeEvent.value)}
            />
            <View style={styles.spacing} />

            <Button
              onPress={
                shouldValidateWithZod
                  ? () => {
                      /** we could also prevalidate using zod like below */

                      // get current form values
                      const currFormValues = methods.getValues();
                      // https://zod.dev/?id=safeparse
                      const result = signUpFormSchema.safeParse(currFormValues);

                      if (!result.success) {
                        const formattedError = result.error.format();
                        Alert.alert(JSON.stringify(formattedError));
                      } else {
                        Alert.alert("Validation is successful with zod");
                      }
                    }
                  : methods.handleSubmit(onSubmit, onError)
              }
              title="Submit Form"
              color={"#007BFF"}
            />
          </FormProvider>
        </View>
      </ScrollView>
    </SafeAreaView>
  );
};

// styles...

এই নমুনা অ্যাপটি expo go দিয়ে লেখা। অর্থাৎ নিচের QR কোড দিয়ে আপনি সহজেই এটি টেস্ট করতে পারেন! (QR কাজ না করলে আর্টিকেলের শেষে দেওয়া সোর্স কোডের লিংক দেখুন।)

উপসংহার

এই আর্টিকেল জুড়ে আমরা দেখেছি কীভাবে React Hook Form, Zod আর TypeScript-এর সমন্বয় কার্যকরভাবে কাজে লাগিয়ে আমাদের React Native অ্যাপ্লিকেশনে মজবুত ফর্ম validation তৈরি করা যায়। আমরা দেখেছি এই লাইব্রেরিগুলোর নমনীয়তা আর শক্তি কীভাবে আমাদের পরিষ্কার, type-safe কোড লিখতে দেয়, যা জটিল validation-এর চাহিদা সামলাতে পারে।

React Hook Form আর Zod-এর সমন্বয় আমাদের দুটোরই সুবিধা নিতে দেয়। React Hook Form ফর্ম হ্যান্ডলিং সহজ করে, re-rendering অপ্টিমাইজ করে, আর ফর্ম state management ও error হ্যান্ডলিংয়ের মতো ফিচার দেয়। অন্যদিকে Zod নিরাপত্তার একটি বাড়তি স্তর যোগ করে, যা দিয়ে আমরা প্রতিটি ফর্ম ফিল্ডে কোন ধরনের ডেটা চলবে তা নির্দিষ্ট করে সেই নিয়মগুলো প্রয়োগ করতে পারি।

মনে রাখবেন, এখানে দেখানো কৌশলগুলো একটি সাধারণ SignUp ফর্মের প্রেক্ষাপটে ব্যবহার হলেও আপনার React Native অ্যাপ্লিকেশনের যেকোনো ফর্ম-ভিত্তিক ব্যবহারকারী ইনপুটে এগুলো প্রযোজ্য। এই কৌশলগুলো কাজে লাগিয়ে আপনি নিশ্চিত করতে পারেন যে আপনার ফর্মগুলো ব্যবহারবান্ধব, মজবুত আর রক্ষণাবেক্ষণযোগ্য, যার ফলে ব্যবহারকারীর অভিজ্ঞতা ভালো হয় আর অ্যাপ্লিকেশন আরও মজবুত হয়।

সম্পূর্ণ সোর্স কোডের লিংক