# Cara Menyusun Navigasi di React Native dengan TypeScript

By Tarik Pinarci (https://tarikpinarci.com). Published 2022-09-24. Canonical: https://tarikpinarci.com/id/blog/react-navigation-with-typescript

Manfaatkan typing-nya: React Navigation

Navigasi sudah menjadi fitur dasar setiap aplikasi mobile saat ini. Di dunia React Native, kita punya [React Navigation](https://reactnavigation.org/) di saku kita.

Artikel ini akan membahas bagaimana React Navigation yang umum bisa diimplementasikan dengan TypeScript, sambil membandingkan beberapa strategi penggunaan TypeScript.

Dan yang lebih penting, artikel ini juga akan membahas bagaimana kita bisa memaksimalkan fitur TypeScript untuk membangun arsitektur navigasi yang lebih scalable.

> Catatan: Contoh di artikel ini dibuat menggunakan versi @react-navigation@6.x.

> Catatan: Metode atau strategi yang dibahas di artikel ini bukan sesuatu yang wajib kamu ikuti dengan ketat. Ini hanyalah preferensi saya yang menurut saya berguna untuk dibagikan kepada pembaca artikel ini. [React Navigation sudah punya bagian dokumentasi yang luar biasa tentang penggunaan typescript.](https://reactnavigation.org/docs/typescript) Dengan kata lain, kamu sudah bisa membangun struktur typescript react-navigation yang keren hanya dengan mengikuti [dokumentasi ini](https://reactnavigation.org/docs/typescript/).

### Membuat Stack Navigator

Mari kita lihat cara membuat [stack navigator](https://reactnavigation.org/docs/stack-navigator/) menggunakan package [React Navigation ](https://reactnavigation.org/).

Lihat contoh di bawah yang diambil dari [React Navigation](https://reactnavigation.org/docs/stack-navigator/#api-definition):

```tsx
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>
  );
}
```

Seperti yang terlihat, belum ada yang spesifik tentang TypeScript di sini. Mari kita tambahkan sedikit TypeScript ke potongan kode ini.

```tsx
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>
  );
}
```

Di atas, kita menambahkan tipe ParamList untuk createStackNavigator. Tapi tunggu, bagaimana kita tahu bahwa createStackNavigator menerima generic type? Ada beberapa cara untuk mengetahuinya. Membaca [dokumentasi](https://reactnavigation.org/docs/typescript/#type-checking-the-navigator) terlebih dahulu selalu menjadi kebiasaan yang baik. Pada contoh ini, kamu akan langsung melihat bahwa sudah ada bagian khusus untuk hal ini di dokumentasi.

Di sisi lain, anggap saja typing spesifik createStackNavigator ini tidak didokumentasikan di website. Cara yang mungkin untuk mengetahui apakah fungsi tersebut punya typing adalah langsung melompat ke type definition fungsi itu. Awalnya mungkin terasa mengintimidasi karena akan ada banyak type, interface, dan generic di mana-mana, tetapi makin terbiasa kamu melompat ke type definition, makin tidak membingungkan rasanya.

### **Update!**

Kalau kamu mau menghadapi kompleksitas tambahan dengan typescript dan juga ingin mengabaikan utilitas TS brilian dari tim React (React.ComponentProps), kamu bisa lanjut membaca sampai akhir artikel ini.

Tapi saya khawatir, bagian ini mungkin sudah menjadi akhirnya!

Kita bisa mendapatkan typing untuk setiap stack screen beserta konfigurasinya dengan React.ComponentProps<typeof YourStack.Screen>. Dan hasilnya benar-benar luar biasa.

Lihat contoh lengkapnya di bawah:

```tsx
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>
  );
}
```

Dan ya, intellisense tetap ada, dan kamu tetap akan diperingatkan kalau memasukkan screen yang tidak berkaitan *(misalnya: screen yang tidak ada di deklarasi tipe stack kamu)* ke dalam stack, seperti ini:

![Screen tidak valid](https://cdn-images-1.medium.com/max/3176/1*LkS3Ay_QPrWIDMZZCsOpZQ.png)_Screen tidak valid_

Intellisense juga tetap ada:

![](https://cdn-images-1.medium.com/max/2124/1*zWJw4fN3Fs0IpOd-rSAIQA.png)

Cara ini juga lebih bersih, mudah dikonfigurasi, dan dinamis:

```tsx
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...
        },
      },
    },
  ];
};
```

Kesimpulannya, pendekatan ini memungkinkan kita mengelola struktur navigasi yang kompleks dengan mudah *(setidaknya jika dibandingkan dengan pendekatan lain di artikel ini)*. Alasannya, selain JSX yang lebih bersih, kamu juga bisa mengonfigurasi route dengan cara yang lebih dinamis dan modular.

### Membawa penggunaan TypeScript selangkah lebih jauh

Ini tentu tidak terbatas pada deklarasi generic type untuk createStackNavigator saja. Bagaimana dengan tipe elemen children yang akan dimiliki Stack.Navigator? Walaupun [konsep ini sudah dijelaskan dengan cukup baik di dokumentasi resmi](https://reactnavigation.org/docs/typescript/#type-checking-screens), mari kita lihat di bawah bagaimana kita bisa bereksperimen dengannya untuk mendapatkan cara membangun struktur yang lebih terpisah.

```tsx
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>
  );
}
```

Waduh, banyak sekali yang terjadi di sini… Mari kita bagi setiap blok kode menjadi beberapa bagian.

```tsx
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";
```

Di bagian atas potongan kode, kita meng-import modul yang dibutuhkan. Import ini mencakup type, fungsi, dan hal lain yang diperlukan. Tidak menarik, tapi perlu :)

```tsx
// mocking the screen components for the sake of example
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
```

Di atas, kita meng-import komponen [View](https://reactnative.dev/docs/view) dari react-native supaya contohnya bisa ditunjukkan dengan lebih sederhana.

```tsx
// type of the single route in app stack
type AppStackRoutesType = RouteConfig<
  AppStackParamList,
  keyof AppStackParamList,
  StackNavigationState<AppStackParamList>,
  StackNavigationOptions,
  StackNavigationEventMap
>;
```

Nah, sekarang bagian yang menarik. RouteConfig yang di-import dari @react-navigation/core menerima tepat lima tipe sebagai [generic type](https://www.typescriptlang.org/docs/handbook/2/generics.html). Type definition ini tidak didokumentasikan di website resmi react-navigation, tetapi kamu tetap bisa memahaminya dengan cara melompat ke type definition seperti yang kita bahas di atas.

Walaupun mungkin terlihat berlebihan atau tidak perlu di proyek react-native typescript pada umumnya, cara ini punya beberapa manfaat yang akan dibahas di bagian berikut.

### [IntelliSense](https://code.visualstudio.com/docs/editor/intellisense)

Karena kita punya array stack route (alias route aplikasi) yang bertipe ketat, setiap elemen array sekarang wajib mengikuti type definition array tersebut. Artinya IntelliSense langsung bekerja saat kita menambahkan elemen baru ke array.

Selain itu, menerapkan tipe ini memaksa kita memperbarui AppStackRoutesType *setiap kali ada elemen baru yang akan ditambahkan ke route aplikasi. Kalau tidak, kita tidak akan bisa menambahkan elemen baru yang tidak ada di AppStackRoutesType (AppStackParamList)*.

### Memetakan route

Inilah bagian terakhir: kita membuat stack navigator memakai createStackNavigator. Setelah itu, tinggal memetakan array yang kita buat di atas beserta tipe ketatnya.

Pada akhirnya kita bisa memercayai setiap elemen array kita. Semua elemennya bertipe dengan benar, jadi aman untuk memakai [spread syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax).

```tsx
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>
  );
}
```

### Apakah itu benar-benar bagian terakhir?

Hmm… Tidak!

Kita masih bisa memperbaiki typing pada contoh yang sudah kita bahas.

```tsx
// 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,
  },
];
```

Perbedaan yang mungkin kamu perhatikan adalah kita punya StackRoutesType yang menerima generic type dan sama dengan tipe yang sudah kita lihat sebelumnya. Tapi apa manfaatnya, mungkin kamu bertanya. Lebih baik pertanyaan ini dijawab secara visual.

```tsx
// 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
>;
```

Kalau kita tidak memilih memakai StackRoutesType yang generic, kita harus menduplikasi typing untuk setiap stack yang ada di aplikasi.

Akibatnya, ini akan menjadi mimpi buruk saat aplikasi makin besar. _(gagasannya di sini adalah jumlah stack di aplikasi berbanding lurus dengan kompleksitas aplikasi. Kenyataannya, asumsi ini tidak selalu 100% benar, tetapi cukup cocok untuk contoh khusus ini)_

```tsx
// 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>;
```

Sebaliknya, lihat di atas betapa lebih sederhana dan bersihnya sekarang saat memakai generic type.

## Gambaran akhir

Mari kita bandingkan bagaimana fungsi Stack yang umum akan terlihat dalam dua skenario berbeda:

_Gambar 1: Merender seluruh stack screen satu per satu di JSX._

```tsx
// ...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>
  );
}
```

_Gambar 2: Merender screen menggunakan array stack route yang dibuat dengan typescript bertipe ketat. 🎉_

```tsx
function AppStack() {
  return (
    <Stack.Navigator>
      {appStackRoutes.map((stackRoute) => (
        <Stack.Screen key={stackRoute.name} {...stackRoute} />
      ))}
    </Stack.Navigator>
  );
}
```

### Satu hal lagi… Bagaimana dengan props Navigator

Mungkin masih ada satu hal lagi yang perlu dipertimbangkan, yaitu props dari stack navigator. Kalau melihat StackNavigator di bawah, ada sekumpulan konfigurasi untuk satu navigator. Kenapa tidak memisahkan konfigurasi ini dari JSX?

```tsx
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>
  );
}
```

Mulai dari Baris 13, kita seharusnya sudah paham kenapa kita memakai generic type. Perbedaan kecil dalam typing dibandingkan stack route di sini mungkin adalah tipe DefaultNavigatorOptions, yang di-import dari @react-navigation/core. Nama tipenya sendiri sudah menjelaskan maksudnya: ini adalah options untuk navigator.

Mirip dengan tipe *RouteConfig* yang sudah kita bahas di atas, tipe ini juga menerima beberapa generic type. Selain itu, ingat bahwa kita secara eksplisit [melakukan *omit*](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) pada key children, karena kita sudah merender children Stack.Navigator yang berupa Stack.Screen.

Di Baris 22, kita membuat objek baru (atau bisa juga fungsi, selama fungsi itu mengembalikan objek yang memenuhi tipe navigator options) yang merepresentasikan options navigator kita.

Hasilnya, di Baris 50, objek ini bisa dipakai dengan aman menggunakan spread syntax selama memenuhi tipe yang diberikan.

JSX jadi jauh lebih bersih… Menurut saya…

### Gambaran akhir: props Navigator

Sekali lagi, mari kita bandingkan bagaimana fungsi Stack yang umum akan terlihat dalam dua skenario berbeda:

_Gambar 1: Konfigurasi stack navigator berada di JSX._

```tsx
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>
  );
}
```

_Gambar 2: Konfigurasi stack navigator dipisahkan dari JSX._

```tsx
// ...

function AppStack() {
  return (
    <Stack.Navigator {...appStackNavigatorProps}>
      {appStackRoutes.map((stackRoute) => (
        <Stack.Screen key={stackRoute.name} {...stackRoute} />
      ))}
    </Stack.Navigator>
  );
}
```

---

### Kesimpulan

Di artikel ini, kita sudah membahas bagaimana kita bisa benar-benar memanfaatkan TypeScript dan mendapatkan cara yang lebih bersih untuk menyusun navigator react-native.

Semoga hari kalian bebas bug.

### Diterbitkan di

Artikel ini juga diterbitkan di:

- [Medium](https://medium.com/better-programming/react-navigation-with-typescript-fa7805f52ab0)

