Блог

Как структурировать навигацию в React Native с TypeScript

24 сентября 2022 г. 8 мин чтения

Освойте React Navigation v6 с TypeScript. Типобезопасная навигация, передача параметров и продвинутые паттерны навигации в приложениях на React Native.

Как структурировать навигацию в React Native с TypeScript
React NativeTypeScriptНавигацияReact Navigation

Используем типизацию по максимуму: React Navigation

Навигация сегодня стала базовой функцией любого мобильного приложения. В мире React Native у нас для этого есть React Navigation.

В этой статье мы разберём, как можно реализовать типичную навигацию на React Navigation с TypeScript, и заодно сравним разные стратегии использования TypeScript.

И что ещё важнее, мы посмотрим, как выжать максимум из возможностей TypeScript, чтобы построить более масштабируемую архитектуру навигации.

Оговорка: примеры в этой статье написаны для версии @react-navigation@6.x.

Оговорка: методы и стратегии из этой статьи не обязательны к строгому соблюдению. Это просто мои предпочтения, которые показались мне полезными, и я решил поделиться ими с читателями. В React Navigation уже есть отличный, хорошо задокументированный раздел про использование TypeScript. Так что вы вполне можете построить отличную структуру react-navigation на TypeScript, просто следуя этой документации.

Создаём Stack Navigator

Давайте посмотрим, как создать stack navigator с помощью пакета React Navigation .

Вот пример, взятый из React Navigation:

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

Как видно, ничего специфичного для TypeScript здесь нет, так что давайте добавим в этот фрагмент немного TypeScript.

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

Выше мы добавили тип ParamList для createStackNavigator. Но постойте, откуда мы знаем, что createStackNavigator принимает generic-тип? Выяснить это можно несколькими способами. Хорошая практика: сначала заглянуть в документацию. В этом примере вы сразу заметите, что в документации уже есть раздел на эту тему.

С другой стороны, если бы эта конкретная типизация createStackNavigator не была описана на сайте, то один из способов понять, есть ли у функции типизация, это просто перейти к определению типа функции. Поначалу это может пугать, ведь вокруг будет летать множество типов, интерфейсов и generics, но чем больше вы привыкаете переходить к определению типа, тем меньше это перегружает.

Обновление!

Если вы хотите возиться с дополнительной сложностью TypeScript и при этом игнорировать блестящую утилиту для TS от команды React (React.ComponentProps), можете читать эту статью до конца.

Но, боюсь, этот раздел может оказаться последним!

Мы сможем получить типизацию для каждого экрана стека и его конфигурации с помощью React.ComponentProps. И результат будет просто потрясающим.

Полный пример ниже:

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

И да, intellisense по-прежнему будет работать, и вы по-прежнему получите предупреждение, если добавите в стек посторонний экран (например, экран, которого нет в объявлении типа вашего стека), вот так:

Некорректный экранНекорректный экран

Intellisense тоже будет на месте:

Кроме того, так чище, гибче в настройке и динамичнее:

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

В итоге этот подход позволяет легко управлять сложными структурами навигации (по крайней мере, если сравнивать его с другими подходами из этой статьи). Всё потому, что JSX становится чище, а маршруты можно настраивать более динамично и модульно.

Делаем шаг дальше с TypeScript

На самом деле всё не ограничивается объявлением generic-типа для createStackNavigator. Как насчёт типа дочерних элементов, которые будут у Stack.Navigator? Хотя эта концепция уже довольно хорошо описана в официальной документации, давайте посмотрим, как с ней можно поиграть, чтобы создавать структуру более независимым способом.

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

Ой, тут столько всего происходит… Давайте разобьём код на отдельные части.

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

В начале фрагмента мы импортируем нужные модули. Среди них типы, функции и прочие необходимые вещи. Ничего интересного, но без них никак :)

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

Выше мы импортируем компонент View из react-native, чтобы пример было проще продемонстрировать.

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

А вот и интересная часть. RouteConfig, импортированный из @react-navigation/core, принимает ровно пять типов в качестве generic-типа. Это определение типа не описано на официальном сайте react-navigation, но вы и сами можете в нём разобраться, просто перейдя к определению типа, как мы обсуждали выше.

Хотя в типичном проекте на react-native с TypeScript это может показаться избыточным и ненужным, у такого подхода есть несколько преимуществ, о которых пойдёт речь в следующем разделе.

IntelliSense

Поскольку у нас есть строго типизированный массив маршрутов стека (то есть маршрутов приложения), каждый элемент массива теперь обязан соответствовать определению типа массива. Это значит, что IntelliSense будет работать сразу при добавлении нового элемента в массив.

Более того, такой тип заставляет нас обновлять AppStackRoutesType каждый раз, когда в маршруты приложения добавляется новый элемент. Иначе мы не смогли бы добавить новый элемент, которого нет в AppStackRoutesType (AppStackParamList).

Перебираем маршруты через map

Последняя часть: мы создаём stack navigator с помощью createStackNavigator. Дальше остаётся просто пройтись через map по массиву, который мы создали выше, вместе с его строгим типом.

В итоге мы можем доверять каждому элементу массива: у него будет правильная типизация, поэтому можно безопасно использовать spread-синтаксис.

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

Это действительно была последняя часть?

Ну… Нет!

Мы всё ещё можем улучшить типизацию в разобранном примере.

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

Вы, возможно, заметили разницу: теперь у нас есть StackRoutesType, который принимает generic-тип и равен типу, который мы уже видели раньше. Но в чём выгода, спросите вы? На этот вопрос лучше ответить наглядно.

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

Если бы мы не использовали generic StackRoutesType, нам пришлось бы дублировать типизацию для каждого стека в приложении.

По мере роста приложения это превратилось бы в кошмар. (Здесь подразумевается, что количество стеков в приложении прямо пропорционально его сложности. На самом деле это допущение верно не всегда, но для этого конкретного примера оно подходит.)

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

А теперь посмотрите выше, насколько проще и чище всё становится с generic-типом.

Итоговая картина

Сравним, как будет выглядеть типичная функция Stack в двух разных сценариях:

Картинка 1: все экраны стека рендерятся в JSX по одному.

// ...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>
  );
}

Картинка 2: экраны рендерятся через массив маршрутов стека, созданный со строгой типизацией TypeScript. 🎉

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

И ещё одно… Как насчёт props навигатора

Осталось рассмотреть ещё одну вещь: props самого stack navigator. Если посмотреть на StackNavigator ниже, у одного навигатора есть целый блок конфигурации. Почему бы не отделить эту конфигурацию от JSX?

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

Начиная со строки 13, нам уже должно быть понятно, зачем мы используем generic-тип. Единственное отличие в типизации от маршрутов стека здесь, пожалуй, это тип DefaultNavigatorOptions, который импортируется из @react-navigation/core. Само название типа говорит за себя: это опции навигатора.

Как и тип RouteConfig, о котором мы говорили выше, он тоже принимает несколько generic-типов. Кроме того, учтите, что мы явно исключаем через Omit ключ children, поскольку уже рендерим дочерние элементы Stack.Navigator, то есть Stack.Screen.

На строке 22 мы создаём совершенно новый объект (это может быть и функция, если она возвращает объект, удовлетворяющий типу опций навигатора), который будет представлять опции нашего навигатора.

В результате на строке 50 этот объект можно безопасно использовать со spread-синтаксисом, если он удовлетворяет заданному типу.

JSX гораздо чище… По моему мнению…

Итоговая картина: props навигатора

Снова сравним, как будет выглядеть типичная функция Stack в двух разных сценариях:

Картинка 1: конфигурация stack navigator находится в JSX.

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

Картинка 2: конфигурация stack navigator отделена от JSX.

// ...

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

Заключение

В этой статье мы разобрали, как по-настоящему использовать TypeScript и получить более чистый способ структурировать навигаторы в react-native.

Всем дня без багов.

Где ещё опубликовано

Эта статья также опубликована здесь: