Blog

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

24 Eylül 2022 8 dk okuma

TypeScript ile React Navigation v6'da ustalaşın. React Native uygulamalarında tip güvenli navigasyonu, parametre aktarımını ve ileri seviye navigasyon kalıplarını öğrenin.

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

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 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. Yani sadece bu dokümantasyonu takip ederek bile harika bir react-navigation typescript yapısı kurabilirsiniz.

Stack Navigator Oluşturmak

React Navigation paketini kullanarak bir stack navigator'ın nasıl oluşturulacağına bakalım.

React Navigation'dan alınan aşağıdaki örneğe bakın;

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.

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 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 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:

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 ekranGeçersiz ekran

Intellisense de orada olacak:

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

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, yapıyı daha ayrık (decoupled) bir şekilde oluşturmak için onunla nasıl oynayabileceğimize aşağıda bakalım.

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.

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 :)

// 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 component'ini import ediyoruz.

// 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 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

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 kullanmak güvenli.

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.

// 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.

// 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)

// 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.

// ...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. 🎉

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?

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 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.

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.

// ...

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ı: