Kurs JavaScript i React · Moduł 12: React i TypeScript
Typowanie Context API i useReducer
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. Dlaczego zaleca się używanie createContext<Type | undefined>(undefined) zamiast podawania domyślnego obiektu?
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
Zadania po tej lekcji
- PytanieDomyślna wartość createContext
- PytanieAkcje useReducer jako discriminated union
- Ułóż w kolejnościBudowanie Context + useReducer
- Zadanie z kodemPraktyka: Context + useReducer
- Kliknij w kolejnościCustom hook z walidacją kontekstu
- Ułóż w kolejnościTyp dispatch w useReducer
- Ułóż w kolejnościOd prostego do złożonego typowania
- Ułóż w kolejnościSkładnia createContext z typem
- Kliknij w kolejnościDefinicja typowanego reducera
- Ułóż w kolejnościPrzepływ danych w Context + useReducer
- Ułóż w kolejnościWywołanie dispatch z akcją
- Kliknij w kolejnościTypowany Provider komponent
- Ułóż w kolejnościZalety TypeScript w React
- PytanieExhaustive checking z never
- Zadanie z kodemPraktyka: Połączenie wszystkich konceptów