# Come strutturare la navigazione in React Native con TypeScript

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

Sfruttare le tipizzazioni di React Navigation

Oggi la navigazione è una funzione fondamentale di qualsiasi applicazione mobile. Nel mondo React Native abbiamo [React Navigation](https://reactnavigation.org/) a portata di mano.

Questo articolo mostra come implementare una tipica navigazione con React Navigation usando TypeScript, confrontando nel frattempo diverse strategie di utilizzo di TypeScript.

E, cosa più importante, spiega anche come sfruttare al massimo le funzioni di TypeScript per costruire un'architettura di navigazione più scalabile.

> Attenzione: gli esempi di questo articolo sono basati sulla versione @react-navigation@6.x.

> Attenzione: i metodi e le strategie di questo articolo non sono obbligatori e non vanno seguiti alla lettera. Sono solo le mie preferenze, che ho trovato utile condividere con chi legge. [React Navigation ha già una sezione splendidamente documentata sull'uso di typescript.](https://reactnavigation.org/docs/typescript) Detto questo, puoi già costruire un'ottima struttura typescript per react-navigation semplicemente seguendo [questa documentazione](https://reactnavigation.org/docs/typescript/).

### Creare uno stack navigator

Vediamo come creare uno [stack navigator](https://reactnavigation.org/docs/stack-navigator/) con il pacchetto [React Navigation ](https://reactnavigation.org/).

Guarda l'esempio qui sotto, preso da [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>
  );
}
```

Come si vede, qui non c'è niente di specifico di TypeScript. Aggiungiamo un po' di TypeScript a questo snippet.

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

Qui sopra abbiamo aggiunto il tipo ParamList a createStackNavigator. Ma come facciamo a sapere che createStackNavigator accetta un tipo generico? Ci sono un paio di modi per scoprirlo. È sempre buona pratica controllare prima la [documentazione](https://reactnavigation.org/docs/typescript/#type-checking-the-navigator). In questo esempio noterai che nella documentazione c'è già una sezione apposita.

D'altra parte, supponendo che questa tipizzazione specifica di createStackNavigator non sia documentata sul sito, un modo per capire se la funzione ha la tipizzazione è semplicemente saltare alla definizione del tipo della funzione. All'inizio può intimidire, perché ci saranno tanti tipi, interfacce e generics che volano in giro, ma più prendi l'abitudine di saltare alla definizione del tipo, meno ti sembrerà opprimente.

### **Aggiornamento!**

Se vuoi gestire una complessità extra con typescript e ignorare anche la brillante utility TS del team di React (React.ComponentProps), puoi continuare a leggere fino alla fine dell'articolo.

Ma temo che questa sezione possa essere la fine!

Possiamo ottenere le tipizzazioni di ogni schermata dello stack e della sua configurazione con React.ComponentProps<typeof YourStack.Screen>. E il risultato è semplicemente fantastico.

Ecco l'esempio completo:

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

E sì, avrai ancora l'intellisense, e ti avviserà ancora se aggiungi al tuo stack una schermata non pertinente* (cioè una schermata che non è nella dichiarazione di tipo del tuo stack)*, così:

![Schermata non valida](https://cdn-images-1.medium.com/max/3176/1*LkS3Ay_QPrWIDMZZCsOpZQ.png)_Schermata non valida_

Anche l'intellisense ci sarà:

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

È anche più pulito, configurabile e dinamico:

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

In conclusione, questo approccio ci permette di gestire facilmente strutture di navigazione complesse*(almeno se lo confrontiamo con gli altri approcci di questo articolo)*. Questo perché, oltre ad avere un JSX più pulito, potrai configurare le tue route in modo più dinamico e modulare.

### Portare l'uso di TypeScript un passo avanti

Non ci si limita a dichiarare solo il tipo generico di createStackNavigator. E il tipo degli elementi figli che Stack.Navigator avrà? Anche se q[uesto concetto è già definito piuttosto bene nella documentazione ufficiale](https://reactnavigation.org/docs/typescript/#type-checking-screens), vediamo qui sotto come possiamo giocarci per creare la struttura in modo più disaccoppiato.

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

Ops, qui succedono un sacco di cose… Dividiamo il codice in parti separate.

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

In cima allo snippet importiamo i moduli necessari. Questi import includono tipi, funzioni e altre cose necessarie. Non sono interessanti, ma servono :)

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

Qui sopra importiamo il componente [View](https://reactnative.dev/docs/view) da react-native, così l'esempio si può mostrare in modo più semplice.

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

Ecco la parte interessante. RouteConfig, importato da @react-navigation/core, accetta esattamente cinque tipi come [tipo generico](https://www.typescriptlang.org/docs/handbook/2/generics.html). Questa definizione di tipo non è documentata sul sito ufficiale di react-navigation, ma puoi comunque ricavarla semplicemente saltando alla definizione del tipo, come abbiamo detto prima.

Anche se in un tipico progetto react-native con typescript può sembrare ridondante o non necessario, porta diversi vantaggi che vediamo nella sezione qui sotto.

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

Dato che abbiamo un array di route dello stack (cioè le route dell'app) tipizzato in modo rigoroso, ogni elemento dell'array è ora obbligato a rispettare la definizione di tipo dell'array. Questo significa che IntelliSense funziona subito quando aggiungiamo un nuovo elemento all'array.

Inoltre, applicare questo tipo ci obbliga ad aggiornare AppStackRoutesType\* _ogni volta che ci sarà un nuovo elemento da aggiungere alle route dell'app. Altrimenti non potremmo aggiungere un nuovo elemento che non esiste in AppStackRoutesType(AppStackParamList)_.\*

### Mappare le route

Ecco l'ultima parte: creiamo lo stack navigator con createStackNavigator. Poi si tratta solo di mappare l'array creato prima, insieme al suo tipo rigoroso.

A questo punto possiamo fidarci di ogni elemento del nostro array: avrà elementi tipizzati correttamente, quindi è sicuro usare la [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>
  );
}
```

### Era davvero l'ultima parte?

Beh… No!

Possiamo migliorare ancora le tipizzazioni dell'esempio che abbiamo visto.

```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 differenza che avrai notato è che abbiamo StackRoutesType, che accetta un tipo generico ed equivale al tipo che abbiamo già visto prima. Ma qual è il vantaggio, potresti chiedere. Meglio rispondere in modo visivo.

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

Se non scegliessimo di usare lo StackRoutesType generico*, *dovremmo duplicare le tipizzazioni per ogni stack dell'app.

Sarebbe un incubo man mano che l'app cresce. _(qui l'idea è che il numero di stack nell'app e la complessità dell'app siano direttamente proporzionali; in realtà non è un'ipotesi valida al 100%, ma va bene per questo esempio specifico)_

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

Invece, qui sopra, guarda come tutto diventa più semplice e pulito usando il tipo generico.

## Le immagini finali

Confrontiamo come apparirebbe una tipica funzione Stack in due scenari diversi:

_Immagine 1: tutte le schermate dello stack renderizzate una per una nel 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>
  );
}
```

_Immagine 2: schermate renderizzate con l'array di route dello stack, creato con typescript a tipizzazione rigorosa. 🎉_

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

### Un'ultima cosa… E le props del navigator?

Ci resta forse un'ultima cosa da considerare: le props dello stack navigator. Guardando lo StackNavigator qui sotto*, *c'è un bel blocco di configurazioni per un singolo navigator. Perché non separare queste configurazioni dal 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>
  );
}
```

Dalla riga 13 in poi dovremmo già sapere perché usiamo il tipo generico. L'unica differenza di tipizzazione rispetto alle route dello stack potrebbe essere il tipo DefaultNavigatorOptions, importato da @react-navigation/core. Il nome del tipo si spiega da solo: sono le opzioni del navigator.

Come il tipo *RouteConfig *\* _di cui abbiamo parlato sopra_, *anche questo accetta più tipi generici. Inoltre, tieni presente che stiamo esplicitamente [*omettendo](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) _la chiave children, perché stiamo già renderizzando i figli di Stack.Navigator_ _che corrispondono a Stack.Screen_.\*

Alla riga 22 creiamo un oggetto nuovo (o può essere una funzione, purché restituisca un oggetto che soddisfa il tipo delle opzioni del navigator) che rappresenterà le opzioni del nostro navigator.

Di conseguenza, alla riga 50, questo oggetto si può usare tranquillamente con la spread syntax, purché soddisfi il tipo indicato.

JSX molto più pulito… secondo me…

### Le immagini finali: props del navigator

Confrontiamo di nuovo come apparirebbe una tipica funzione Stack in due scenari diversi:

_Immagine 1: configurazioni dello stack navigator nel 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>
  );
}
```

_Immagine 2: configurazioni dello stack navigator separate dal JSX._

```tsx
// ...

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

---

### Conclusione

In questo articolo abbiamo visto come sfruttare davvero TypeScript e ottenere un modo più pulito di strutturare i navigator in react-native.

Buona giornata senza bug a tutti.

### Pubblicato su

Questo articolo è pubblicato anche su:

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

