Блог

Як структурувати навігацію в 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).

Перебір маршрутів

Ось і остання частина: створюємо 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, нам довелося б дублювати типи для кожного стеку в застосунку.

А це перетвориться на жах, коли застосунок розростеться. (ідея тут у тому, що кількість стеків у застосунку прямо пропорційна його складності; насправді це припущення не завжди правильне на 100%, але для цього прикладу воно підходить)

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

Ще одне… А як щодо пропсів Navigator

Залишилося розглянути ще одне: пропси 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… На мою думку…

Підсумкові картинки: пропси Navigator

Знову порівняймо, як виглядала б типова функція 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.

Гарного дня без багів усім.

Опубліковано

Ця стаття також опублікована на: