Kurs JavaScript i React · Moduł 9: Nowoczesne hooki React

Projekt: Zaawansowana aplikacja React 18+

12 min czytania ·
W tej lekcji4

Każda załoga przechodzi kiedyś symulację pełnej misji, w której wszystkie systemy działają naraz. Znasz już przejścia, opóźnione wartości, useId, use i useOptimistic, ale osobno. Teraz muszą współpracować w jednym kodzie.

W tym projekcie stworzysz nowoczesną aplikację React wykorzystującą wszystkie poznane funkcjonalności React 18+. Będziesz budować Advanced Task Management System - zaawansowany system zarządzania zadaniami z wykorzystaniem Concurrent Features, Server Components i nowoczesnych hooków.

Specyfikacja projektu

Funkcjonalności główne

  1. Panel z aktualizacjami na żywo

    • Wykorzystanie useTransition i useDeferredValue
    • Optymistyczne aktualizacje z useOptimistic
    • Streaming zawartości z Suspense
  2. Zaawansowane formularze

    • useFormStatus i useActionState
    • Server Actions
    • Walidacja w czasie rzeczywistym
  3. System powiadomień

    • useId dla dostępności
    • Concurrent rendering
    • Progressive enhancement
  4. Wydajność i optymalizacja

    • React Compiler (opcjonalnie)
    • Automatic Batching
    • Selective Hydration

React Compiler ma od 2025 roku stabilną wersję 1.0 i sam dodaje memoizację, więc warto go rozważyć.

Struktura aplikacji

Projekt korzysta z App Routera Next.js, czyli frameworka, który obsługuje Server Components i Server Actions. Oto mapa katalogów:

src/
├── app/
│   ├── layout.tsx          # Root layout (Server Component)
│   ├── page.tsx            # Home page
│   ├── dashboard/
│   │   ├── page.tsx        # Dashboard (Server Component)
│   │   └── loading.tsx     # Loading UI
│   ├── tasks/
│   │   ├── page.tsx        # Tasks list
│   │   ├── [id]/page.tsx   # Task details
│   │   └── new/page.tsx    # Create task
│   └── api/
│       ├── tasks/route.ts  # Tasks API
│       └── notifications/route.ts
├── components/
│   ├── ui/                 # Basic UI components
│   ├── forms/              # Form components
│   ├── dashboard/          # Dashboard components
│   └── tasks/              # Task components
├── hooks/                  # Custom hooks
├── lib/                    # Utilities
└── types/                  # TypeScript types

Folder app/ to trasy, components/ to klocki UI, a lib/ to logika serwerowa.

Implementacja krok po kroku

Krok 1: Podstawowa struktura i typy

Zaczynamy od danych. Interfejs TypeScript to kontrakt opisujący pola zadania, użytkownika i powiadomienia:

// types/index.ts
export interface Task {
  id: string;
  title: string;
  description: string;
  status: 'pending' | 'in_progress' | 'completed';
  priority: 'low' | 'medium' | 'high';
  assignee?: string;
  dueDate?: Date;
  createdAt: Date;
  updatedAt: Date;
}

export interface User {
  id: string;
  name: string;
  email: string;
  avatar?: string;
}

export interface Notification {
  id: string;
  type: 'task_created' | 'task_updated' | 'task_completed';
  message: string;
  timestamp: Date;
  read: boolean;
}

Pola ze znakiem zapytania, jak assignee?, są opcjonalne, a unie typu 'low' | 'medium' | 'high' pozwalają tylko na wymienione wartości.

Krok 2: Root Layout z Server Components

Layout to asynchroniczny Server Component, więc może pobrać dane użytkownika jeszcze na serwerze:

// app/layout.tsx (Server Component)
import { Suspense } from 'react';
import { Navigation } from '@/components/Navigation';
import { NotificationProvider } from '@/components/NotificationProvider';

async function RootLayout({ children }: { children: React.ReactNode }) {
  // Pobierz dane użytkownika na serwerze
  const user = await getCurrentUser();
  const notifications = await getUnreadNotifications(user.id);

  return (
    <html lang="pl">
      <head>
        <title>Advanced Task Manager</title>
        <meta name="description" content="Zaawansowany system zarządzania zadaniami" />
      </head>
      <body>
        <NotificationProvider initialNotifications={notifications}>
          <div className="app-layout">
            <Suspense fallback={<NavigationSkeleton />}>
              <Navigation user={user} />
            </Suspense>

            <main className="main-content">
              <Suspense fallback={<PageSkeleton />}>
                {children}
              </Suspense>
            </main>
          </div>
        </NotificationProvider>
      </body>
    </html>
  );
}

export default RootLayout;

Dwie granice Suspense pozwalają nawigacji i treści pojawiać się niezależnie. W Next.js tytuł i opis strony definiuje się zwykle przez eksport metadata, a nie ręczny <head>.

Krok 3: Dashboard z Concurrent Features

Strona dashboardu pobiera równolegle statystyki i ostatnie zadania, a wolniejsze sekcje strumieniuje:

// app/dashboard/page.tsx (Server Component)
import { Suspense } from 'react';
import { TasksOverview } from '@/components/dashboard/TasksOverview';
import { RecentActivity } from '@/components/dashboard/RecentActivity';
import { PerformanceMetrics } from '@/components/dashboard/PerformanceMetrics';

async function DashboardPage() {
  // Równoległe pobieranie danych
  const [tasksStats, recentTasks] = await Promise.all([
    getTasksStatistics(),
    getRecentTasks(10)
  ]);

  return (
    <div className="dashboard">
      <h1>Dashboard</h1>

      {/* Szybko ładująca się sekcja */}
      <TasksOverview stats={tasksStats} />

      <div className="dashboard-grid">
        {/* Streams niezależnie */}
        <Suspense fallback={<RecentActivitySkeleton />}>
          <RecentActivity initialTasks={recentTasks} />
        </Suspense>

        {/* Może ładować się później */}
        <Suspense fallback={<MetricsSkeleton />}>
          <PerformanceMetrics />
        </Suspense>
      </div>
    </div>
  );
}

export default DashboardPage;

TasksOverview pojawia się od razu, a PerformanceMetrics doczytuje się później.

Krok 4: Interaktywne komponenty z nowymi hookami

Dyrektywa 'use client' oznacza granicę, za którą kod trafia do przeglądarki i może używać stanu:

// components/dashboard/RecentActivity.tsx (Client Component)
'use client';

import { useState, useTransition, useDeferredValue } from 'react';
import { Task } from '@/types';

interface RecentActivityProps {
  initialTasks: Task[];
}

export function RecentActivity({ initialTasks }: RecentActivityProps) {
  const [tasks, setTasks] = useState(initialTasks);
  const [searchQuery, setSearchQuery] = useState('');
  const [isPending, startTransition] = useTransition();

  // Opóźniona wartość dla wyszukiwania
  const deferredSearchQuery = useDeferredValue(searchQuery);

  // Filtrowanie zadań z wykorzystaniem deferredValue
  const filteredTasks = tasks.filter(task =>
    task.title.toLowerCase().includes(deferredSearchQuery.toLowerCase()) ||
    task.description.toLowerCase().includes(deferredSearchQuery.toLowerCase())
  );

  const handleSearch = (query: string) => {
    setSearchQuery(query);

    // Użyj transition dla mniej priorytetowych aktualizacji
    startTransition(() => {
      // Dodatkowe operacje które mogą być przerwane
      updateSearchAnalytics(query);
    });
  };

  const refreshTasks = async () => {
    startTransition(async () => {
      const newTasks = await fetchRecentTasks();
      setTasks(newTasks);
    });
  };

  return (
    <div className="recent-activity">
      <div className="activity-header">
        <h2>Ostatnia aktywność</h2>
        <button
          onClick={refreshTasks}
          disabled={isPending}
          className={isPending ? 'loading' : ''}
        >
          {isPending ? 'Odświeżanie...' : 'Odśwież'}
        </button>
      </div>

      <SearchInput
        value={searchQuery}
        onChange={handleSearch}
        isPending={isPending}
      />

      <div className="tasks-list">
        {filteredTasks.map(task => (
          <TaskCard
            key={task.id}
            task={task}
            onUpdate={setTasks}
          />
        ))}

        {deferredSearchQuery && filteredTasks.length === 0 && (
          <div className="no-results">
            Brak wyników dla "{deferredSearchQuery}"
          </div>
        )}
      </div>
    </div>
  );
}

Lista filtruje się według deferredSearchQuery, więc pole wyszukiwania nie zwalnia. Dwie uwagi: startTransition w handleSearch nie przerywa samego wywołania updateSearchAnalytics, bo przerywalne są tylko rendery po zmianach stanu. A setTasks po await powinien zgodnie z react.dev trafić do kolejnego startTransition.

Krok 5: Zaawansowane formularze z Server Actions

Formularz łączy trzy hooki. useActionState trzyma wynik akcji, useOptimistic pokazuje zapis od razu, a useFormStatus informuje przycisk o wysyłce. Ważne: useFormStatus importujemy z react-dom, a nie z react. Najpierw logika:

// components/forms/TaskForm.tsx (Client Component)
'use client';

import { useActionState, useEffect, useId, useOptimistic } from 'react';
import { useFormStatus } from 'react-dom';
import { Task } from '@/types';
import { createTask, updateTask } from '@/lib/actions';

interface TaskFormProps {
  task?: Task;
  onSuccess?: () => void;
}

export function TaskForm({ task, onSuccess }: TaskFormProps) {
  const formId = useId();
  const titleId = useId();
  const descriptionId = useId();

  // useActionState dla zarządzania stanem akcji
  const [state, formAction] = useActionState(
    task ? updateTask.bind(null, task.id) : createTask,
    {
      success: false,
      errors: {},
      data: task || null
    }
  );

  // useOptimistic dla natychmiastowej informacji zwrotnej
  const [optimisticState, addOptimistic] = useOptimistic(
    state,
    (currentState, optimisticUpdate) => ({
      ...currentState,
      ...optimisticUpdate,
      optimistic: true
    })
  );

  const handleSubmit = async (formData: FormData) => {
    // Optymistyczna aktualizacja
    addOptimistic({
      success: true,
      data: {
        id: task?.id || 'temp-' + Date.now(),
        title: formData.get('title') as string,
        description: formData.get('description') as string,
        status: formData.get('status') as Task['status'],
        priority: formData.get('priority') as Task['priority'],
        createdAt: new Date(),
        updatedAt: new Date()
      }
    });

    // Wykonaj rzeczywistą akcję
    formAction(formData);
  };

  // Nowy state pojawia się w kolejnym renderze, więc reagujemy na niego w efekcie
  useEffect(() => {
    if (state.success) {
      onSuccess?.();
    }
  }, [state, onSuccess]);

Funkcja formAction nie zwraca Promise, a state w tym domknięciu to jeszcze stary stan. Dlatego na sukces reagujemy w efekcie, gdy nowy state przyjdzie w kolejnym renderze. Teraz widok formularza:

  return (
    <form
      id={formId}
      action={handleSubmit}
      className="task-form"
    >
      <div className="form-group">
        <label htmlFor={titleId}>Tytuł zadania</label>
        <input
          id={titleId}
          name="title"
          type="text"
          required
          defaultValue={optimisticState.data?.title || ''}
          className={optimisticState.errors?.title ? 'error' : ''}
        />
        {optimisticState.errors?.title && (
          <span className="error-message" role="alert">
            {optimisticState.errors.title}
          </span>
        )}
      </div>

      <div className="form-group">
        <label htmlFor={descriptionId}>Opis</label>
        <textarea
          id={descriptionId}
          name="description"
          rows={4}
          defaultValue={optimisticState.data?.description || ''}
        />
      </div>

      <div className="form-group">
        <label>Status</label>
        <select name="status" defaultValue={optimisticState.data?.status || 'pending'}>
          <option value="pending">Oczekujące</option>
          <option value="in_progress">W trakcie</option>
          <option value="completed">Zakończone</option>
        </select>
      </div>

      <div className="form-group">
        <label>Priorytet</label>
        <select name="priority" defaultValue={optimisticState.data?.priority || 'medium'}>
          <option value="low">Niski</option>
          <option value="medium">Średni</option>
          <option value="high">Wysoki</option>
        </select>
      </div>

      <FormSubmitButton />

      {optimisticState.optimistic && (
        <div className="optimistic-indicator">
          Zapisywanie...
        </div>
      )}

      {optimisticState.success && !optimisticState.optimistic && (
        <div className="success-message">
          Zadanie zostało {task ? 'zaktualizowane' : 'utworzone'}!
        </div>
      )}
    </form>
  );
}

// Komponent wykorzystujący useFormStatus
function FormSubmitButton() {
  const { pending } = useFormStatus();

  return (
    <button
      type="submit"
      disabled={pending}
      className={pending ? 'loading' : ''}
    >
      {pending ? 'Zapisywanie...' : 'Zapisz zadanie'}
    </button>
  );
}

FormSubmitButton jest osobnym komponentem, bo useFormStatus czyta stan formularza rodzica, więc musi być wywołany wewnątrz <form>.

Krok 6: Server Actions

Dyrektywa 'use server' sprawia, że te funkcje wykonują się tylko na serwerze. Walidację robimy biblioteką Zod:

// lib/actions.ts
'use server';

import { revalidatePath } from 'next/cache';
import { redirect } from 'next/navigation';
import { z } from 'zod';

const TaskSchema = z.object({
  title: z.string().min(1, 'Tytuł jest wymagany').max(100, 'Tytuł jest za długi'),
  description: z.string().optional(),
  status: z.enum(['pending', 'in_progress', 'completed']),
  priority: z.enum(['low', 'medium', 'high']),
  dueDate: z.string().optional().transform(str => str ? new Date(str) : undefined)
});

export async function createTask(prevState: any, formData: FormData) {
  try {
    const validatedFields = TaskSchema.safeParse({
      title: formData.get('title'),
      description: formData.get('description'),
      status: formData.get('status'),
      priority: formData.get('priority'),
      dueDate: formData.get('dueDate')
    });

    if (!validatedFields.success) {
      return {
        success: false,
        errors: z.flattenError(validatedFields.error).fieldErrors,
        data: null
      };
    }

    const task = await db.tasks.create({
      data: {
        ...validatedFields.data,
        id: generateId(),
        createdAt: new Date(),
        updatedAt: new Date()
      }
    });

    // Revalidate cache
    revalidatePath('/dashboard');
    revalidatePath('/tasks');

    return {
      success: true,
      errors: {},
      data: task
    };

  } catch (error) {
    return {
      success: false,
      errors: { _form: ['Wystąpił błąd podczas tworzenia zadania'] },
      data: null
    };
  }
}

safeParse nie rzuca wyjątku, tylko zwraca obiekt z polem success. Błędy spłaszczamy przez z.flattenError, bo w Zod 4 metoda error.flatten() jest oznaczona jako przestarzała. Akcja edycji wygląda podobnie:

export async function updateTask(taskId: string, prevState: any, formData: FormData) {
  try {
    const validatedFields = TaskSchema.safeParse({
      title: formData.get('title'),
      description: formData.get('description'),
      status: formData.get('status'),
      priority: formData.get('priority'),
      dueDate: formData.get('dueDate')
    });

    if (!validatedFields.success) {
      return {
        success: false,
        errors: z.flattenError(validatedFields.error).fieldErrors,
        data: null
      };
    }

    const task = await db.tasks.update({
      where: { id: taskId },
      data: {
        ...validatedFields.data,
        updatedAt: new Date()
      }
    });

    revalidatePath(`/tasks/${taskId}`);
    revalidatePath('/dashboard');

    return {
      success: true,
      errors: {},
      data: task
    };

  } catch (error) {
    return {
      success: false,
      errors: { _form: ['Wystąpił błąd podczas aktualizacji zadania'] },
      data: null
    };
  }
}

updateTask dostaje taskId jako pierwszy argument dzięki bind w formularzu, a revalidatePath odświeża dane stron.

Krok 7: Zaawansowane wzorce Suspense

Granice Suspense można zagnieżdżać, aż do pojedynczej karty:

// components/tasks/TasksList.tsx (Server Component)
import { Suspense } from 'react';
import { TaskCard } from './TaskCard';
import { TasksFilter } from './TasksFilter';

async function TasksList({ searchParams }: { searchParams: any }) {
  return (
    <div className="tasks-page">
      <div className="tasks-header">
        <h1>Zadania</h1>

        {/* Filter nie wymaga Suspense - szybko się ładuje */}
        <TasksFilter />
      </div>

      <div className="tasks-content">
        {/* Główna lista zadań */}
        <Suspense fallback={<TasksListSkeleton />}>
          <TasksGrid searchParams={searchParams} />
        </Suspense>

        {/* Sidebar z dodatkowymi informacjami */}
        <aside className="tasks-sidebar">
          <Suspense fallback={<StatsSkeleton />}>
            <TasksStatistics />
          </Suspense>

          <Suspense fallback={<ActivitySkeleton />}>
            <RecentActivity />
          </Suspense>
        </aside>
      </div>
    </div>
  );
}

// Komponent z długim czasem ładowania
async function TasksGrid({ searchParams }: { searchParams: any }) {
  // Symuluj długie zapytanie
  const tasks = await getFilteredTasks(searchParams);

  return (
    <div className="tasks-grid">
      {tasks.map(task => (
        <Suspense
          key={task.id}
          fallback={<TaskCardSkeleton />}
        >
          <TaskCard task={task} />
        </Suspense>
      ))}
    </div>
  );
}

Od Next.js 15 searchParams na stronie jest obiektem Promise, więc przed użyciem trzeba go odczytać przez await.

Krok 8: Dostępność z useId

Uniwersalne pole formularza wstrzykuje identyfikatory do swojego dziecka:

// components/ui/FormField.tsx
'use client';

import { useId, forwardRef, cloneElement } from 'react';

interface FormFieldProps {
  label: string;
  error?: string;
  help?: string;
  required?: boolean;
  children: React.ReactNode;
}

export const FormField = forwardRef<HTMLDivElement, FormFieldProps>(
  ({ label, error, help, required, children }, ref) => {
    const fieldId = useId();
    const errorId = useId();
    const helpId = useId();

    return (
      <div ref={ref} className="form-field">
        <label
          htmlFor={fieldId}
          className={required ? 'required' : ''}
        >
          {label}
          {required && <span aria-hidden="true">*</span>}
        </label>

        <div className="field-input">
          {cloneElement(children as React.ReactElement, {
            id: fieldId,
            'aria-describedby': [
              help ? helpId : null,
              error ? errorId : null
            ].filter(Boolean).join(' ') || undefined,
            'aria-invalid': error ? 'true' : undefined,
            required
          })}
        </div>

        {help && (
          <div id={helpId} className="field-help">
            {help}
          </div>
        )}

        {error && (
          <div
            id={errorId}
            className="field-error"
            role="alert"
            aria-live="polite"
          >
            {error}
          </div>
        )}
      </div>
    );
  }
);

FormField.displayName = 'FormField';

W React 19 ref jest zwykłym propsem komponentu funkcyjnego, a forwardRef ma zostać w przyszłości wycofany, więc w nowym kodzie możesz przyjąć ref wprost.

Krok 9: Monitorowanie wydajności

Na koniec kontekst zbierający metryki wydajności:

// components/providers/PerformanceProvider.tsx
'use client';

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

interface PerformanceMetrics {
  renderTime: number;
  interactionTime: number;
  suspenseTime: number;
}

const PerformanceContext = createContext<{
  metrics: PerformanceMetrics;
  recordMetric: (type: keyof PerformanceMetrics, time: number) => void;
}>({
  metrics: { renderTime: 0, interactionTime: 0, suspenseTime: 0 },
  recordMetric: () => {}
});

export function PerformanceProvider({ children }: { children: React.ReactNode }) {
  const [metrics, setMetrics] = useState<PerformanceMetrics>({
    renderTime: 0,
    interactionTime: 0,
    suspenseTime: 0
  });

  const recordMetric = (type: keyof PerformanceMetrics, time: number) => {
    setMetrics(prev => ({
      ...prev,
      [type]: time
    }));

    // Wyślij metryki do systemu analitycznego
    if (time > getThreshold(type)) {
      analytics.track('performance_issue', {
        type,
        time,
        url: window.location.pathname
      });
    }
  };

  useEffect(() => {
    // Obserwuj Web Vitals
    const observer = new PerformanceObserver((list) => {
      for (const entry of list.getEntries()) {
        if (entry.entryType === 'measure') {
          recordMetric('renderTime', entry.duration);
        }
      }
    });

    observer.observe({ entryTypes: ['measure'] });

    return () => observer.disconnect();
  }, []);

  return (
    <PerformanceContext.Provider value={{ metrics, recordMetric }}>
      {children}
    </PerformanceContext.Provider>
  );
}

export const usePerformance = () => useContext(PerformanceContext);

function getThreshold(type: keyof PerformanceMetrics): number {
  const thresholds = {
    renderTime: 100,      // 100ms
    interactionTime: 50,  // 50ms
    suspenseTime: 1000    // 1s
  };
  return thresholds[type];
}

PerformanceObserver słucha tu wpisów typu measure, czyli Twoich własnych pomiarów, a nie Web Vitals. Do Core Web Vitals użyj biblioteki web-vitals.

Podsumowanie projektu

Ten projekt demonstruje:

  1. Concurrent Features: useTransition, useDeferredValue dla responsywnego UI
  2. Obsługa formularzy: useActionState, useFormStatus z Server Actions
  3. Dostępność: useId dla unikalnych identyfikatorów
  4. Optymistyczne aktualizacje: useOptimistic dla natychmiastowej informacji zwrotnej
  5. Server Components: Renderowanie na serwerze z równoległym pobieraniem danych
  6. Wzorce Suspense: zagnieżdżone stany ładowania i strumieniowanie
  7. Wydajność: monitorowanie i optymalizacja
  8. Obsługa błędów: osobne Error Boundaries dla poszczególnych sekcji
  9. Bezpieczeństwo typów: pełne wykorzystanie TypeScriptu

Następne kroki do rozszerzenia:

  1. Dodaj synchronizację na żywo przez WebSockety
  2. Dodaj pracę offline z Service Workerem
  3. Dodaj zaawansowane filtry i sortowanie
  4. Stwórz system uprawnień użytkowników
  5. Zintegruj z systemem powiadomień push
  6. Dodaj eksport danych do różnych formatów
  7. Dodaj tryb ciemny z CSS-in-JS
  8. Stwórz mobilną aplikację z React Native

Ten projekt to solidna podstawa do budowania nowoczesnych aplikacji React wykorzystujących najnowsze funkcjonalności frameworka.

Moja rada: buduj krok po kroku i po każdym kroku uruchamiaj aplikację. Pamiętaj: dobra misja to taka, w której każdy system statku zna swoje zadanie, a centrum kontroli widzi wszystkie naraz.

Kod do tej lekcji: App.jsx
import React, {
  useState, useMemo, useCallback, memo,
  useTransition, useDeferredValue, Suspense, lazy, createContext, use,
} from 'react';

// ========================
// KONTEKSTY APLIKACJI
// ========================
const ThemeContext = createContext('dark');

// ========================
// DANE SYMULACYJNE
// ========================
function generateCrewMembers(count) {
  const roles = ['Pilot', 'Nawigator', 'Inżynier', 'Medyk', 'Naukowiec', 'Technik'];
  const statuses = ['Aktywny', 'Na misji', 'Odpoczynek', 'Szkolenie'];
  const members = [];
  for (let i = 0; i < count; i++) {
    members.push({
      id: i + 1,
      name: `Kosmonauta-${(i + 1).toString().padStart(3, '0')}`,
      role: roles[i % roles.length],
      status: statuses[i % statuses.length],
      missions: Math.floor(Math.random() * 50),
      rating: (3 + Math.random() * 2).toFixed(1),
    });
  }
  return members;
}

const ALL_CREW = generateCrewMembers(200);

// ========================
// ZOPTYMALIZOWANE KOMPONENTY
// ========================

// React.memo - zapobiega niepotrzebnym re-renderom
const StatCard = memo(function StatCard({ label, value, color, icon }) {
  return (
    <div style={{
      padding: '16px', borderRadius: '10px',
      background: `${color}11`, border: `1px solid ${color}33`,
      textAlign: 'center', minWidth: '120px',
    }}>
      <div style={{ fontSize: '24px', marginBottom: '4px' }}>{icon}</div>
      <div style={{ fontSize: '22px', fontWeight: 'bold', color }}>{value}</div>
      <div style={{ fontSize: '12px', color: '#778da9', marginTop: '4px' }}>{label}</div>
    </div>
  );
});

// Memoizowany wiersz tabeli
const CrewRow = memo(function CrewRow({ member, onSelect }) {
  const statusColor = {
    'Aktywny': '#4ecdc4',
    'Na misji': '#ffd700',
    'Odpoczynek': '#778da9',
    'Szkolenie': '#00d4ff',
  }[member.status] || '#778da9';

  return (
    <div
      onClick={() => onSelect(member)}
      style={{
        display: 'grid', gridTemplateColumns: '1fr 100px 90px 60px 50px',
        padding: '10px 14px', fontSize: '13px',
        borderBottom: '1px solid #1a2a3c', cursor: 'pointer',
        transition: 'background 0.15s',
      }}
      onMouseEnter={e => e.currentTarget.style.background = 'rgba(0,212,255,0.05)'}
      onMouseLeave={e => e.currentTarget.style.background = 'transparent'}
    >
      <span style={{ color: '#e0e1dd' }}>{member.name}</span>
      <span style={{ color: '#778da9' }}>{member.role}</span>
      <span style={{ color: statusColor }}>{member.status}</span>
      <span style={{ color: '#c0c8d0', textAlign: 'center' }}>{member.missions}</span>
      <span style={{ color: '#ffd700', textAlign: 'center' }}>{member.rating}</span>
    </div>
  );
});

// TODO 1: Owiń komponent DetailPanel w React.memo
// Powinien renderować się tylko wtedy, gdy zmieni się selectedMember
function DetailPanel({ selectedMember }) {
  if (!selectedMember) {
    return (
      <div style={{
        padding: '40px', textAlign: 'center', color: '#556677',
        background: 'rgba(255,255,255,0.02)', borderRadius: '10px',
      }}>
        Wybierz członka załogi, aby zobaczyć szczegóły
      </div>
    );
  }
  return (
    <div style={{
      padding: '20px', background: 'rgba(0, 212, 255, 0.04)',
      borderRadius: '10px', border: '1px solid #1a3a5c',
    }}>
      <h3 style={{ color: '#00d4ff', margin: '0 0 12px' }}>{selectedMember.name}</h3>
      <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '10px', fontSize: '13px' }}>
        <div><span style={{ color: '#778da9' }}>Rola:</span> <span style={{ color: '#e0e1dd' }}>{selectedMember.role}</span></div>
        <div><span style={{ color: '#778da9' }}>Status:</span> <span style={{ color: '#4ecdc4' }}>{selectedMember.status}</span></div>
        <div><span style={{ color: '#778da9' }}>Misje:</span> <span style={{ color: '#e0e1dd' }}>{selectedMember.missions}</span></div>
        <div><span style={{ color: '#778da9' }}>Ocena:</span> <span style={{ color: '#ffd700' }}>{selectedMember.rating}/5.0</span></div>
      </div>
    </div>
  );
}

// ========================
// GŁÓWNY DASHBOARD
// ========================
export default function App() {
  const [searchQuery, setSearchQuery] = useState('');
  const [statusFilter, setStatusFilter] = useState('all');
  const [selectedMember, setSelectedMember] = useState(null);
  const [isPending, startTransition] = useTransition();

  // useDeferredValue - opóźnione wyszukiwanie
  const deferredSearch = useDeferredValue(searchQuery);

  // useMemo - zapamiętanie przefiltrowanej listy
  const filteredCrew = useMemo(() => {
    return ALL_CREW.filter(member => {
      const matchesSearch = member.name.toLowerCase().includes(deferredSearch.toLowerCase()) ||
                            member.role.toLowerCase().includes(deferredSearch.toLowerCase());
      const matchesStatus = statusFilter === 'all' || member.status === statusFilter;
      return matchesSearch && matchesStatus;
    });
  }, [deferredSearch, statusFilter]);

  // useMemo - obliczenie statystyk
  const stats = useMemo(() => ({
    total: ALL_CREW.length,
    active: ALL_CREW.filter(m => m.status === 'Aktywny').length,
    onMission: ALL_CREW.filter(m => m.status === 'Na misji').length,
    avgRating: (ALL_CREW.reduce((sum, m) => sum + parseFloat(m.rating), 0) / ALL_CREW.length).toFixed(1),
  }), []);

  // useCallback - stabilna referencja funkcji dla memo komponentów
  const handleSelect = useCallback((member) => {
    setSelectedMember(member);
  }, []);

  // TODO 2: Użyj useCallback dla handleStatusChange
  // żeby zapobiec ponownym renderom komponentów filtrujących
  const handleStatusChange = (status) => {
    startTransition(() => {
      setStatusFilter(status);
    });
  };

  // TODO 3: Użyj useMemo, aby obliczyć topPerformers
  // (5 najlepszych członków według oceny z przefiltrowanej listy)
  // sort zmienia tablicę w miejscu, więc sortujemy kopię: inaczej tabela też ułożyłaby się według oceny
  const topPerformers = [...filteredCrew]
    .sort((a, b) => parseFloat(b.rating) - parseFloat(a.rating))
    .slice(0, 5);

  const STATUSES = ['all', 'Aktywny', 'Na misji', 'Odpoczynek', 'Szkolenie'];

  return (
    <div style={{
      minHeight: '100vh',
      background: 'linear-gradient(135deg, #0a0e27 0%, #1a1a3e 100%)',
      padding: '20px', fontFamily: 'monospace', color: '#e0e1dd',
    }}>
      <h1 style={{ color: '#00d4ff', textAlign: 'center', margin: '0 0 4px' }}>
        Centrum Dowodzenia Floty
      </h1>
      <p style={{ color: '#778da9', textAlign: 'center', marginBottom: '20px', fontSize: '13px' }}>
        Dashboard z React.memo | useMemo | useCallback | useTransition | useDeferredValue
      </p>

      {/* Statystyki */}
      <div style={{
        display: 'flex', gap: '12px', justifyContent: 'center',
        marginBottom: '20px', flexWrap: 'wrap',
      }}>
        <StatCard icon="◆" label="Cała zaloga" value={stats.total} color="#00d4ff" />
        <StatCard icon="OK" label="Aktywni" value={stats.active} color="#4ecdc4" />
        <StatCard icon="▲" label="Na misji" value={stats.onMission} color="#ffd700" />
        <StatCard icon="◆" label="Średnia ocena" value={stats.avgRating} color="#ff6b4a" />
      </div>

      <div style={{ maxWidth: '800px', margin: '0 auto' }}>
        {/* Wyszukiwanie i filtry */}
        <div style={{ display: 'flex', gap: '8px', marginBottom: '12px', flexWrap: 'wrap' }}>
          <input
            value={searchQuery}
            onChange={e => setSearchQuery(e.target.value)}
            placeholder="Szukaj członka załogi..."
            style={{
              flex: 1, minWidth: '200px', padding: '10px 14px',
              background: '#0d1b2a', border: '1px solid #1a3a5c',
              borderRadius: '8px', color: '#e0e1dd', fontSize: '14px',
            }}
          />
          {STATUSES.map(status => (
            <button
              key={status}
              onClick={() => handleStatusChange(status)}
              style={{
                padding: '8px 14px',
                background: statusFilter === status ? '#1a3a5c' : 'transparent',
                border: `1px solid ${statusFilter === status ? '#00d4ff' : '#1a3a5c'}`,
                borderRadius: '6px', fontSize: '12px',
                color: statusFilter === status ? '#00d4ff' : '#778da9',
                cursor: 'pointer',
              }}
            >
              {status === 'all' ? 'Wszyscy' : status}
            </button>
          ))}
        </div>

        {isPending && (
          <div style={{ color: '#00d4ff', fontSize: '12px', marginBottom: '8px' }}>
            Filtrowanie...
          </div>
        )}

        <div style={{ display: 'grid', gridTemplateColumns: '1fr 280px', gap: '16px' }}>
          {/* Tabela załogi */}
          <div>
            <div style={{
              display: 'grid', gridTemplateColumns: '1fr 100px 90px 60px 50px',
              padding: '8px 14px', fontSize: '11px', color: '#556677',
              borderBottom: '2px solid #1a3a5c', textTransform: 'uppercase',
            }}>
              <span>Nazwa</span><span>Rola</span><span>Status</span>
              <span style={{ textAlign: 'center' }}>Misje</span>
              <span style={{ textAlign: 'center' }}>Ocena</span>
            </div>
            <div style={{ maxHeight: '350px', overflow: 'auto' }}>
              {filteredCrew.slice(0, 50).map(member => (
                <CrewRow
                  key={member.id}
                  member={member}
                  onSelect={handleSelect}
                />
              ))}
            </div>
            <div style={{ padding: '8px 14px', fontSize: '12px', color: '#556677' }}>
              Wyświetlono {Math.min(50, filteredCrew.length)} z {filteredCrew.length} wyników
            </div>
          </div>

          {/* Panel boczny */}
          <div>
            <DetailPanel selectedMember={selectedMember} />

            <div style={{ marginTop: '16px' }}>
              <h4 style={{ color: '#ffd700', margin: '0 0 8px', fontSize: '13px' }}>
                Top 5 - najwyższa ocena
              </h4>
              {topPerformers.map((m, i) => (
                <div key={m.id} style={{
                  display: 'flex', justifyContent: 'space-between',
                  padding: '6px 10px', fontSize: '12px',
                  background: i === 0 ? 'rgba(255, 215, 0, 0.06)' : 'transparent',
                  borderRadius: '4px',
                }}>
                  <span style={{ color: '#c0c8d0' }}>
                    {i + 1}. {m.name}
                  </span>
                  <span style={{ color: '#ffd700' }}>{m.rating}</span>
                </div>
              ))}
            </div>
          </div>
        </div>
      </div>
    </div>
  );
}

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. Projekt do wysłaniaProjekt do mentora: Laboratorium wydajności Galactic Core
  2. WideoVideo: Podsumowanie modułu

Przydatne artykuły