# Comment structurer la navigation dans React Native avec TypeScript

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

Tirer parti des typages de React Navigation

La navigation est devenue une fonctionnalité fondamentale de toute application mobile. Dans l’univers React Native, nous avons [React Navigation](https://reactnavigation.org/) sous la main.

Cet article montre comment implémenter une navigation React Navigation classique avec TypeScript, tout en comparant différentes stratégies d’utilisation de TypeScript.

Et surtout, il montre comment tirer le meilleur parti des fonctionnalités de TypeScript pour construire une architecture de navigation plus scalable.

> Attention : les exemples de cet article ont été réalisés avec la version @react-navigation@6.x.

> Attention : les méthodes et stratégies présentées dans cet article ne sont pas des règles indispensables à suivre à la lettre, ce sont simplement mes préférences, et je les ai trouvées utiles à partager avec les lecteurs de cet article. [React Navigation propose déjà une excellente section très bien documentée sur l’utilisation de typescript.](https://reactnavigation.org/docs/typescript) Cela dit, vous pouvez déjà construire une très bonne structure react-navigation en typescript en suivant simplement [cette documentation](https://reactnavigation.org/docs/typescript/).

### Créer un stack navigator

Voyons comment créer un [stack navigator](https://reactnavigation.org/docs/stack-navigator/) avec le package [React Navigation ](https://reactnavigation.org/).

Voici l’exemple tiré de [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>
  );
}
```

Comme on le voit, il n’y a rien de spécifique à TypeScript ici. Ajoutons un peu de TypeScript à cet extrait de code.

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

Ci-dessus, nous avons ajouté le type ParamList à createStackNavigator. Mais au fait, comment savoir que createStackNavigator accepte un type générique ? Il y a plusieurs façons de le découvrir. C’est toujours une bonne pratique de consulter d’abord la [documentation](https://reactnavigation.org/docs/typescript/#type-checking-the-navigator). Dans cet exemple, vous remarquerez qu’une section y est déjà consacrée dans la documentation.

En revanche, si ce typage précis de createStackNavigator n’était pas documenté sur le site, une façon de savoir si la fonction est typée serait simplement d’aller voir la définition de type de la fonction. Ça peut être intimidant au début, avec tous ces types, interfaces et génériques qui se baladent partout, mais plus vous prendrez l’habitude d’aller voir les définitions de type, moins ce sera écrasant.

### **Mise à jour !**

Si vous voulez gérer de la complexité supplémentaire avec typescript et ignorer un excellent utilitaire TS proposé par l’équipe React (React.ComponentProps), vous pouvez lire cet article jusqu’au bout.

Mais j’ai bien peur que cette section soit la dernière !

Nous pouvons récupérer les typages de chaque écran du stack et leur configuration avec React.ComponentProps<typeof YourStack.Screen>. Et le résultat est tout simplement génial.

Voici l’exemple complet :

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

Et oui, l’intellisense est toujours là, et vous serez toujours averti si vous ajoutez à votre stack un écran sans rapport* (par exemple un écran qui ne figure pas dans la déclaration de type de votre stack)*, comme ceci :

![Écran invalide](https://cdn-images-1.medium.com/max/3176/1*LkS3Ay_QPrWIDMZZCsOpZQ.png)_Écran invalide_

L’intellisense est aussi au rendez-vous :

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

C’est aussi plus propre, plus configurable et plus dynamique :

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

En conclusion, cette approche permet de gérer facilement des structures de navigation complexes*(du moins si on la compare aux autres approches de cet article)*. Car en plus d’avoir un JSX plus propre, vous pourrez configurer vos routes de façon plus dynamique et plus modulaire.

### Aller un cran plus loin avec TypeScript

On ne se limite pas à déclarer le type générique de createStackNavigator. Et le type des éléments enfants de Stack.Navigator ? Même si [ce concept est déjà très bien expliqué dans la documentation officielle](https://reactnavigation.org/docs/typescript/#type-checking-screens), voyons ci-dessous comment jouer avec pour créer la structure de façon plus découplée.

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

Oups, il se passe beaucoup de choses ici… Découpons ce code en plusieurs parties.

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

En haut de l’extrait, nous importons les modules nécessaires. Ces imports incluent des types, des fonctions et d’autres éléments nécessaires. Ils ne sont pas passionnants, mais indispensables :)

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

Ci-dessus, nous importons le composant [View](https://reactnative.dev/docs/view) de react-native pour que l’exemple soit plus simple à montrer.

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

Voici maintenant la partie intéressante. Le type RouteConfig, importé depuis @react-navigation/core, prend exactement cinq types en [type générique](https://www.typescriptlang.org/docs/handbook/2/generics.html). Cette définition de type précise n’est pas documentée sur le site officiel de react-navigation, mais vous pouvez déjà la comprendre en allant voir la définition de type, comme mentionné plus haut.

Même si cela peut sembler redondant ou superflu dans un projet react-native typescript classique, cela apporte plusieurs avantages, présentés dans la section suivante.

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

Comme nous avons un tableau de routes de stack (les routes de l’application) strictement typé, chaque élément du tableau doit désormais respecter la définition de type du tableau. L’IntelliSense fonctionne donc directement lorsqu’on ajoute un nouvel élément au tableau.

De plus, appliquer ce type nous oblige à mettre à jour AppStackRoutesType\* _chaque fois qu’un nouvel élément doit être ajouté aux routes de l’application. Sinon, nous ne pourrions pas ajouter un nouvel élément qui n’existe pas dans AppStackRoutesType (AppStackParamList)_.\*

### Mapper les routes

Voici la dernière partie : nous créons le stack navigator avec createStackNavigator. Il suffit ensuite de mapper le tableau créé plus haut, avec son type strict.

Nous pouvons finalement faire confiance à chaque élément de notre tableau : ils seront correctement typés, on peut donc utiliser la [syntaxe de décomposition](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax) (spread) en toute sécurité.

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

### Était-ce vraiment la dernière partie ?

Eh bien… Non !

Nous pouvons encore améliorer nos typages dans l’exemple que nous venons de voir.

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

La différence que vous avez peut-être remarquée, c’est que nous avons StackRoutesType, qui prend un type générique et correspond au type que nous avons déjà vu. Mais quel est l’avantage, me direz-vous ? Mieux vaut répondre à cette question de façon visuelle.

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

Si nous ne choisissions pas d’utiliser le StackRoutesType générique*, *nous devrions dupliquer les typages pour chaque stack de l’application.

Ce serait donc un cauchemar à mesure que l’application grandit. _(l’idée ici est que le nombre de stacks de l’application et sa complexité sont directement proportionnels ; en réalité, ce n’est pas toujours vrai à 100 %, mais cela convient pour cet exemple précis)_

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

À l’inverse, voyez ci-dessus comme tout devient plus simple et plus propre avec le type générique.

## Le résultat final

Comparons à quoi ressemblerait une fonction Stack classique dans deux scénarios différents :

_Image 1 : afficher tous les écrans du stack un par un dans le 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>
  );
}
```

_Image 2 : afficher les écrans à partir du tableau de routes du stack, créé avec un typage typescript strict. 🎉_

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

### Encore une chose… Et les props du navigator ?

Il nous reste peut-être une dernière chose à considérer : les props du stack navigator. Dans le StackNavigator ci-dessous*, *on trouve tout un bloc de configuration pour un seul navigator. Pourquoi ne pas découpler ces configurations du 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>
  );
}
```

À partir de la ligne 13, vous savez déjà pourquoi nous utilisons un type générique. La seule vraie différence de typage avec les routes du stack est peut-être le type DefaultNavigatorOptions, importé depuis @react-navigation/core. Le nom du type parle de lui-même : ce sont les options du navigator.

Comme le type *RouteConfig *\* _mentionné plus haut_, *il prend lui aussi plusieurs types génériques. Notez en plus que nous [*omettons](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) explicitement _la clé children, puisque nous affichons déjà les enfants de Stack.Navigator_ _qui correspondent à Stack.Screen_.\*

À la ligne 22, nous créons un tout nouvel objet (ça peut aussi être une fonction, tant qu’elle renvoie un objet qui respecte le type des options du navigator), qui représentera les options de notre navigator.

Ainsi, à la ligne 50, cet objet peut être utilisé en toute sécurité avec la syntaxe de décomposition, tant qu’il respecte le type donné.

Un JSX bien plus propre… à mon avis…

### Le résultat final : props du navigator

Comparons à nouveau à quoi ressemblerait une fonction Stack classique dans deux scénarios différents :

_Image 1 : les configurations du stack navigator dans le 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>
  );
}
```

_Image 2 : les configurations du stack navigator découplées du JSX._

```tsx
// ...

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

---

### Conclusion

Dans cet article, nous avons vu comment tirer réellement parti de TypeScript pour structurer plus proprement nos navigators react-native.

Bonne journée sans bugs à tous.

### Publié sur

Cet article est également publié sur :

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

