# Navigatie structureren in React Native met TypeScript

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

Haal meer uit de typings van React Navigation

Navigatie bouwen is tegenwoordig een basisfunctie van elke mobiele applicatie. In de wereld van React Native hebben we daarvoor [React Navigation](https://reactnavigation.org/) op zak.

In dit artikel bekijken we hoe je een typische React Navigation-opzet met TypeScript implementeert, en vergelijken we tegelijk verschillende manieren om TypeScript te gebruiken.

En nog belangrijker: we bekijken ook hoe we het meeste uit de features van TypeScript halen, zodat we een beter schaalbare architectuur voor navigatie kunnen bouwen.

> Let op: de voorbeelden in dit artikel zijn gemaakt met versie @react-navigation@6.x.

> Let op: de methodes en strategieën in dit artikel zijn geen onmisbare regels die je strikt moet volgen. Het zijn gewoon mijn voorkeuren, en ik vond ze nuttig genoeg om met de lezers van dit artikel te delen. [React Navigation heeft al een uitstekend gedocumenteerd onderdeel over het gebruik van TypeScript.](https://reactnavigation.org/docs/typescript) Je kunt dus al een prima TypeScript-structuur voor react-navigation bouwen door gewoon [deze documentatie](https://reactnavigation.org/docs/typescript/) te volgen.

### Een stack navigator maken

Laten we kijken hoe je een [stack navigator](https://reactnavigation.org/docs/stack-navigator/) maakt met het pakket [React Navigation ](https://reactnavigation.org/).

Bekijk het voorbeeld hieronder, afkomstig uit [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>
  );
}
```

Zoals je ziet, is hier niets specifieks aan TypeScript. Laten we wat TypeScript aan dit codefragment toevoegen.

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

Hierboven hebben we het type ParamList toegevoegd aan createStackNavigator. Maar hoe weten we eigenlijk dat createStackNavigator een generiek type accepteert? Dat kun je op een paar manieren uitzoeken. Het is altijd een goede gewoonte om eerst de [documentatie](https://reactnavigation.org/docs/typescript/#type-checking-the-navigator) te bekijken. In dit voorbeeld zie je meteen dat de docs er al een apart onderdeel voor hebben.

Stel nu dat deze specifieke typing van createStackNavigator niet op de website gedocumenteerd is. Dan kun je uitzoeken of de functie die typing heeft door gewoon naar de typedefinitie van de functie te springen. Dat kan in het begin intimiderend zijn, omdat er overal types, interfaces en generics rondvliegen, maar hoe meer je eraan gewend raakt om naar de typedefinitie te springen, hoe minder overweldigend het wordt.

### **Update!**

Als je extra complexiteit met TypeScript voor lief neemt en ook de briljante TS-utility van het React-team (React.ComponentProps) wilt negeren, kun je dit artikel tot het einde blijven lezen.

Maar ik vrees dat dit onderdeel weleens het einde kan zijn!

We kunnen de typings voor elk stack screen en de bijbehorende configuratie ophalen met React.ComponentProps<typeof YourStack.Screen>. En het resultaat is gewoon geweldig.

Hieronder staat een volledig voorbeeld:

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

En ja, je houdt nog steeds intellisense, en je krijgt nog steeds een waarschuwing als je een screen aan je stack toevoegt dat er niets mee te maken heeft *(bijvoorbeeld een screen dat niet in de typedeclaratie van je stack staat)*, zoals hier:

![Ongeldig screen](https://cdn-images-1.medium.com/max/3176/1*LkS3Ay_QPrWIDMZZCsOpZQ.png)_Ongeldig screen_

Ook intellisense is er gewoon:

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

Het is bovendien netter, beter configureerbaar en dynamischer:

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

Kortom, met deze aanpak beheren we complexe navigatiestructuren eenvoudig *(in elk geval als we deze aanpak vergelijken met de andere aanpakken in dit artikel)*. Dat komt doordat je niet alleen nettere JSX krijgt, maar je routes ook dynamischer en modulairder kunt configureren.

### TypeScript een stap verder inzetten

Het blijft niet beperkt tot alleen het generieke type van createStackNavigator declareren. Hoe zit het met het type van de children die Stack.Navigator krijgt? Hoewel [dit concept al heel goed beschreven is in de officiële documentatie](https://reactnavigation.org/docs/typescript/#type-checking-screens), bekijken we hieronder hoe we ermee kunnen spelen om de structuur op een meer ontkoppelde manier op te bouwen.

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

Oei, er gebeurt hier heel veel… Laten we de code opdelen in losse stukken.

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

Bovenaan het codefragment importeren we de benodigde modules. Die imports bevatten types, functies en andere nodige dingen. Niet interessant, maar wel nodig :)

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

Hierboven importeren we de component [View](https://reactnative.dev/docs/view) uit react-native, zodat het voorbeeld eenvoudiger te demonstreren is.

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

Nu komt het interessante deel. RouteConfig, dat we importeren uit @react-navigation/core, neemt precies vijf types als [generiek type](https://www.typescriptlang.org/docs/handbook/2/generics.html). Deze specifieke typedefinitie staat niet in de officiële documentatie van react-navigation, maar je kunt hem toch achterhalen door naar de typedefinitie te springen, zoals we hierboven al noemden.

Ook al lijkt het in een typisch React Native-project met TypeScript misschien overbodig of onnodig, het heeft een aantal voordelen, die ik in het onderdeel hieronder bespreek.

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

Omdat we een strikt getypeerde array van stack routes hebben (oftewel app routes), moet elk element van de array zich nu aan de typedefinitie van de array houden. Dat betekent dat IntelliSense direct werkt als je een nieuw element aan de array toevoegt.

Bovendien dwingt dit type ons om AppStackRoutesType bij te werken *telkens wanneer er een nieuw element aan de app routes wordt toegevoegd. Anders kunnen we geen nieuw element toevoegen dat niet bestaat in AppStackRoutesType(AppStackParamList)*.

### De routes mappen

Dan het laatste deel: we maken de stack navigator met createStackNavigator. Daarna is het gewoon een kwestie van de array die we hierboven hebben gemaakt mappen, samen met het strikte type ervan.

We kunnen uiteindelijk elk element van onze array vertrouwen: de elementen zijn correct getypeerd, dus het is veilig om [spread syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax) te gebruiken.

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

### Was dat echt het laatste deel?

Nou… Nee!

We kunnen de typings in het voorbeeld dat we hebben behandeld nog verder verbeteren.

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

Het verschil dat je misschien al hebt opgemerkt, is dat we nu StackRoutesType hebben, dat een generiek type neemt en gelijk is aan het type dat we eerder al zagen. Maar wat is hier het voordeel, vraag je je misschien af. Die vraag beantwoord ik het liefst visueel.

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

Als we er niet voor zouden kiezen om het generieke StackRoutesType te gebruiken, zouden we de typings moeten dupliceren voor elke stack in de app.

Dat zou een nachtmerrie worden naarmate de app groter wordt. _(het idee hier is dat het aantal stacks in de app recht evenredig is met de complexiteit van de app; dat is in feite niet altijd 100% waar, maar voor dit specifieke voorbeeld klopt het wel)_

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

Hierboven zie je daarentegen hoe het nu eenvoudiger en netter wordt met een generiek type.

## Het eindresultaat

Laten we vergelijken hoe een typische Stack-functie eruitziet in twee verschillende scenario's:

_Afbeelding 1: alle stack screens worden een voor een in JSX gerenderd._

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

_Afbeelding 2: de screens worden gerenderd met de array van stack routes, gemaakt met strikt getypeerde TypeScript. 🎉_

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

### Nog één ding… En de props van de navigator?

Er blijft misschien nog één ding over om naar te kijken: de props van de stack navigator. In de StackNavigator hieronder zie je een flinke hoeveelheid configuratie voor één enkele navigator. Waarom zouden we die configuratie niet loskoppelen van 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>
  );
}
```

Vanaf regel 13 zou het al duidelijk moeten zijn waarom we een generiek type gebruiken. Het enige echte verschil in typing ten opzichte van de stack routes is hier misschien het type DefaultNavigatorOptions, dat we importeren uit @react-navigation/core. De naam van het type zegt eigenlijk al genoeg: het zijn de opties voor de navigator.

Net als het type *RouteConfig* dat we hierboven noemden, neemt het ook meerdere generieke types. Houd er daarnaast rekening mee dat we de sleutel children expliciet [weglaten](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys), omdat we de children van Stack.Navigator al renderen, en die komen overeen met Stack.Screen.

Op regel 22 maken we een gloednieuw object (het mag ook een functie zijn, zolang die een object teruggeeft dat voldoet aan het type van de navigatoropties) dat de opties van onze navigator voorstelt.

Daardoor kan dit object op regel 50 veilig met spread syntax worden gebruikt, zolang het aan het opgegeven type voldoet.

Veel nettere JSX… Vind ik…

### Het eindresultaat: props van de navigator

Laten we opnieuw vergelijken hoe een typische Stack-functie eruitziet in twee verschillende scenario's:

_Afbeelding 1: de configuratie van de stack navigator staat in 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>
  );
}
```

_Afbeelding 2: de configuratie van de stack navigator is losgekoppeld van JSX._

```tsx
// ...

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

---

### Conclusie

In dit artikel hebben we bekeken hoe we TypeScript echt kunnen benutten om onze navigators in React Native op een nettere manier te structureren.

Ik wens iedereen een bugvrije dag.

### Gepubliceerd op

Dit artikel is ook gepubliceerd op:

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

