Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React
Projekt główny: Kosmiczne Centrum Dowodzenia Misją
W tej lekcji6
Gratulacje, astronauto! Dotarłeś do finałowej misji w module React Mastery. Czas połączyć wszystkie poznane technologie w jeden, potężny system - Kosmiczne Centrum Dowodzenia Misją. Ten projekt to twój ostateczny test, który sprawdzi, czy opanowałeś zaawansowane wzorce React.
Cel projektu
Zbudujesz dashboard do zarządzania kosmiczną misją, który łączy kluczowe koncepty z całego modułu:
1. React Portals - Modalne okna alertów
Użyj React Portals do renderowania modalnych okien alertów misji poza głównym drzewem DOM. Alerty powinny pojawiać się nad interfejsem z efektem overlay.
2. Internacjonalizacja (i18n)
Dodaj przełącznik języka (PL/EN) do nagłówka. Cały dashboard powinien zmieniać język interfejsu dynamicznie za pomocą Context API i obiektów z tłumaczeniami.
3. State Management z useReducer
Zarządzaj stanem misji (status, paliwo, załoga, systemy) za pomocą useReducer. Zdefiniuj akcje takie jak LAUNCH_MISSION, UPDATE_FUEL, TOGGLE_SYSTEM, ADD_CREW_MEMBER.
4. Compound Components
Stwórz komponent <Dashboard.Panel> we wzorcu Compound Components, który pozwala elastycznie komponować sekcje dashboardu:
<Dashboard>
<Dashboard.Header title="Mission Control" />
<Dashboard.Panel title="Systems">
<SystemsList />
</Dashboard.Panel>
<Dashboard.Panel title="Crew">
<CrewList />
</Dashboard.Panel>
</Dashboard>5. Error Boundaries
Opakuj sekcje dashboardu w Error Boundaries, aby awaria jednego panelu nie powodowała crashu całej aplikacji. Wyświetl przyjazny komunikat błędu z opcją ponownego załadowania sekcji.
6. Performance Optimization
Zastosuj React.memo na komponentach listy, useMemo na obliczeniach statystyk misji i useCallback na handlerach zdarzeń przekazywanych do komponentów potomnych.
Struktura aplikacji
Zanim napiszesz pierwszą linię kodu, rozpisz drzewo komponentów. Dostawcy kontekstu leżą na samej górze, żeby każdy panel mógł czytać język i stan misji, a każdy panel ma własny Error Boundary, więc awaria jednego nie wyłączy pozostałych. Okno alarmu renderuje się przez portal, poza drzewem dashboardu:
App
├── LanguageProvider (Context - i18n)
├── MissionProvider (useReducer - state)
├── Dashboard (Compound Component)
│ ├── Dashboard.Header
│ ├── Dashboard.Panel "Status Misji"
│ │ └── ErrorBoundary
│ │ └── MissionStatus (React.memo)
│ ├── Dashboard.Panel "Systemy"
│ │ └── ErrorBoundary
│ │ └── SystemsList (React.memo)
│ └── Dashboard.Panel "Załoga"
│ └── ErrorBoundary
│ └── CrewList (React.memo)
└── Portal → AlertModal (React Portal)Wymagania
- Dashboard wyświetla 3 panele: Status Misji, Systemy, Załoga
- Przełącznik języka (PL/EN) zmienia wszystkie etykiety interfejsu
- Przycisk startu misji zmienia status i zużywa paliwo (useReducer)
- Systemy można włączać/wyłączać (toggle)
- Alert modal (Portal) pojawia się gdy paliwo spadnie poniżej 20%
- Error Boundary wyświetla fallback gdy komponent rzuci błąd
- Memoizacja zapobiega zbędnym re-renderom
Wskazówki implementacyjne
Reducer dla stanu misji
Cały stan misji trzyma jeden reducer, czyli czysta funkcja, która z poprzedniego stanu i akcji wylicza nowy stan. Nie zmienia obiektu state, tylko zwraca kopię z poprawionymi polami, dzięki czemu React wie, że coś się zmieniło, a React.memo może pominąć panele, których dane się nie zmieniły:
const initialState = {
status: 'ready',
fuel: 100,
systems: [
{ id: 1, name: 'Nawigacja', active: true },
{ id: 2, name: 'Podtrzymywanie życia', active: true },
{ id: 3, name: 'Komunikacja', active: false },
],
crew: ['Kowalski', 'Nowak', 'Wiśniewska'],
};
function missionReducer(state, action) {
switch (action.type) {
case 'LAUNCH_MISSION':
return { ...state, status: 'inProgress', fuel: Math.max(0, state.fuel - 20) };
case 'UPDATE_FUEL':
return { ...state, fuel: Math.max(0, state.fuel + action.payload) };
case 'TOGGLE_SYSTEM':
return {
...state,
systems: state.systems.map(s =>
s.id === action.payload ? { ...s, active: !s.active } : s
),
};
case 'ADD_CREW_MEMBER':
return { ...state, crew: [...state.crew, action.payload] };
default:
return state;
}
}Komponenty nie zmieniają stanu same, tylko wysyłają akcje, na przykład dispatch({ type: 'TOGGLE_SYSTEM', payload: 2 }). Math.max pilnuje, żeby paliwo nigdy nie spadło poniżej zera.
Context dla i18n
Tłumaczenia to zwykłe obiekty, po jednym na język. Dostawca kontekstu trzyma bieżący język w stanie i udostępnia funkcję setLang, a komponenty czytają teksty przez własny hook useLanguage, więc zmiana języka od razu przerysowuje wszystkie etykiety:
const translations = {
pl: { launch: 'Rozpocznij misję', fuel: 'Paliwo', systems: 'Systemy' },
en: { launch: 'Launch Mission', fuel: 'Fuel', systems: 'Systems' },
};
const LanguageContext = createContext();
function LanguageProvider({ children }) {
const [lang, setLang] = useState('pl');
const t = translations[lang];
return (
<LanguageContext.Provider value={{ lang, setLang, t }}>
{children}
</LanguageContext.Provider>
);
}
function useLanguage() {
return useContext(LanguageContext);
}Portal dla alertów
Alarm musi przykryć cały interfejs, a rodzic z overflow: hidden albo własnym z-index potrafi go przyciąć. createPortal renderuje okno w innym węźle DOM, ale zdarzenia i kontekst nadal płyną przez drzewo Reacta, więc przycisk w oknie może wywołać dispatch albo przeczytać tłumaczenia:
function AlertModal({ message, onClose }) {
return createPortal(
<div className="modal-overlay">
<div className="modal-content">
<h2>Uwaga!</h2>
<p>{message}</p>
<button onClick={onClose}>Zamknij</button>
</div>
</div>,
document.getElementById('modal-root')
);
}Węzeł #modal-root dodajesz w index.html obok #root. W edytorze poniżej portal trafia po prostu do document.body.
Plan pracy
Najłatwiej budować projekt warstwami i sprawdzać działanie po każdym kroku:
- Zacznij od
MissionProviderz reducerem i jednego panelu, który pokazuje status i paliwo. - Dodaj
LanguageProvideri przepuść wszystkie etykiety przez funkcję tłumaczącą. - Zbuduj
DashboardzDashboard.HeaderiDashboard.Panel, a w każdym panelu umieśćErrorBoundary. - Dopisz alarm w portalu, który pojawia się, gdy paliwo spadnie poniżej 20%.
- Na końcu zmierz rendery w React DevTools i dodaj
React.memo,useMemoorazuseCallbacktam, gdzie naprawdę skracają pracę.
Kryteria oceny
- Wszystkie 6 wzorców (Portals, i18n, useReducer, Compound Components, Error Boundaries, memoizacja) muszą być zaimplementowane
- Aplikacja powinna działać bez błędów w konsoli
- Przełączanie języka powinno aktualizować wszystkie etykiety
- Alert powinien pojawiać się automatycznie przy niskim paliwie
Edytor poniżej zawiera działający szkielet centrum dowodzenia ze wszystkimi sześcioma wzorcami. Przełącz język, rozpocznij misję, spal paliwo poniżej 20% i zasymuluj awarię panelu systemów, żeby zobaczyć każdy wzorzec w akcji. Potem rozbuduj aplikację o własne pomysły, na przykład akcję kończącą misję, statystyki floty liczone w useMemo albo trzeci język, i porównaj ją ze strukturą opisaną powyżej.
Kod do tej lekcji: App.jsx
import { Component, createContext, memo, useCallback, useContext, useMemo, useReducer, useState } from 'react';
import { createPortal } from 'react-dom';
import './App.css';
// === I18N: Context z tłumaczeniami ===
const translations = {
pl: {
title: 'Centrum Dowodzenia Misją',
status: 'Status misji',
systems: 'Systemy',
crew: 'Załoga',
fuel: 'Paliwo',
launch: 'Rozpocznij misję',
abort: 'Przerwij misję',
burnFuel: '-10% paliwa',
ready: 'Gotowi do startu',
inProgress: 'Misja w toku',
lowFuel: 'Uwaga! Niski poziom paliwa!',
alertTitle: 'Alarm',
dismiss: 'Zamknij',
addMember: 'Dodaj członka',
namePlaceholder: 'Imię astronauty',
active: 'aktywnych',
on: 'WŁ.',
off: 'WYŁ.',
engine: 'Silnik',
shields: 'Tarcze',
comms: 'Komunikacja',
navigation: 'Nawigacja',
commander: 'Dowódca',
navigator: 'Nawigator',
recruit: 'Rekrut',
crashed: 'Panel uległ awarii',
reload: 'Załaduj ponownie',
simulateCrash: 'Symuluj awarię panelu',
},
en: {
title: 'Mission Command Center',
status: 'Mission status',
systems: 'Systems',
crew: 'Crew',
fuel: 'Fuel',
launch: 'Launch mission',
abort: 'Abort mission',
burnFuel: '-10% fuel',
ready: 'Ready for launch',
inProgress: 'Mission in progress',
lowFuel: 'Warning! Low fuel level!',
alertTitle: 'Alert',
dismiss: 'Dismiss',
addMember: 'Add member',
namePlaceholder: 'Astronaut name',
active: 'active',
on: 'ON',
off: 'OFF',
engine: 'Engine',
shields: 'Shields',
comms: 'Communications',
navigation: 'Navigation',
commander: 'Commander',
navigator: 'Navigator',
recruit: 'Recruit',
crashed: 'The panel has crashed',
reload: 'Reload',
simulateCrash: 'Simulate a panel failure',
},
};
const FIRST_LANG = 'pl';
const SECOND_LANG = 'en';
const LanguageContext = createContext(null);
function LanguageProvider({ children }) {
const [lang, setLang] = useState(FIRST_LANG);
const t = useCallback(key => translations[lang][key] ?? key, [lang]);
const toggleLang = useCallback(() => setLang(l => (l === FIRST_LANG ? SECOND_LANG : FIRST_LANG)), []);
const value = useMemo(() => ({ lang, t, toggleLang }), [lang, t, toggleLang]);
return <LanguageContext.Provider value={value}>{children}</LanguageContext.Provider>;
}
function useLanguage() {
return useContext(LanguageContext);
}
// === STAN MISJI: useReducer ===
const initialMission = {
status: 'ready',
fuel: 100,
systems: [
{ id: 1, key: 'engine', active: true },
{ id: 2, key: 'shields', active: false },
{ id: 3, key: 'comms', active: true },
{ id: 4, key: 'navigation', active: true },
],
crew: [
{ id: 1, name: 'Ra', role: 'commander' },
{ id: 2, name: 'Astro', role: 'navigator' },
],
};
function missionReducer(state, action) {
switch (action.type) {
case 'LAUNCH_MISSION':
return { ...state, status: 'inProgress', fuel: Math.max(0, state.fuel - 15) };
case 'ABORT_MISSION':
return { ...state, status: 'ready' };
case 'UPDATE_FUEL':
return { ...state, fuel: Math.max(0, state.fuel + action.payload) };
case 'TOGGLE_SYSTEM':
return {
...state,
systems: state.systems.map(s => (s.id === action.payload ? { ...s, active: !s.active } : s)),
};
case 'ADD_CREW_MEMBER':
return { ...state, crew: [...state.crew, { ...action.payload, role: 'recruit' }] };
default:
return state;
}
}
const MissionContext = createContext(null);
function MissionProvider({ children }) {
const [state, dispatch] = useReducer(missionReducer, initialMission);
const value = useMemo(() => ({ state, dispatch }), [state]);
return <MissionContext.Provider value={value}>{children}</MissionContext.Provider>;
}
function useMission() {
return useContext(MissionContext);
}
// === ERROR BOUNDARY: awaria jednego panelu nie wyłącza reszty ===
class ErrorBoundary extends Component {
constructor(props) {
super(props);
this.state = { hasError: false };
}
static getDerivedStateFromError() {
return { hasError: true };
}
render() {
if (this.state.hasError) {
return (
<div className="error-fallback">
<p>{this.props.message}</p>
<button onClick={() => this.setState({ hasError: false })}>{this.props.retryLabel}</button>
</div>
);
}
return this.props.children;
}
}
// === COMPOUND COMPONENT: Dashboard, Dashboard.Header, Dashboard.Panel ===
function Dashboard({ children }) {
return <div className="dashboard">{children}</div>;
}
Dashboard.Header = memo(function DashboardHeader() {
const { t, lang, toggleLang } = useLanguage();
const next = lang === FIRST_LANG ? SECOND_LANG : FIRST_LANG;
return (
<header className="dashboard-header">
<h1>{t('title')}</h1>
<button className="lang-btn" onClick={toggleLang}>{next.toUpperCase()}</button>
</header>
);
});
Dashboard.Panel = memo(function DashboardPanel({ title, children }) {
const { t } = useLanguage();
return (
<section className="dashboard-panel">
<h2>{title}</h2>
<ErrorBoundary message={t('crashed')} retryLabel={t('reload')}>
{children}
</ErrorBoundary>
</section>
);
});
// === STATUS MISJI ===
const MissionStatus = memo(function MissionStatus() {
const { state, dispatch } = useMission();
const { t } = useLanguage();
const handleLaunch = useCallback(() => dispatch({ type: 'LAUNCH_MISSION' }), [dispatch]);
const handleAbort = useCallback(() => dispatch({ type: 'ABORT_MISSION' }), [dispatch]);
const handleBurn = useCallback(() => dispatch({ type: 'UPDATE_FUEL', payload: -10 }), [dispatch]);
return (
<div>
<div className="status-indicator">
<span className={'status-dot status-' + state.status} />
<span>{t(state.status)}</span>
</div>
<div className="fuel-bar">
<span>{t('fuel')}: {state.fuel}%</span>
<div className="fuel-track">
<div className={'fuel-fill' + (state.fuel < 20 ? ' fuel-low' : '')} style={{ width: state.fuel + '%' }} />
</div>
</div>
<div className="status-actions">
{state.status === 'ready' && <button className="btn-launch" onClick={handleLaunch}>{t('launch')}</button>}
{state.status === 'inProgress' && (
<>
<button className="btn-abort" onClick={handleAbort}>{t('abort')}</button>
<button className="btn-fuel" onClick={handleBurn}>{t('burnFuel')}</button>
</>
)}
</div>
</div>
);
});
// Czujnik, który na żądanie rzuca błąd podczas renderowania (test Error Boundary)
function SensorArray({ broken }) {
if (broken) {
throw new Error('Awaria czujników systemów');
}
return null;
}
// === LISTA SYSTEMÓW ===
const SystemsList = memo(function SystemsList() {
const { state, dispatch } = useMission();
const { t } = useLanguage();
const [broken, setBroken] = useState(false);
const handleToggle = useCallback(id => dispatch({ type: 'TOGGLE_SYSTEM', payload: id }), [dispatch]);
const activeCount = useMemo(() => state.systems.filter(s => s.active).length, [state.systems]);
return (
<div>
<SensorArray broken={broken} />
<p className="systems-count">{activeCount}/{state.systems.length} {t('active')}</p>
{state.systems.map(system => (
<div key={system.id} className="system-item">
<span>{t(system.key)}</span>
<button className={system.active ? 'sys-on' : 'sys-off'} onClick={() => handleToggle(system.id)}>
{system.active ? t('on') : t('off')}
</button>
</div>
))}
<button className="btn-crash" onClick={() => setBroken(true)}>{t('simulateCrash')}</button>
</div>
);
});
// === LISTA ZAŁOGI ===
const CrewList = memo(function CrewList() {
const { state, dispatch } = useMission();
const { t } = useLanguage();
const [name, setName] = useState('');
const handleAdd = useCallback(() => {
if (!name.trim()) return;
// Identyfikator powstaje w handlerze, bo reducer musi pozostać czystą funkcją
dispatch({ type: 'ADD_CREW_MEMBER', payload: { id: Date.now(), name: name.trim() } });
setName('');
}, [name, dispatch]);
return (
<div>
{state.crew.map(member => (
<div key={member.id} className="crew-item">
<strong>{member.name}</strong>
<span>{t(member.role)}</span>
</div>
))}
<div className="crew-add">
<input
value={name}
onChange={e => setName(e.target.value)}
onKeyDown={e => e.key === 'Enter' && handleAdd()}
placeholder={t('namePlaceholder')}
/>
<button onClick={handleAdd}>{t('addMember')}</button>
</div>
</div>
);
});
// === ALERT W PORTALU: renderowany poza drzewem dashboardu ===
function AlertModal({ onDismiss }) {
const { t } = useLanguage();
return createPortal(
<div className="modal-overlay">
<div className="modal-content">
<h2>{t('alertTitle')}</h2>
<p>{t('lowFuel')}</p>
<button onClick={onDismiss}>{t('dismiss')}</button>
</div>
</div>,
document.body
);
}
// === GŁÓWNA APLIKACJA ===
function MissionControl() {
const { state } = useMission();
const { t } = useLanguage();
const [dismissedAt, setDismissedAt] = useState(null);
// Alert wynika ze stanu: niskie paliwo w trakcie misji, chyba że zamknięto go przy tym poziomie
const showAlert = state.status === 'inProgress' && state.fuel < 20 && dismissedAt !== state.fuel;
return (
<>
<Dashboard>
<Dashboard.Header />
<div className="panels-grid">
<Dashboard.Panel title={t('status')}>
<MissionStatus />
</Dashboard.Panel>
<Dashboard.Panel title={t('systems')}>
<SystemsList />
</Dashboard.Panel>
<Dashboard.Panel title={t('crew')}>
<CrewList />
</Dashboard.Panel>
</div>
</Dashboard>
{showAlert && <AlertModal onDismiss={() => setDismissedAt(state.fuel)} />}
</>
);
}
export default function App() {
return (
<LanguageProvider>
<MissionProvider>
<MissionControl />
</MissionProvider>
</LanguageProvider>
);
}Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?