# Jak ułożyć strukturę nawigacji w React Native z TypeScriptem

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

Wykorzystaj typowanie: React Navigation

Nawigacja jest dziś podstawową funkcją każdej aplikacji mobilnej. W świecie React Native mamy w kieszeni [React Navigation](https://reactnavigation.org/).

W tym artykule pokażę, jak można zaimplementować typową nawigację w React Navigation z użyciem TypeScriptu, porównując przy okazji różne strategie korzystania z TypeScriptu.

A co ważniejsze, omówię też, jak w pełni wykorzystać możliwości TypeScriptu, żeby zbudować bardziej skalowalną architekturę nawigacji.

> Uwaga: Przykłady w tym artykule powstały na wersji @react-navigation@6.x.

> Uwaga: Metody i strategie omówione w tym artykule nie są niezbędne i nie musisz się ich ściśle trzymać. To po prostu moje preferencje, które uznałem za przydatne i warte podzielenia się z czytelnikami. [React Navigation ma już świetnie udokumentowaną sekcję o używaniu TypeScriptu.](https://reactnavigation.org/docs/typescript) Mimo to świetną strukturę react-navigation z TypeScriptem możesz zbudować, po prostu trzymając się [tej dokumentacji](https://reactnavigation.org/docs/typescript/).

### Tworzenie stack navigatora

Zobaczmy, jak stworzyć [stack navigator](https://reactnavigation.org/docs/stack-navigator/) przy użyciu paczki [React Navigation ](https://reactnavigation.org/).

Spójrz na poniższy przykład wzięty z [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>
  );
}
```

Jak widać, nie ma tu nic specyficznego dla TypeScriptu, więc dodajmy do tego fragmentu trochę TypeScriptu.

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

Powyżej dodaliśmy typ ParamList dla createStackNavigator. Ale chwila, skąd wiemy, że createStackNavigator przyjmuje typ generyczny? Jest kilka sposobów, żeby to sprawdzić. Dobrą praktyką zawsze było zajrzenie najpierw do [dokumentacji](https://reactnavigation.org/docs/typescript/#type-checking-the-navigator). W tym przykładzie od razu zauważysz, że w dokumentacji jest na to osobna sekcja.

Z drugiej strony, zakładając, że to konkretne typowanie createStackNavigator nie jest opisane na stronie, jednym ze sposobów na sprawdzenie, czy funkcja ma typowanie, jest po prostu przejście do definicji typu tej funkcji. Na początku może to onieśmielać, bo wszędzie latają typy, interfejsy i generyki, ale im bardziej wejdzie ci w nawyk przechodzenie do definicji typu, tym mniej będzie to przytłaczające.

### **Aktualizacja!**

Jeśli chcesz mierzyć się z dodatkową złożonością TypeScriptu i przy okazji zignorować świetne narzędzie TS od zespołu Reacta (React.ComponentProps), możesz czytać dalej do końca artykułu.

Ale obawiam się, że ta sekcja może być końcem!

Typowanie każdego ekranu w stacku i jego konfiguracji możemy uzyskać przez React.ComponentProps<typeof YourStack.Screen>, a efekt będzie po prostu niesamowity.

Pełny przykład poniżej:

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

I tak, nadal będziesz mieć IntelliSense, a TypeScript nadal ostrzeże cię, jeśli dodasz do stacka niepowiązany* (czyli np. ekran, którego nie ma w deklaracji typu twojego stacka)* ekran, na przykład:

![Nieprawidłowy ekran](https://cdn-images-1.medium.com/max/3176/1*LkS3Ay_QPrWIDMZZCsOpZQ.png)_Nieprawidłowy ekran_

IntelliSense też będzie na miejscu:

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

Jest to też czystsze, bardziej konfigurowalne i dynamiczne:

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

Podsumowując, to podejście pozwala łatwo zarządzać złożonymi strukturami nawigacji*(przynajmniej w porównaniu z innymi podejściami z tego artykułu)*. Wynika to z tego, że oprócz czystszego JSX możesz też konfigurować swoje trasy w bardziej dynamiczny, modularny sposób.

### Wykorzystanie TypeScriptu o krok dalej

Nie ogranicza się to oczywiście do zadeklarowania samego typu generycznego createStackNavigator. A co z typem elementów children, które będzie miał Stack.Navigator? Chociaż [ta koncepcja jest już całkiem dobrze opisana w oficjalnej dokumentacji](https://reactnavigation.org/docs/typescript/#type-checking-screens), zobaczmy poniżej, jak możemy się nią pobawić, żeby tworzyć strukturę w bardziej rozdzielony sposób.

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

Ups, dzieje się tu bardzo dużo… Podzielmy ten kod na osobne części.

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

Na górze fragmentu importujemy potrzebne moduły. Wśród tych importów są typy, funkcje i inne niezbędne rzeczy. Nie są ciekawe, ale są potrzebne :)

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

Powyżej importujemy komponent [View](https://reactnative.dev/docs/view) z react-native, żeby przykład dało się pokazać w prostszy sposób.

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

A teraz ciekawa część. RouteConfig importowany z @react-navigation/core przyjmuje dokładnie pięć typów jako [typ generyczny](https://www.typescriptlang.org/docs/handbook/2/generics.html). Ta konkretna definicja typu nie jest opisana na oficjalnej stronie react-navigation, ale i tak możesz ją rozgryźć, korzystając ze wspomnianej wyżej metody przechodzenia do definicji typu.

Choć w typowym projekcie react-native z TypeScriptem może się to wydawać zbędne albo niepotrzebne, daje kilka korzyści, które omówię w sekcji poniżej.

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

Ponieważ mamy ściśle typowaną tablicę tras stacka (czyli tras aplikacji), każdy element tablicy musi teraz trzymać się definicji typu tej tablicy. Oznacza to, że IntelliSense działa od razu przy dodawaniu nowego elementu do tablicy.

Co więcej, zastosowanie tego typu zmusza nas do aktualizowania AppStackRoutesType\* _za każdym razem, gdy do tras aplikacji trzeba dodać nowy element. W przeciwnym razie nie moglibyśmy dodać nowego elementu, którego nie ma w AppStackRoutesType(AppStackParamList)_.\*

### Mapowanie tras

Teraz ostatnia część: tworzymy stack navigator za pomocą createStackNavigator. Potem to już tylko kwestia zmapowania tablicy, którą stworzyliśmy wyżej, razem z jej ścisłym typem.

Ostatecznie możemy ufać każdemu elementowi naszej tablicy, bo będzie miał poprawne typy, więc można bezpiecznie użyć [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>
  );
}
```

### Czy to naprawdę była ostatnia część?

Cóż… Nie!

Typowanie w omawianym przykładzie wciąż możemy poprawić.

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

Różnica, którą być może zauważyłeś, polega na tym, że mamy StackRoutesType, który przyjmuje typ generyczny i jest równy typowi, który już widzieliśmy. Ale jaka jest z tego korzyść, zapytasz. Najlepiej odpowiedzieć na to pytanie wizualnie.

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

Gdybyśmy nie zdecydowali się na generyczny StackRoutesType*, *musielibyśmy duplikować typowanie dla każdego stacka w aplikacji.

W miarę rozrastania się aplikacji byłby to koszmar. _(chodzi tu o to, że liczba stacków w aplikacji i złożoność aplikacji są wprost proporcjonalne. W rzeczywistości to założenie nie zawsze jest w 100% prawdziwe, ale pasuje do tego konkretnego przykładu)_

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

Z drugiej strony zobacz powyżej, o ile prościej i czyściej robi się teraz z typem generycznym.

## Najnowsze obrazki

Porównajmy, jak typowa funkcja Stack wyglądałaby w dwóch różnych scenariuszach:

_Obrazek 1: Renderowanie wszystkich ekranów stacka jeden po drugim w 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>
  );
}
```

_Obrazek 2: Renderowanie ekranów za pomocą tablicy tras stacka stworzonej przy użyciu ściśle typowanego TypeScriptu. 🎉_

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

### Jeszcze jedno… A co z propsami navigatora

Została nam jeszcze jedna rzecz do rozważenia: propsy stack navigatora. Patrząc na poniższy StackNavigator*, *widać spory kawałek konfiguracji dla jednego navigatora. Czemu nie oddzielić tej konfiguracji od 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>
  );
}
```

Od linii 13 powinniśmy już rozumieć, dlaczego używamy typu generycznego. Jedyna różnica w typowaniu w porównaniu z trasami stacka to być może typ DefaultNavigatorOptions, importowany z @react-navigation/core. Sama nazwa typu mówi wszystko: to opcje navigatora.

Podobnie jak *typ RouteConfig *\* _wspomniany wyżej_, *też przyjmuje wiele typów generycznych. Poza tym pamiętaj, że jawnie [*pomijamy](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) _klucz children, bo już renderujemy children Stack.Navigator_, _które odpowiadają Stack.Screen_.\*

W linii 22 tworzymy zupełnie nowy obiekt (może to być też funkcja, o ile zwraca obiekt spełniający typ opcji navigatora), który będzie reprezentował opcje naszego navigatora.

W efekcie w linii 50 ten obiekt można bezpiecznie użyć ze spread syntax, o ile spełnia podany typ.

Dużo czystszy JSX… Moim zdaniem…

### Najnowsze obrazki: propsy navigatora

Porównajmy jeszcze raz, jak typowa funkcja Stack wyglądałaby w dwóch różnych scenariuszach:

_Obrazek 1: Konfiguracja stack navigatora w 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>
  );
}
```

_Obrazek 2: Konfiguracja stack navigatora oddzielona od JSX._

```tsx
// ...

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

---

### Podsumowanie

W tym artykule omówiliśmy, jak naprawdę wykorzystać TypeScript i uzyskać czystszy sposób na ułożenie struktury navigatorów w react-native.

Życzę wszystkim dnia bez bugów.

### Opublikowano na

Ten artykuł jest też opublikowany na:

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

