Kurs JavaScript i React · Moduł 12: React i TypeScript

Typowanie Context API i useReducer

6 min czytania ·
W tej lekcji5

Motyw kolorystyczny musi dotrzeć z mostka do każdego panelu, a lista misji do każdej kabiny. Przekazywanie props przez pięć poziomów komponentów męczy, a bez typów łatwo wysłać akcję z literówką, której reducer po cichu nie obsłuży. Context API to system komunikacji między odległymi modułami statku kosmicznego - pozwala przesyłać dane bez przekazywania ich przez każdy pośredni komponent. TypeScript zapewnia, że te dane zawsze mają prawidłowy kształt.

Typowanie Context API

Typowany kontekst budujemy w czterech krokach. Najpierw interfejs opisujący, co kontekst udostępnia, potem sam kontekst z createContext. Kontekst tworzymy z wartością undefined i typem ThemeContextType | undefined - za chwilę wyjaśnię dlaczego.

import React, { createContext, useContext, useState } from 'react';

// 1. Zdefiniuj typ kontekstu
interface ThemeContextType {
  theme: "dark" | "light";
  toggleTheme: () => void;
}

// 2. Utwórz kontekst z domyślną wartością
const ThemeContext = createContext<ThemeContextType | undefined>(undefined);

Trzeci krok to własny hook, który odczytuje kontekst i sprawdza, czy komponent w ogóle znajduje się wewnątrz Providera. Czwarty to Provider, czyli komponent przechowujący stan i udostępniający go potomkom:

// 3. Custom hook do użycia kontekstu (z walidacją)
function useTheme(): ThemeContextType {
  const context = useContext(ThemeContext);
  if (context === undefined) {
    throw new Error("useTheme musi być używany wewnątrz ThemeProvider");
  }
  return context;
}

// 4. Provider komponent
function ThemeProvider({ children }: { children: React.ReactNode }) {
  const [theme, setTheme] = useState<"dark" | "light">("dark");

  const toggleTheme = () => {
    setTheme(prev => prev === "dark" ? "light" : "dark");
  };

  return (
    <ThemeContext.Provider value={{ theme, toggleTheme }}>
      {children}
    </ThemeContext.Provider>
  );
}

Po instrukcji if TypeScript zawęża context do ThemeContextType, więc hook zwraca typ bez undefined. Nowość w React 19: kontekst możesz renderować bezpośrednio jako Provider, pisząc <ThemeContext value={...}>. Zapis <ThemeContext.Provider> nadal działa i spotkasz go w większości kodu, ale zespół React zapowiada, że w przyszłości zostanie oznaczony jako przestarzały.

Dlaczego używać undefined jako domyślna wartość?

Wartość domyślna w createContext trafia tylko do komponentów, nad którymi nie ma żadnego Providera. Porównaj dwa podejścia:

// Wzorzec: createContext<T | undefined>(undefined)
// + custom hook z walidacją

// ZALETY:
// - Błąd w runtime jeśli komponent nie jest wewnątrz Providera
// - Typ w komponencie jest zawsze ThemeContextType (nie undefined)
// - Bezpieczniejsze niż podawanie "pustego" obiektu domyślnego

// ALTERNATYWA (mniej bezpieczna):
const ThemeContext = createContext<ThemeContextType>({
  theme: "dark",
  toggleTheme: () => {} // pusta funkcja - cichy błąd
});

W wersji alternatywnej komponent poza Providerem dostanie pustą funkcję - przycisk zmiany motywu po prostu nic nie zrobi i nikt nie dowie się dlaczego. Wzorzec z undefined zamienia ciche awarie w głośny komunikat. Ten właśnie wzorzec polecam.

Typowanie useReducer

useReducer jest idealny do zarządzania złożonym stanem. Reducer to czysta funkcja, która dostaje obecny stan i akcję, a zwraca nowy stan. TypeScript sprawia, że każda akcja i zmiana stanu są bezpieczne. Zaczynamy od typu stanu i typu pojedynczej misji:

// 1. Zdefiniuj typ stanu
interface MissionState {
  missions: Mission[];
  selectedMission: Mission | null;
  loading: boolean;
  error: string | null;
}

interface Mission {
  id: string;
  name: string;
  status: "planned" | "active" | "completed";
}

Akcje opisujemy jako discriminated union z poprzedniej lekcji. Dyskryminatorem jest pole type, a każdy wariant ma własny typ payload. Zapis Mission["status"] pobiera typ pola status z interfejsu, więc nie powtarzamy listy statusów:

// 2. Zdefiniuj typy akcji - discriminated union!
type MissionAction =
  | { type: "SET_MISSIONS"; payload: Mission[] }
  | { type: "SELECT_MISSION"; payload: string }
  | { type: "ADD_MISSION"; payload: Mission }
  | { type: "UPDATE_STATUS"; payload: { id: string; status: Mission["status"] } }
  | { type: "SET_LOADING"; payload: boolean }
  | { type: "SET_ERROR"; payload: string | null };

Teraz reducer. W każdym case TypeScript zna dokładny typ action.payload: w "ADD_MISSION" to Mission, w "SET_LOADING" - boolean.

// 3. Reducer z pełnym typowaniem
function missionReducer(state: MissionState, action: MissionAction): MissionState {
  switch (action.type) {
    case "SET_MISSIONS":
      return { ...state, missions: action.payload, loading: false };
    case "SELECT_MISSION":
      return {
        ...state,
        selectedMission: state.missions.find(m => m.id === action.payload) || null
      };
    case "ADD_MISSION":
      return { ...state, missions: [...state.missions, action.payload] };
    case "UPDATE_STATUS":
      return {
        ...state,
        missions: state.missions.map(m =>
          m.id === action.payload.id
            ? { ...m, status: action.payload.status }
            : m
        )
      };
    case "SET_LOADING":
      return { ...state, loading: action.payload };
    case "SET_ERROR":
      return { ...state, error: action.payload, loading: false };
    default:
      return state;
  }
}

Reducer nigdy nie modyfikuje starego stanu - zawsze zwraca nowy obiekt przez ...state. Akcja { type: "ADD_MISION" } z literówką nie skompiluje się, bo nie pasuje do żadnego wariantu.

Łączenie Context + useReducer

Teraz podłączamy reducer do kontekstu, żeby każdy komponent floty mógł czytać stan i wysyłać akcje. Typ React.Dispatch<MissionAction> opisuje funkcję dispatch, która przyjmuje wyłącznie poprawne akcje:

// Stan początkowy
const initialState: MissionState = {
  missions: [],
  selectedMission: null,
  loading: false,
  error: null
};

// Typ kontekstu
interface MissionContextType {
  state: MissionState;
  dispatch: React.Dispatch<MissionAction>;
}

const MissionContext = createContext<MissionContextType | undefined>(undefined);

Hook i Provider powtarzają wzorzec z motywem. Zwróć uwagę, że useReducer nie dostaje żadnych generyków - typy wywnioskuje z missionReducer i initialState. W React 19 zmieniła się sygnatura typów tego hooka i stary zapis useReducer<State, Action>(...) zgłasza błąd, więc polegaj na wnioskowaniu.

// Custom hook
function useMissions(): MissionContextType {
  const context = useContext(MissionContext);
  if (!context) {
    throw new Error("useMissions musi być używany wewnątrz MissionProvider");
  }
  return context;
}

// Provider
function MissionProvider({ children }: { children: React.ReactNode }) {
  const [state, dispatch] = useReducer(missionReducer, initialState);

  return (
    <MissionContext.Provider value={{ state, dispatch }}>
      {children}
    </MissionContext.Provider>
  );
}

Użycie w komponentach

Komponent listy misji pobiera stan i dispatch jednym wywołaniem hooka. Edytor podpowie dozwolone wartości type, a po wybraniu "SELECT_MISSION" wymusi payload typu string:

function MissionList() {
  const { state, dispatch } = useMissions();

  if (state.loading) return <p>Ładowanie misji...</p>;
  if (state.error) return <p>Błąd: {state.error}</p>;

  return (
    <div>
      {state.missions.map(mission => (
        <div key={mission.id} onClick={() =>
          dispatch({ type: "SELECT_MISSION", payload: mission.id })
        }>
          <h3>{mission.name}</h3>
          <span>{mission.status}</span>
        </div>
      ))}
    </div>
  );
}

MissionList nie wie nic o tym, gdzie leży stan - zna tylko hook. W projekcie końcowym ten sam układ obsłuży motyw całego dashboardu.

Kod do tej lekcji: App.tsx
import React, { createContext, useContext, useReducer, useState } from 'react';

// ===== TYPY =====
interface CrewMember {
  id: string;
  name: string;
  role: string;
  status: "active" | "resting" | "mission";
}

// Stan aplikacji
interface AppState {
  crew: CrewMember[];
  theme: "dark" | "light";
  notifications: string[];
}

// Discriminated union akcji
type AppAction =
  | { type: "ADD_CREW"; payload: CrewMember }
  | { type: "REMOVE_CREW"; payload: string }
  | { type: "UPDATE_STATUS"; payload: { id: string; status: CrewMember["status"] } }
  | { type: "TOGGLE_THEME" }
  | { type: "ADD_NOTIFICATION"; payload: string }
  | { type: "CLEAR_NOTIFICATIONS" };

// ===== REDUCER =====
function appReducer(state: AppState, action: AppAction): AppState {
  switch (action.type) {
    case "ADD_CREW":
      return {
        ...state,
        crew: [...state.crew, action.payload],
        notifications: [...state.notifications, "Dodano: " + action.payload.name]
      };
    case "REMOVE_CREW":
      return {
        ...state,
        crew: state.crew.filter(c => c.id !== action.payload),
        notifications: [...state.notifications, "Usunieto czlonka zalogi"]
      };
    case "UPDATE_STATUS":
      return {
        ...state,
        crew: state.crew.map(c =>
          c.id === action.payload.id ? { ...c, status: action.payload.status } : c
        )
      };
    case "TOGGLE_THEME":
      return { ...state, theme: state.theme === "dark" ? "light" : "dark" };
    case "ADD_NOTIFICATION":
      return { ...state, notifications: [...state.notifications, action.payload] };
    case "CLEAR_NOTIFICATIONS":
      return { ...state, notifications: [] };
    default:
      return state;
  }
}

// ===== CONTEXT =====
interface AppContextType {
  state: AppState;
  dispatch: React.Dispatch<AppAction>;
}

const AppContext = createContext<AppContextType | undefined>(undefined);

function useApp(): AppContextType {
  const context = useContext(AppContext);
  if (!context) throw new Error("useApp wymaga AppProvider");
  return context;
}

// ===== PROVIDER =====
const initialState: AppState = {
  crew: [
    { id: "1", name: "Nova", role: "Kapitan", status: "active" },
    { id: "2", name: "Ra", role: "Nawigator", status: "active" },
    { id: "3", name: "Astro", role: "Inzynier", status: "resting" },
  ],
  theme: "dark",
  notifications: []
};

function AppProvider({ children }: { children: React.ReactNode }) {
  const [state, dispatch] = useReducer(appReducer, initialState);
  return (
    <AppContext.Provider value={{ state, dispatch }}>
      <div className={"app " + state.theme}>{children}</div>
    </AppContext.Provider>
  );
}

// ===== KOMPONENTY =====
function Header() {
  const { state, dispatch } = useApp();
  return (
    <header className="header">
      <h1>Centrum Dowodzenia</h1>
      <button onClick={() => dispatch({ type: "TOGGLE_THEME" })}>
        {state.theme === "dark" ? "Jasny" : "Ciemny"} motyw
      </button>
    </header>
  );
}

function CrewList() {
  const { state, dispatch } = useApp();
  const statusColors = { active: "#22c55e", resting: "#f59e0b", mission: "#818cf8" };
  const statuses: CrewMember["status"][] = ["active", "resting", "mission"];

  return (
    <div className="section">
      <h2>Zaloga ({state.crew.length})</h2>
      {state.crew.map(member => (
        <div key={member.id} className="crew-card">
          <div>
            <strong>{member.name}</strong> - {member.role}
          </div>
          <div className="crew-actions">
            <select
              value={member.status}
              onChange={(e: React.ChangeEvent<HTMLSelectElement>) =>
                dispatch({
                  type: "UPDATE_STATUS",
                  payload: { id: member.id, status: e.target.value as CrewMember["status"] }
                })
              }
            >
              {statuses.map(s => <option key={s} value={s}>{s}</option>)}
            </select>
            <span style={{ color: statusColors[member.status] }}>{member.status}</span>
            <button className="small-btn danger"
              onClick={() => dispatch({ type: "REMOVE_CREW", payload: member.id })}>
              X
            </button>
          </div>
        </div>
      ))}
    </div>
  );
}

function AddCrewForm() {
  const { dispatch } = useApp();
  const [name, setName] = useState("");
  const [role, setRole] = useState("");

  const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    if (!name || !role) return;
    dispatch({
      type: "ADD_CREW",
      payload: { id: Date.now().toString(), name, role, status: "active" }
    });
    setName("");
    setRole("");
  };

  return (
    <form onSubmit={handleSubmit} className="add-form">
      <input value={name} onChange={e => setName(e.target.value)} placeholder="Imie" />
      <input value={role} onChange={e => setRole(e.target.value)} placeholder="Rola" />
      <button type="submit">Dodaj</button>
    </form>
  );
}

function Notifications() {
  const { state, dispatch } = useApp();
  if (state.notifications.length === 0) return null;
  return (
    <div className="section notifications">
      <h2>Powiadomienia ({state.notifications.length})</h2>
      {state.notifications.map((n, i) => <p key={i} className="notif">{n}</p>)}
      <button onClick={() => dispatch({ type: "CLEAR_NOTIFICATIONS" })}>Wyczysc</button>
    </div>
  );
}

function App() {
  return (
    <AppProvider>
      <Header />
      <AddCrewForm />
      <CrewList />
      <Notifications />
    </AppProvider>
  );
}

export default App;

Pamiętaj: kontekst to sieć łączności floty, a typ akcji to jej szyfr - wiadomość z błędnym szyfrem nie opuści mostka.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Dlaczego zaleca się używanie createContext<Type | undefined>(undefined) zamiast podawania domyślnego obiektu?

  2. 2. Dlaczego typy akcji w useReducer najlepiej definiować jako discriminated union?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kolejność kroków tworzenia typowanego Context z useReducer:

  • Edytor kodu

    Pełne typowanie Context API z useReducer

  • Klikanie w kolejności

    Ułóż kod custom hooka z walidacją kontekstu:

  • Układanie w poziomie

    Ułóż poprawny typ dla dispatch w interfejsie kontekstu:

  • Układanie w pionie

    Ułóż koncepty TypeScript w React od najprostszego do najbardziej złożonego:

  • Układanie w poziomie

    Ułóż składnię tworzenia typowanego kontekstu React:

  • Klikanie w kolejności

    Ułóż sygnaturę typowanej funkcji reducer:

  • Układanie w pionie

    Ułóż kolejność przepływu danych w architekturze Context + useReducer:

  • Układanie w poziomie

    Ułóż poprawne wywołanie dispatch z typowaną akcją:

  • Klikanie w kolejności

    Ułóż elementy typowanego Provider komponentu:

  • Układanie w pionie

    Ułóż zalety TypeScript w React od najbardziej podstawowej do najbardziej zaawansowanej:

  • Edytor kodu

    Kompleksowe ćwiczenie łączące wszystkie koncepty TypeScript w React

  1. PytanieDomyślna wartość createContext
  2. PytanieAkcje useReducer jako discriminated union
  3. Ułóż w kolejnościBudowanie Context + useReducer
  4. Zadanie z kodemPraktyka: Context + useReducer
  5. Kliknij w kolejnościCustom hook z walidacją kontekstu
  6. Ułóż w kolejnościTyp dispatch w useReducer
  7. Ułóż w kolejnościOd prostego do złożonego typowania
  8. Ułóż w kolejnościSkładnia createContext z typem
  9. Kliknij w kolejnościDefinicja typowanego reducera
  10. Ułóż w kolejnościPrzepływ danych w Context + useReducer
  11. Ułóż w kolejnościWywołanie dispatch z akcją
  12. Kliknij w kolejnościTypowany Provider komponent
  13. Ułóż w kolejnościZalety TypeScript w React
  14. PytanieExhaustive checking z never
  15. Zadanie z kodemPraktyka: Połączenie wszystkich konceptów

Przydatne artykuły