Kurs JavaScript i React · Moduł 9: Nowoczesne hooki React
Projekt: Zaawansowana aplikacja React 18+
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
Panel z aktualizacjami na żywo
- Wykorzystanie useTransition i useDeferredValue
- Optymistyczne aktualizacje z useOptimistic
- Streaming zawartości z Suspense
Zaawansowane formularze
- useFormStatus i useActionState
- Server Actions
- Walidacja w czasie rzeczywistym
System powiadomień
- useId dla dostępności
- Concurrent rendering
- Progressive enhancement
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 typesFolder 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:
- Concurrent Features: useTransition, useDeferredValue dla responsywnego UI
- Obsługa formularzy: useActionState, useFormStatus z Server Actions
- Dostępność: useId dla unikalnych identyfikatorów
- Optymistyczne aktualizacje: useOptimistic dla natychmiastowej informacji zwrotnej
- Server Components: Renderowanie na serwerze z równoległym pobieraniem danych
- Wzorce Suspense: zagnieżdżone stany ładowania i strumieniowanie
- Wydajność: monitorowanie i optymalizacja
- Obsługa błędów: osobne Error Boundaries dla poszczególnych sekcji
- Bezpieczeństwo typów: pełne wykorzystanie TypeScriptu
Następne kroki do rozszerzenia:
- Dodaj synchronizację na żywo przez WebSockety
- Dodaj pracę offline z Service Workerem
- Dodaj zaawansowane filtry i sortowanie
- Stwórz system uprawnień użytkowników
- Zintegruj z systemem powiadomień push
- Dodaj eksport danych do różnych formatów
- Dodaj tryb ciemny z CSS-in-JS
- 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?