Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React

Projekt główny: Kosmiczne Centrum Dowodzenia Misją

5 min czytania ·
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

  1. Dashboard wyświetla 3 panele: Status Misji, Systemy, Załoga
  2. Przełącznik języka (PL/EN) zmienia wszystkie etykiety interfejsu
  3. Przycisk startu misji zmienia status i zużywa paliwo (useReducer)
  4. Systemy można włączać/wyłączać (toggle)
  5. Alert modal (Portal) pojawia się gdy paliwo spadnie poniżej 20%
  6. Error Boundary wyświetla fallback gdy komponent rzuci błąd
  7. 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:

  1. Zacznij od MissionProvider z reducerem i jednego panelu, który pokazuje status i paliwo.
  2. Dodaj LanguageProvider i przepuść wszystkie etykiety przez funkcję tłumaczącą.
  3. Zbuduj Dashboard z Dashboard.Header i Dashboard.Panel, a w każdym panelu umieść ErrorBoundary.
  4. Dopisz alarm w portalu, który pojawia się, gdy paliwo spadnie poniżej 20%.
  5. Na końcu zmierz rendery w React DevTools i dodaj React.memo, useMemo oraz useCallback tam, 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?

  1. Projekt do wysłaniaProjekt do mentora: Kosmiczne Centrum Dowodzenia Misją
  2. WideoVideo: Podsumowanie modułu

Przydatne artykuły