React Navigation: টাইপিংয়ের পুরো সুবিধা নিন
নেভিগেশন তৈরি করা আজকাল যেকোনো মোবাইল অ্যাপ্লিকেশনের মৌলিক ফিচার। React Native-এর জগতে আমাদের হাতের কাছেই আছে React Navigation।
এই আর্টিকেলে দেখাব কীভাবে TypeScript দিয়ে একটি সাধারণ React Navigation ইমপ্লিমেন্ট করা যায়, আর পাশাপাশি TypeScript ব্যবহারের বিভিন্ন কৌশল তুলনা করব।
আর আরও গুরুত্বপূর্ণ হলো, নেভিগেশনে আরও স্কেলেবল আর্কিটেকচার তৈরি করতে TypeScript-এর ফিচারগুলো কীভাবে সর্বোচ্চ কাজে লাগানো যায় তাও দেখাব।
সতর্কতা: এই আর্টিকেলের উদাহরণগুলো @react-navigation@6.x সংস্করণ ব্যবহার করে তৈরি।
সতর্কতা: এই আর্টিকেলে যে পদ্ধতি বা কৌশলগুলো দেখানো হবে সেগুলো অবশ্যই কঠোরভাবে মানতে হবে এমন নয়, এগুলো শুধু আমার পছন্দ, যেগুলো এই আর্টিকেলের পাঠকদের সাথে শেয়ার করার মতো কাজের মনে হয়েছে। TypeScript ব্যবহার নিয়ে React Navigation-এর আগে থেকেই দারুণ, ভালোভাবে ডকুমেন্ট করা একটি অংশ আছে। অর্থাৎ শুধু এই ডকুমেন্টেশন অনুসরণ করেই আপনি react-navigation-এর একটি চমৎকার TypeScript কাঠামো তৈরি করতে পারেন।
Stack Navigator তৈরি করা
চলুন দেখি React Navigation প্যাকেজ দিয়ে কীভাবে একটি stack navigator তৈরি করা যায়।
React Navigation থেকে নেওয়া নিচের উদাহরণটি দেখুন:
import { createStackNavigator } from "@react-navigation/stack";
import * as React from "react";
import { View } from "react-native";
const Stack = createStackNavigator();
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
function AppStack() {
return (
<Stack.Navigator>
<Stack.Screen name="Home" component={Home} />
<Stack.Screen name="Notifications" component={Notifications} />
<Stack.Screen name="Profile" component={Profile} />
<Stack.Screen name="Settings" component={Settings} />
</Stack.Navigator>
);
}
দেখতেই পাচ্ছেন এখানে TypeScript-নির্দিষ্ট কিছু নেই, তাই এই কোড স্নিপেটে একটু TypeScript যোগ করি।
import { createStackNavigator } from "@react-navigation/stack";
import * as React from "react";
import { View } from "react-native";
type AppStackParamList = {
Home: undefined;
Notifications: undefined;
Profile: undefined;
Settings: undefined;
};
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
const Stack = createStackNavigator<AppStackParamList>();
function AppStack() {
return (
<Stack.Navigator>
<Stack.Screen name="Home" component={Home} />
<Stack.Screen name="Notifications" component={Notifications} />
<Stack.Screen name="Profile" component={Profile} />
<Stack.Screen name="Settings" component={Settings} />
</Stack.Navigator>
);
}
ওপরে আমরা createStackNavigator-এর জন্য ParamList টাইপ যোগ করেছি। কিন্তু আচ্ছা, আমরা কীভাবে জানব যে createStackNavigator একটি generic টাইপ নেয়? এটা বের করার কয়েকটি উপায় আছে। প্রথমে ডকুমেন্টেশন দেখে নেওয়া সবসময়ই ভালো অভ্যাস। এই উদাহরণে আপনি দেখবেন ডকুমেন্টেশনে এর জন্য আগে থেকেই একটি অংশ আছে।
অন্যদিকে, ধরুন createStackNavigator-এর এই নির্দিষ্ট টাইপিং ওয়েবসাইটে ডকুমেন্ট করা নেই, তাহলে ফাংশনটির টাইপিং আছে কি না বোঝার একটি সম্ভাব্য উপায় হলো সরাসরি ফাংশনের type definition-এ চলে যাওয়া। শুরুতে এটা ভয় ধরাতে পারে, কারণ চারপাশে অনেক টাইপ, interface আর generic উড়ে বেড়াবে, কিন্তু type definition-এ যাওয়ার অভ্যাস যত গড়ে উঠবে, ততই এটা কম চাপের মনে হবে।
আপডেট!
আপনি যদি TypeScript-এর বাড়তি জটিলতা সামলাতে চান আর React টিমের চমৎকার TS utility (React.ComponentProps) উপেক্ষা করতে চান, তাহলে এই আর্টিকেলের শেষ পর্যন্ত পড়তে থাকুন।
তবে আমার আশঙ্কা, এই অংশটাই হয়তো শেষ!
React.ComponentProps
সম্পূর্ণ উদাহরণের জন্য নিচে দেখুন:
import { createStackNavigator } from "@react-navigation/stack";
import * as React from "react";
import { View } from "react-native";
type AppStackParamList = {
Home: undefined;
Notifications: undefined;
Profile: undefined;
Settings: undefined;
};
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
const Stack = createStackNavigator<AppStackParamList>();
const routes: Array<React.ComponentProps<typeof Stack.Screen>> = [
{
name: "Home",
component: Home,
},
{
name: "Notifications",
component: Notifications,
},
{
name: "Profile",
component: Profile,
},
{
name: "Settings",
component: Settings,
},
];
function AppStack() {
return (
<Stack.Navigator>
{routes.map((routeConfig) => (
<Stack.Screen key={routeConfig.name} {...routeConfig} />
))}
</Stack.Navigator>
);
}
আর হ্যাঁ, এতেও intellisense থাকবে, আর আপনি যদি stack-এ অসম্পর্কিত কোনো screen বসান (যেমন এমন একটি screen যা আপনার stack type declaration-এ নেই), তাহলে এটি এখনো সতর্ক করবে, এভাবে:
অবৈধ screen
Intellisense-ও থাকবে:

এটি আরও পরিষ্কার, কনফিগারযোগ্য আর ডাইনামিক:
const getAuthStackRoutes = (
// other parameters...
theme: ThemeType
): Array<React.ComponentProps<typeof Stack.Screen>> => {
// more business logic...
return [
{
name: "Home",
component: Home,
options: {
headerStyle: {
backgroundColor: theme.colors.primary,
// other theme stylings...
},
},
},
];
};
শেষ কথা হলো, এই পদ্ধতি আমাদের জটিল নেভিগেশন কাঠামো সহজে সামলাতে দেয় (অন্তত এই আর্টিকেলের অন্য পদ্ধতিগুলোর সাথে এই নির্দিষ্ট পদ্ধতির তুলনা করলে)। কারণ আপনার JSX আরও পরিষ্কার হবে, আবার আপনি route-গুলো আরও ডাইনামিক আর মডুলার উপায়ে কনফিগার করতে পারবেন।
TypeScript-এর ব্যবহার আরও এক ধাপ এগিয়ে নেওয়া
এটি শুধু createStackNavigator-এর generic টাইপ ঘোষণার মধ্যে সীমাবদ্ধ নয়। Stack.Navigator-এর children এলিমেন্টের টাইপ নিয়ে কী বলবেন? এই ধারণাটি অফিসিয়াল ডকুমেন্টেশনে আগে থেকেই বেশ ভালোভাবে ব্যাখ্যা করা আছে, তবু চলুন নিচে দেখি কাঠামোটি আরও বিচ্ছিন্নভাবে তৈরি করতে এটা নিয়ে কীভাবে খেলা যায়।
import type { RouteConfig, StackNavigationState } from "@react-navigation/core";
import {
createStackNavigator,
StackNavigationEventMap,
StackNavigationOptions,
} from "@react-navigation/stack";
import * as React from "react";
import { View } from "react-native";
// stack param list type
type AppStackParamList = {
Home: undefined;
Notifications: undefined;
Profile: undefined;
Settings: undefined;
};
// type of the single route in app stack
type AppStackRoutesType = RouteConfig<
AppStackParamList,
keyof AppStackParamList,
StackNavigationState<AppStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
// mocking the screen components for the sake of example
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
// strictly typed array of app stack routes
const appStackRoutes: Array<AppStackRoutesType> = [
{
name: "Home",
component: Home,
},
{
name: "Notifications",
component: Notifications,
},
{
name: "Profile",
component: Profile,
},
{
name: "Settings",
component: Settings,
},
];
const Stack = createStackNavigator<AppStackParamList>();
function AppStack() {
return (
<Stack.Navigator>
{/** mapping the app stack routes */}
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
উফ, এখানে অনেক কিছু ঘটছে… চলুন প্রতিটি কোড ব্লককে আলাদা অংশে ভাগ করি।
import type { RouteConfig, StackNavigationState } from "@react-navigation/core";
import {
createStackNavigator,
StackNavigationEventMap,
StackNavigationOptions,
} from "@react-navigation/stack";
import * as React from "react";
import { View } from "react-native";
কোড স্নিপেটের শুরুতে আমরা প্রয়োজনীয় মডিউলগুলো import করছি। এই import-গুলোর মধ্যে আছে টাইপ, ফাংশন আর অন্যান্য প্রয়োজনীয় জিনিস। এগুলো আকর্ষণীয় নয়, কিন্তু দরকারি :)
// mocking the screen components for the sake of example
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
ওপরে আমরা react-native থেকে View কম্পোনেন্ট import করছি, যাতে উদাহরণটি আরও সহজভাবে দেখানো যায়।
// type of the single route in app stack
type AppStackRoutesType = RouteConfig<
AppStackParamList,
keyof AppStackParamList,
StackNavigationState<AppStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
এবার আসছে আকর্ষণীয় অংশ। @react-navigation/core থেকে import করা RouteConfig ঠিক পাঁচটি টাইপকে generic টাইপ হিসেবে নেয়। আর এই নির্দিষ্ট type definition অফিসিয়াল react-navigation ওয়েবসাইটে ডকুমেন্ট করা নেই, তবু ওপরে যেমন বলেছি, type definition-এ চলে যাওয়ার পদ্ধতি দিয়েই আপনি এটা বের করে ফেলতে পারেন।
একটি সাধারণ react-native TypeScript প্রজেক্টে এটা অপ্রয়োজনীয় বা বাড়তি মনে হতে পারে, কিন্তু এর বেশ কিছু সুবিধা আছে, যেগুলো নিচের অংশে দেখানো হবে।
IntelliSense
যেহেতু আমাদের stack route-এর (অর্থাৎ অ্যাপের route-এর) array কঠোরভাবে টাইপ করা, তাই array-এর প্রতিটি এলিমেন্ট এখন array-এর type definition মানতে বাধ্য। এর মানে array-তে নতুন এলিমেন্ট যোগ করার সময় IntelliSense সরাসরি কাজ করবে।
তার ওপর এই টাইপ প্রয়োগ করলে অ্যাপের route-এ নতুন এলিমেন্ট যোগ করার সময় প্রতিবার আমাদের AppStackRoutesType আপডেট করতে বাধ্য হতে হয়। না হলে AppStackRoutesType (AppStackParamList)-এ নেই এমন নতুন এলিমেন্ট আমরা যোগ করতে পারব না।
route-গুলো map করা
এবার শেষ অংশ, আমরা createStackNavigator দিয়ে stack navigator তৈরি করছি। তারপর ব্যাপারটা শুধু ওপরে তৈরি করা array-টি তার কঠোর টাইপসহ map করা।
শেষ পর্যন্ত আমরা array-এর প্রতিটি এলিমেন্টের ওপর ভরসা করতে পারি, এতে সঠিকভাবে টাইপ করা এলিমেন্ট থাকবে, তাই spread syntax ব্যবহার করা নিরাপদ।
const Stack = createStackNavigator<AppStackParamList>();
function AppStack() {
return (
<Stack.Navigator>
{/** mapping the app stack routes */}
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
এটাই কি সত্যিই শেষ অংশ ছিল?
আসলে… না!
যে উদাহরণটি দেখলাম, তাতে আমরা টাইপিং আরও উন্নত করতে পারি।
// generic stack routes type
export type StackRoutesType<ParamList extends ParamListBase> = Array<
RouteConfig<
ParamList,
keyof ParamList,
StackNavigationState<ParamList>,
StackNavigationOptions,
StackNavigationEventMap
>
>;
type AppStackRoutesType = StackRoutesType<AppStackParamList>;
// mocking the screen components for the sake of example
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
// strictly typed array of app stack routes
const appStackRoutes: AppStackRoutesType = [
{
name: "Home",
component: Home,
},
{
name: "Notifications",
component: Notifications,
},
{
name: "Profile",
component: Profile,
},
{
name: "Settings",
component: Settings,
},
];
আপনি হয়তো যে পার্থক্যটা লক্ষ করেছেন তা হলো আমাদের একটি StackRoutesType আছে, যেটি একটি generic টাইপ নেয় এবং আগে দেখা টাইপের সমান। কিন্তু আপনি জিজ্ঞেস করতে পারেন, এখানে লাভটা কী। এই প্রশ্নের উত্তর দৃশ্যমানভাবে দেওয়াই ভালো।
// too much duplicated code...
type AppStackRoutesType = RouteConfig<
AppStackParamList,
keyof AppStackParamList,
StackNavigationState<AppStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
type OtherStackRoutesType = RouteConfig<
OtherStackParamList,
keyof OtherStackParamList,
StackNavigationState<OtherStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
type AnotherStackRoutesType = RouteConfig<
AnotherStackParamList,
keyof AnotherStackParamList,
StackNavigationState<AnotherStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
আমরা যদি generic StackRoutesType ব্যবহার না করতাম, তাহলে অ্যাপের প্রতিটি stack-এর জন্য টাইপিং ডুপ্লিকেট করতে হতো।
ফলে অ্যাপ বড় হওয়ার সাথে সাথে এটা একটা দুঃস্বপ্ন হয়ে উঠত। (এখানে ধারণাটা হলো, অ্যাপে stack-এর সংখ্যা আর অ্যাপের জটিলতা সরাসরি সমানুপাতিক; আসলে এটা সবসময় ১০০% সঠিক অনুমান নয়, তবু এই নির্দিষ্ট উদাহরণের জন্য উপযুক্ত)
// generic stack routes type
export type StackRoutesType<ParamList extends ParamListBase> = Array<
RouteConfig<
ParamList,
keyof ParamList,
StackNavigationState<ParamList>,
StackNavigationOptions,
StackNavigationEventMap
>
>;
// becomes one line typings for each stack
type AppStackRoutesType = StackRoutesType<AppStackParamList>;
type OtherStackRoutesType = StackRoutesType<OtherStackParamList>;
type AnotherStackRoutesType = StackRoutesType<AnotherStackParamList>;
অন্যদিকে, ওপরে দেখুন generic টাইপ ব্যবহার করলে এখন এটা কত সহজ আর পরিষ্কার হয়ে যায়।
সর্বশেষ চিত্র
চলুন তুলনা করি দুটি আলাদা পরিস্থিতিতে একটি সাধারণ Stack ফাংশন দেখতে কেমন হবে:
চিত্র ১: JSX-এ সব stack screen এক এক করে রেন্ডার করা।
// ...imports, components
function AppStack() {
return (
<Stack.Navigator>
<Stack.Screen name="Home" component={Home} />
<Stack.Screen name="Notifications" component={Notifications} />
<Stack.Screen name="Profile" component={Profile} />
<Stack.Screen name="Settings" component={Settings} />
{/** n more screens... */}
</Stack.Navigator>
);
}
চিত্র ২: কঠোরভাবে টাইপ করা TypeScript দিয়ে তৈরি stack route array ব্যবহার করে screen রেন্ডার করা। 🎉
function AppStack() {
return (
<Stack.Navigator>
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
আরও একটা কথা… Navigator props-এর কী হবে
ভাবার মতো আরও একটা জিনিস বাকি থাকতে পারে, সেটা হলো stack navigator-এর props। নিচের StackNavigator দেখলে বোঝা যায়, একটি navigator-এর জন্যই একগাদা কনফিগারেশন আছে। এই কনফিগারেশনগুলো JSX থেকে আলাদা করে রাখলে কেমন হয়?
import type {
DefaultNavigatorOptions,
ParamListBase,
StackNavigationState,
} from "@react-navigation/core";
import {
StackNavigationEventMap,
StackNavigationOptions,
} from "@react-navigation/stack";
// other necessary imports for screens...
// generic typing for stack navigator options
type StackNavigatorOptions<ParamList extends ParamListBase> =
DefaultNavigatorOptions<
ParamList,
StackNavigationState<ParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
// omit the children as it corresponds to stack screen
const appStackNavigatorProps: Omit<
StackNavigatorOptions<AppStackParamList>,
"children"
> = {
initialRouteName: "Home",
screenOptions: {
headerShown: false,
cardOverlayEnabled: true,
gestureEnabled: false,
cardStyle: {
backgroundColor: "royalblue",
},
headerLeftContainerStyle: {
backgroundColor: "firebrick",
},
presentation: "modal",
headerTitleStyle: {
fontSize: 24,
color: "olivedrab",
},
},
// ...rest
};
// screen components and stack routes...
function AppStack() {
return (
<Stack.Navigator {...appStackNavigatorProps}>
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
Line 13 থেকে শুরু করে, আমরা কেন generic টাইপ ব্যবহার করি তা ইতিমধ্যে আমাদের জানা থাকার কথা। stack route-এর সাথে টাইপিংয়ে এখানে একমাত্র পার্থক্য হতে পারে DefaultNavigatorOptions টাইপ, যেটি @react-navigation/core থেকে import করা। টাইপের নামই সবকিছু বলে দেয়, এটা navigator-এর options।
ওপরে বলা RouteConfig টাইপের মতোই এটিও একাধিক generic টাইপ নেয়। এছাড়া মনে রাখবেন, আমরা স্পষ্টভাবে children key-টি বাদ দিচ্ছি (Omit), কারণ আমরা ইতিমধ্যে Stack.Navigator-এর children রেন্ডার করছি, যেগুলো Stack.Screen-এর সাথে মেলে।
Line 22-এ আমরা একদম নতুন একটি অবজেক্ট তৈরি করছি (অথবা এটা একটি ফাংশনও হতে পারে, যতক্ষণ এটি navigator options টাইপ মেনে চলা একটি অবজেক্ট ফেরত দেয়), যেটি আমাদের navigator-এর options প্রকাশ করবে।
ফলে Line 50-এ, প্রদত্ত টাইপ মেনে চললে এই অবজেক্টটি spread syntax দিয়ে নিরাপদে ব্যবহার করা যায়।
অনেক পরিষ্কার JSX… আমার মতে…
সর্বশেষ চিত্র: Navigator props
চলুন আবার তুলনা করি দুটি আলাদা পরিস্থিতিতে একটি সাধারণ Stack ফাংশন দেখতে কেমন হবে:
চিত্র ১: stack navigator-এর কনফিগারেশন JSX-এর ভেতরে রাখা।
function AppStack() {
return (
<Stack.Navigator
initialRouteName="Home"
screenOptions={{
headerShown: false,
cardOverlayEnabled: true,
gestureEnabled: false,
cardStyle: {
backgroundColor: "royalblue",
},
headerLeftContainerStyle: {
backgroundColor: "firebrick",
},
presentation: "modal",
headerTitleStyle: {
fontSize: 24,
color: "olivedrab",
},
}}
// rest...
>
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
চিত্র ২: stack navigator-এর কনফিগারেশন JSX থেকে আলাদা রাখা।
// ...
function AppStack() {
return (
<Stack.Navigator {...appStackNavigatorProps}>
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
উপসংহার
এই আর্টিকেলে আমরা দেখেছি কীভাবে TypeScript-কে সত্যিকারভাবে কাজে লাগিয়ে react-native navigator-গুলো আরও পরিষ্কার উপায়ে সাজানো যায়।
সবার দিন বাগমুক্ত কাটুক।
প্রকাশিত হয়েছে
এই আর্টিকেলটি এখানেও প্রকাশিত হয়েছে: