# React Native'de TypeScript ile Navigasyon Nasıl Yapılandırılır

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

React Navigation: tiplerden sonuna kadar yararlanın

Navigasyon kurmak bugünlerde her mobil uygulamanın temel özelliği haline geldi. React Native dünyasında ise cebimizde [React Navigation](https://reactnavigation.org/) var.

Bu yazıda tipik bir React Navigation yapısının TypeScript ile nasıl kurulabileceğini ele alırken, TypeScript kullanımındaki farklı stratejileri de karşılaştıracağız.

Daha da önemlisi, navigasyonda daha ölçeklenebilir bir mimari kurabilmek için TypeScript özelliklerinden en iyi şekilde nasıl yararlanabileceğimizi de konuşacağız.

> Not: Bu yazıdaki örnekler @react-navigation@6.x sürümü kullanılarak hazırlandı.

> Not: Bu yazıda ele alınacak yöntemler/stratejiler kesinlikle uymanız gereken vazgeçilmez kurallar değil; sadece benim tercihlerim ve bu yazının okurlarıyla paylaşmaya değer bulduklarım. [React Navigation'ın typescript kullanımıyla ilgili zaten harika ve iyi belgelenmiş bir bölümü var.](https://reactnavigation.org/docs/typescript) Yani sadece [bu dokümantasyonu](https://reactnavigation.org/docs/typescript/) takip ederek bile harika bir react-navigation typescript yapısı kurabilirsiniz.

### Stack Navigator Oluşturmak

[React Navigation ](https://reactnavigation.org/)paketini kullanarak bir [stack navigator](https://reactnavigation.org/docs/stack-navigator/)'ın nasıl oluşturulacağına bakalım.

[React Navigation](https://reactnavigation.org/docs/stack-navigator/#api-definition)'dan alınan aşağıdaki örneğe bakın;

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

Görüldüğü gibi burada TypeScript'e özgü hiçbir şey yok, bu kod parçasına biraz TypeScript ekleyelim.

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

Yukarıda createStackNavigator için ParamList tipini ekledik. Ama durun, createStackNavigator'ın generic tip aldığını nereden biliyoruz? Bunu anlamanın birkaç yolu var. Önce [dokümantasyonu](https://reactnavigation.org/docs/typescript/#type-checking-the-navigator) incelemek her zaman iyi bir alışkanlık olmuştur. Bu örnekte dokümanlarda bunun için zaten bir bölüm olduğunu fark edeceksiniz.

Öte yandan, createStackNavigator'ın bu tiplemesinin web sitesinde belgelenmediğini varsayalım. Bu durumda fonksiyonun bu tiplemeye sahip olup olmadığını anlamanın olası bir yolu, doğrudan fonksiyonun tip tanımına atlamak olurdu. Ortalıkta uçuşan bir sürü tip, interface ve generic olacağı için ilk başta göz korkutucu olabilir, ama tip tanımına atlamayı alışkanlık haline getirdikçe çok daha az bunaltıcı olacaktır.

### **Güncelleme!**

Typescript ile fazladan karmaşıklıkla uğraşmak ve React ekibinin harika TS yardımcısını (React.ComponentProps) görmezden gelmek istiyorsanız, bu yazıyı sonuna kadar okumaya devam edebilirsiniz.

Ama korkarım bu bölüm sonun başlangıcı olabilir!

React.ComponentProps<typeof YourStack.Screen> ile her stack ekranının ve konfigürasyonunun tiplerini alabileceğiz. Sonuç da düpedüz harika olacak.

Tam örnek için aşağıya bakın:

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

Ve evet, intellisense yine çalışacak, stack'inize alakasız bir ekran *(örneğin stack tip tanımınızda olmayan bir ekran)* koyarsanız sizi yine uyaracak, şöyle ki:

![Geçersiz ekran](https://cdn-images-1.medium.com/max/3176/1*LkS3Ay_QPrWIDMZZCsOpZQ.png)_Geçersiz ekran_

Intellisense de orada olacak:

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

Ayrıca daha temiz, daha yapılandırılabilir ve daha dinamik:

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

Sonuç olarak bu yaklaşım, karmaşık navigasyon yapılarını kolayca yönetmemizi sağlıyor *(en azından bu yazıdaki diğer yaklaşımlarla karşılaştırdığımızda)*. Çünkü hem daha temiz bir JSX'iniz olacak hem de route'larınızı daha dinamik ve modüler bir şekilde yapılandırabileceksiniz.

### TypeScript kullanımını bir adım öteye taşımak

Bu iş sadece createStackNavigator'ın generic tipini tanımlamakla sınırlı değil. Peki Stack.Navigator'ın sahip olacağı children elemanlarının tipi ne olacak? [Bu kavram resmi dokümantasyonda zaten oldukça iyi tanımlanmış olsa da](https://reactnavigation.org/docs/typescript/#type-checking-screens), yapıyı daha ayrık (decoupled) bir şekilde oluşturmak için onunla nasıl oynayabileceğimize aşağıda bakalım.

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

Eyvah, burada çok şey oluyor... Her kod bloğunu ayrı parçalara bölelim.

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

Kod parçasının en üstünde gerekli modülleri import ediyoruz. Bu import'lar tipleri, fonksiyonları ve gereken diğer şeyleri içeriyor. İlginç değiller ama gerekliler :)

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

Yukarıda, örneği daha basit bir şekilde gösterebilmek için react-native'den [View](https://reactnative.dev/docs/view) component'ini import ediyoruz.

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

Şimdi geldik ilginç kısma. @react-navigation/core'dan import edilen RouteConfig, [generic tip](https://www.typescriptlang.org/docs/handbook/2/generics.html) olarak tam beş tip alıyor. Bu tip tanımı resmi react-navigation web sitesinde belgelenmemiş, yine de yukarıda bahsettiğimiz tip tanımına atlama yöntemiyle bu tip tanımını kendiniz çözebilirsiniz.

Tipik bir react-native typescript projesinde gereksiz görünebilse de, aşağıdaki bölümde ele alacağımız birkaç faydası var.

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

Artık sıkı şekilde tiplenmiş bir stack route'ları (yani uygulama route'ları) dizimiz olduğu için, dizinin her elemanı dizinin tip tanımına uymak zorunda. Bu da diziye yeni bir eleman eklerken IntelliSense'in kutudan çıktığı haliyle çalışacağı anlamına geliyor.

Dahası, bu tipi uygulamak bizi uygulama route'larına her yeni eleman eklendiğinde AppStackRoutesType'ı \* _güncellemeye zorluyor. Aksi halde AppStackRoutesType(AppStackParamList) içinde olmayan yeni bir eleman ekleyemeyiz_.\*

### Route'ları map etmek

Son kısma geldik: createStackNavigator kullanarak stack navigator'ı oluşturuyoruz. Ardından iş, yukarıda oluşturduğumuz diziyi sıkı tipiyle birlikte map etmekten ibaret.

Sonuçta dizimizin her elemanına güvenebiliriz; elemanlar doğru tiplenmiş olacak, dolayısıyla [spread syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax) kullanmak güvenli.

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

### Gerçekten son kısım mıydı?

Şey... Hayır!

Ele aldığımız örnekteki tiplemelerimizi hâlâ iyileştirebiliriz.

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

Fark etmiş olabileceğiniz fark şu: generic bir tip alan ve daha önce gördüğümüz tipe eşit olan bir StackRoutesType'ımız var. Peki burada fayda ne, diye sorabilirsiniz. Bu soruyu görsel olarak cevaplamak daha iyi.

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

Generic StackRoutesType'ı *kullanmamayı* seçseydik, uygulamadaki her stack için tiplemeleri tekrar tekrar yazmak zorunda kalırdık.

Bu da uygulama büyüdükçe bir kabusa dönüşürdü. _(buradaki varsayım, uygulamadaki stack sayısının uygulamanın karmaşıklığıyla doğru orantılı olması; aslında bu her zaman yüzde yüz geçerli bir varsayım değil, yine de bu örnek için uygun)_

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

Öte yandan, generic tip kullanınca her şeyin nasıl daha basit ve temiz hale geldiğine yukarıda bakın.

## Son durum

Tipik bir Stack fonksiyonunun iki farklı senaryoda nasıl görüneceğini karşılaştıralım:

_Görünüm 1: Tüm stack ekranlarını JSX içinde tek tek render etmek._

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

_Görünüm 2: Ekranları, sıkı tiplenmiş typescript ile oluşturulan stack route'ları dizisini kullanarak render etmek. 🎉_

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

### Bir şey daha... Navigator props'ları ne olacak

Ele almamız gereken bir şey daha kalmış olabilir: stack navigator'ın props'ları. Aşağıdaki StackNavigator'a *bakarsanız*, tek bir navigator için bir yığın konfigürasyon olduğunu görürsünüz. Neden bu konfigürasyonları JSX'ten ayırmayalım?

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

Kodun 13. satırından itibaren neden generic tip kullandığımıza zaten aşinayız. Buradaki stack route'larıyla tipleme açısından tek fark, @react-navigation/core'dan import edilen DefaultNavigatorOptions tipi olabilir. Tipin adı bile kendini açıklıyor: navigator için seçenekler.

Yukarıda *bahsettiğimiz RouteConfig* tipine \* _benzer şekilde_, *bu da birden fazla generic tip alıyor. Bunun yanında, Stack.Screen'e karşılık gelen Stack.Navigator* _children'larını zaten render ettiğimiz için_ _children key'ini açıkça_ [*omit ettiğimizi*](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) unutmayın.\*

Kodun 22. satırında, navigator'ımızın seçeneklerini temsil edecek yepyeni bir nesne oluşturuyoruz (navigator options tipini karşılayan bir nesne döndürdüğü sürece bir fonksiyon da olabilir).

Sonuç olarak kodun 50. satırında, verilen tipi karşıladığı sürece bu nesne spread syntax ile güvenle kullanılabiliyor.

Çok daha temiz bir JSX... Bence...

### Son durum: Navigator props'ları

Tipik bir Stack fonksiyonunun iki farklı senaryoda nasıl görüneceğini yine karşılaştıralım:

_Görünüm 1: Stack navigator konfigürasyonlarını JSX içinde tutmak._

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

_Görünüm 2: Stack navigator konfigürasyonlarını JSX'ten ayırmak._

```tsx
// ...

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

---

### Sonuç

Bu yazıda TypeScript'ten gerçekten nasıl yararlanabileceğimizi ve react-native navigator'larımızı daha temiz bir şekilde nasıl yapılandırabileceğimizi ele aldık.

Herkese hatasız bir gün dilerim.

### Yayınlandığı yerler

Bu yazı ayrıca şurada da yayınlandı:

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

