# Cómo estructurar la navegación en React Native con TypeScript

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

Aprovecha los tipos en React Navigation

Hoy en día, construir la navegación es una funcionalidad fundamental de cualquier aplicación móvil. En el mundo de React Native, tenemos [React Navigation](https://reactnavigation.org/) en el bolsillo.

Este artículo explica cómo se puede implementar una navegación típica con React Navigation usando TypeScript, comparando a la vez distintas estrategias de uso de TypeScript.

Y, lo que es más importante, también explica cómo sacar el máximo partido a las funciones de TypeScript para construir una arquitectura de navegación más escalable.

> Advertencia: los ejemplos de este artículo se han hecho con la versión @react-navigation@6.x.

> Advertencia: los métodos y estrategias que se tratan en este artículo no son imprescindibles ni tienes que seguirlos al pie de la letra; son solo mis preferencias, y me pareció útil compartirlas con los lectores de este artículo. [React Navigation ya tiene una sección excelente y muy bien documentada sobre el uso de TypeScript.](https://reactnavigation.org/docs/typescript) Dicho esto, ya puedes construir una estructura estupenda de react-navigation con TypeScript simplemente siguiendo [esta documentación](https://reactnavigation.org/docs/typescript/).

### Crear un stack navigator

Veamos cómo crear un [stack navigator](https://reactnavigation.org/docs/stack-navigator/) con el paquete [React Navigation ](https://reactnavigation.org/).

Mira el siguiente ejemplo, tomado 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>
  );
}
```

Como se puede ver, aquí no hay nada específico de TypeScript, así que añadamos un poco de TypeScript a este fragmento de código.

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

Arriba hemos añadido el tipo ParamList a createStackNavigator. Pero, un momento, ¿cómo sabemos que createStackNavigator acepta un tipo genérico? Hay un par de formas de averiguarlo. Siempre ha sido buena práctica revisar primero la [documentación](https://reactnavigation.org/docs/typescript/#type-checking-the-navigator). En este ejemplo, verás que ya hay una sección sobre ello en la documentación.

Por otro lado, suponiendo que este tipado concreto de createStackNavigator no estuviera documentado en la web, una forma posible de saber si la función tiene ese tipado sería simplemente saltar a la definición de tipo de la función. Puede intimidar al principio, porque verás un montón de tipos, interfaces y genéricos por todas partes, pero cuanto más te acostumbres a saltar a la definición de tipo, menos abrumador te resultará.

### **¡Actualización!**

Si quieres lidiar con complejidad extra en TypeScript y además ignorar una utilidad de TS brillante del equipo de React (React.ComponentProps), puedes seguir leyendo hasta el final del artículo.

¡Pero me temo que esta sección podría ser el final!

Podremos obtener los tipos de cada pantalla del stack y de su configuración con React.ComponentProps<typeof YourStack.Screen>. Y el resultado será sencillamente increíble.

Mira el ejemplo completo a continuación:

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

Y sí, seguirás teniendo IntelliSense, y seguirá avisándote si añades a tu stack una pantalla que no corresponde* (es decir, una pantalla que no está en la declaración de tipos de tu stack)*, así:

![Pantalla no válida](https://cdn-images-1.medium.com/max/3176/1*LkS3Ay_QPrWIDMZZCsOpZQ.png)_Pantalla no válida_

IntelliSense también estará ahí:

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

También es más limpio, configurable y dinámico:

```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 conclusión, este enfoque nos permite gestionar estructuras de navegación complejas con facilidad *(al menos si comparamos este enfoque concreto con los demás enfoques de este artículo)*. Esto se debe a que, además de tener un JSX más limpio, también podrás configurar tus rutas de una forma más dinámica y modular.

### Llevar el uso de TypeScript un paso más allá

En realidad no se limita a declarar solo el tipo genérico de createStackNavigator. ¿Qué hay del tipo de los elementos hijos que tendrá Stack.Navigator? Aunque [este concepto ya está bastante bien definido en la documentación oficial](https://reactnavigation.org/docs/typescript/#type-checking-screens), veamos cómo podemos jugar con él para crear la estructura de una forma más desacoplada.

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

Vaya, aquí pasan muchas cosas… Dividamos el código en partes separadas.

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

Al principio del fragmento importamos los módulos necesarios. Estos imports incluyen tipos, funciones y otras cosas necesarias. No son interesantes, pero sí necesarios :)

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

Arriba importamos el componente [View](https://reactnative.dev/docs/view) de react-native para que el ejemplo se pueda mostrar de forma más sencilla.

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

Ahora viene la parte interesante. RouteConfig, que se importa de @react-navigation/core, recibe exactamente cinco tipos como [tipo genérico](https://www.typescriptlang.org/docs/handbook/2/generics.html). Esta definición de tipo concreta no está documentada en la web oficial de react-navigation; aun así, puedes descubrirla simplemente usando el método de saltar a la definición de tipo que mencionamos antes.

Aunque pueda parecer redundante o innecesario en un proyecto típico de react-native con TypeScript, aporta varias ventajas que veremos en la siguiente sección.

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

Como tenemos un array de rutas del stack (es decir, las rutas de la app) estrictamente tipado, cada elemento del array está ahora obligado a respetar la definición de tipo del array. Esto significa que IntelliSense funcionará de entrada al añadir un nuevo elemento al array.

Además, aplicar este tipo nos obliga a actualizar AppStackRoutesType\* _cada vez que haya que añadir un nuevo elemento a las rutas de la app. De lo contrario, no podríamos añadir un nuevo elemento que no exista en AppStackRoutesType (AppStackParamList)_.\*

### Mapear las rutas

Llegamos a la última parte: creamos el stack navigator con createStackNavigator. Después, solo es cuestión de mapear el array que creamos arriba junto con su tipo estricto.

Al final podemos confiar en cada elemento de nuestro array, ya que tendrá elementos correctamente tipados, así que es seguro usar la [sintaxis de propagación](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>
  );
}
```

### ¿De verdad era la última parte?

Pues… ¡no!

Todavía podemos mejorar los tipos del ejemplo que hemos 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 diferencia que quizá hayas notado es que tenemos StackRoutesType, que recibe un tipo genérico y equivale al tipo que ya vimos antes. Pero ¿cuál es la ventaja?, te preguntarás. Mejor responder a esta pregunta de forma visual.

```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 no eligiéramos usar el StackRoutesType genérico, tendríamos que duplicar los tipos para cada stack que tengamos en la app.

Por tanto, esto sería una pesadilla a medida que la app crece. _(aquí la idea es que el número de stacks de la app y la complejidad de la app son directamente proporcionales; en realidad no es una suposición válida al 100% siempre, pero sirve para este ejemplo concreto)_

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

En cambio, mira arriba lo simple y limpio que queda ahora al usar el tipo genérico.

## Resultado final

Comparemos cómo se vería una función Stack típica en dos escenarios distintos:

_Imagen 1: renderizar todas las pantallas del stack una a una en 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>
  );
}
```

_Imagen 2: renderizar las pantallas usando el array de rutas del stack creado con TypeScript estrictamente tipado. 🎉_

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

### Una cosa más… ¿Qué pasa con las props del navigator?

Puede que nos quede una cosa más por considerar: las props del stack navigator. Si miras el StackNavigator de abajo, hay un bloque de configuraciones para un solo navigator. ¿Por qué no desacoplar estas configuraciones del 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>
  );
}
```

A partir de la línea 13, ya deberíamos saber por qué usamos el tipo genérico. La única diferencia de tipado con las rutas del stack podría ser el tipo DefaultNavigatorOptions, que se importa de @react-navigation/core. El propio nombre del tipo se explica solo: son las opciones del navigator.

Igual que el tipo *RouteConfig* _que mencionamos antes_, también recibe varios tipos genéricos. Además, ten en cuenta que estamos [*omitiendo*](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) explícitamente _la clave children, ya que ya estamos renderizando los hijos de Stack.Navigator, que corresponden a Stack.Screen_.

En la línea 22 creamos un objeto completamente nuevo (o puede ser una función, siempre que devuelva un objeto que cumpla el tipo de opciones del navigator) que representará las opciones de nuestro navigator.

Como resultado, en la línea 50, este objeto se puede usar de forma segura con la sintaxis de propagación, siempre que cumpla el tipo dado.

Un JSX mucho más limpio… en mi opinión…

### Resultado final: props del navigator

Comparemos de nuevo cómo se vería una función Stack típica en dos escenarios distintos:

_Imagen 1: tener las configuraciones del stack navigator en el 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>
  );
}
```

_Imagen 2: tener las configuraciones del stack navigator desacopladas del JSX._

```tsx
// ...

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

---

### Conclusión

En este artículo hemos visto cómo aprovechar de verdad TypeScript y conseguir una forma más limpia de estructurar los navigators de react-native.

Que tengáis todos un día sin bugs.

### Publicado en

Este artículo también está publicado en:

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

