Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React
React 19.2 - Partial Pre-rendering (PPR)
W tej lekcji9
Strona misji ma stały nagłówek i menu, ale listę aktywnych misji trzeba pobrać przy każdym żądaniu. Statyczne generowanie (SSG) poda szkielet błyskawicznie, ale ze starymi danymi, a SSR poda świeże dane, lecz użytkownik czeka na najwolniejsze zapytanie. Partial Pre-rendering (PPR) łączy oba światy na jednej stronie, jak statek z trasą obliczoną przed startem, który koryguje kurs, gdy dotrą nowe dane.
Czym jest Partial Pre-rendering?
PPR pre-renderuje statyczne części strony podczas budowania, dynamiczne renderuje w czasie żądania i strumieniuje je do klienta w miarę gotowości. React 19.2 dodał do react-dom niskopoziomowe API: prerender zwraca gotową powłokę (prelude) i odłożony stan (postponed), a resume później dokańcza renderowanie. Next.js buduje na nim wygodną warstwę. Tak wygląda podział strony:
┌─────────────────────────────────────────┐
│ Strona WWW │
├─────────────────────────────────────────┤
│ ┌─────────────────────────────────┐ │
│ │ NAGŁÓWEK (pre-rendered) │ │ ← Natychmiastowo
│ └─────────────────────────────────┘ │
│ ┌─────────────────────────────────┐ │
│ │ SIDEBAR (pre-rendered) │ │ ← Natychmiastowo
│ └─────────────────────────────────┘ │
│ ┌─────────────────────────────────┐ │
│ │ CONTENT (Suspense boundary) │ │ ← Streaming
│ │ ┌───────────────────────┐ │ │
│ │ │ Loading... │ │ │
│ │ │ → Dynamic content │ │ │
│ │ └───────────────────────┘ │ │
│ └─────────────────────────────────┘ │
└─────────────────────────────────────────┘Nagłówek i sidebar trafiają do przeglądarki od razu, a fallback w miejscu treści po chwili zamienia się w dane. Granicę wyznacza <Suspense>.
PPR w samym Reakcie: prerender i resume
Next.js nie wymyśla tu własnego mechanizmu, tylko korzysta z API dodanego w React 19.2. Na etapie budowania prerender z react-dom/static renderuje aplikację, a gdy przerwiesz go sygnałem z AbortController, granice Suspense z niegotowymi danymi trafiają do powłoki jako fallback, a ich stan ląduje w obiekcie postponed. Przy żądaniu resume z react-dom/server dokańcza renderowanie właśnie od tego miejsca:
// build.js - etap budowania
import { prerender } from 'react-dom/static';
const controller = new AbortController();
setTimeout(() => controller.abort(), 100); // Po chwili przestań czekać na dane z żądania
const { prelude, postponed } = await prerender(<MissionsPage />, {
signal: controller.signal,
});
await saveShell(prelude); // Statyczna powłoka HTML, np. do CDN
await savePostponedState(postponed); // Stan odłożonych granic Suspense
// server.js - przy każdym żądaniu
import { resume } from 'react-dom/server';
const postponedState = await loadPostponedState();
const stream = await resume(<MissionsPage />, postponedState);
// Przeglądarka dostaje najpierw powłokę z CDN, a potem ten strumień z resztą HTMLprelude to gotowy HTML powłoki, a postponed to zwykły obiekt JSON, który zapiszesz i odczytasz przy żądaniu. Jeśli wszystko zdążyło się wyrenderować, postponed ma wartość null. Do generowania stron statycznych służy jeszcze resumeAndPrerender z react-dom/static, a w Node.js warianty dla strumieni Node: resumeToPipeableStream i prerenderToNodeStream.
Jak działa PPR?
Konfiguracja w Next.js
W Next.js 15 PPR było eksperymentalne i włączało się flagą experimental.ppr. Next.js 16 ją usunął, a PPR jest domyślnym zachowaniem po włączeniu Cache Components:
// next.config.js (Next.js 16+)
module.exports = {
cacheComponents: true, // Włącza Cache Components, a z nimi Partial Pre-rendering
};Z Cache Components dane są domyślnie dynamiczne, a do powłoki trafia to, co nie czyta danych z żądania albo jest oznaczone dyrektywą 'use cache'. Dane z żądania to cookies(), headers(), searchParams, params bez generateStaticParams, zapytania bez cache i wywołanie connection(). Komponent, który ich używa, musi leżeć wewnątrz <Suspense>, inaczej Next.js zgłosi błąd prerenderingu. Cache Components wymaga środowiska Node.js, więc trasy z przestarzałym eksportem runtime = 'edge' trzeba przenieść.
Struktura strony z PPR
Strona z PPR to zwykły komponent, w którym część dynamiczną owijasz w Suspense:
// app/missions/page.jsx
import { Suspense } from 'react';
import MissionHeader from './MissionHeader';
import MissionSidebar from './MissionSidebar';
import MissionList from './MissionList';
import MissionListSkeleton from './MissionListSkeleton';
// Ta strona będzie częściowo pre-renderowana
export default function MissionsPage() {
return (
<div className="missions-layout">
{/* Te komponenty są statyczne - pre-rendered */}
<MissionHeader />
<MissionSidebar />
{/* Ten komponent jest dynamiczny - streaming */}
<Suspense fallback={<MissionListSkeleton />}>
<MissionList />
</Suspense>
</div>
);
}MissionHeader i MissionSidebar trafią do statycznej powłoki, a MissionList wyrenderuje się przy żądaniu. Sposób pisania komponentów się nie zmienia.
Komponenty statyczne (pre-rendered)
Komponenty statyczne nie pobierają danych ani nie czytają niczego z żądania, więc serwer renderuje je raz, podczas budowania:
// MissionHeader.jsx - statyczny komponent
export default function MissionHeader() {
return (
<header className="mission-header">
<h1>Centrum Kontroli Misji</h1>
<nav>
<a href="/missions">Wszystkie misje</a>
<a href="/missions/active">Aktywne</a>
<a href="/missions/completed">Ukończone</a>
</nav>
</header>
);
}
// MissionSidebar.jsx - statyczny komponent
export default function MissionSidebar() {
return (
<aside className="mission-sidebar">
<h2>Filtruj misje</h2>
<ul>
<li>Misje eksploracyjne</li>
<li>Misje badawcze</li>
<li>Misje ratunkowe</li>
</ul>
</aside>
);
}Ich HTML jest taki sam dla wszystkich, więc może leżeć w CDN.
Komponenty dynamiczne (streaming)
Komponent dynamiczny to asynchroniczny Server Component, który pobiera świeże dane przy każdym żądaniu:
// MissionList.jsx - dynamiczny Server Component
async function getMissions() {
// Bez 'use cache' fetch niczego nie zapamiętuje: dane pobierane przy każdym żądaniu
const res = await fetch('https://api.space-missions.com/missions');
return res.json();
}
export default async function MissionList() {
const missions = await getMissions();
return (
<div className="mission-list">
{missions.map(mission => (
<MissionCard key={mission.id} mission={mission} />
))}
</div>
);
}
// MissionListSkeleton.jsx - fallback podczas ładowania
export default function MissionListSkeleton() {
return (
<div className="mission-list skeleton">
{[1, 2, 3].map(i => (
<div key={i} className="mission-card-skeleton">
<div className="skeleton-title" />
<div className="skeleton-text" />
<div className="skeleton-text short" />
</div>
))}
</div>
);
}Z Cache Components fetch bez dyrektywy 'use cache' niczego nie zapamiętuje, więc lista pobiera się przy każdym żądaniu, a do nadejścia danych widać MissionListSkeleton. Szkielet powinien mieć wymiary listy, żeby treść nie skakała.
Zalety PPR
Szybszy Time To First Byte (TTFB)
Porównaj oś czasu żądania bez PPR i z PPR:
Bez PPR:
Request → Render całości → Response
[==========] 800ms
Z PPR:
Request → Pre-rendered shell → Response (instant)
Dynamic parts → Stream
[==] 50ms (shell)
[======] 750ms (dynamic, streaming)Liczby na schemacie są poglądowe. Powłoka wychodzi od razu, więc pierwszy bajt nie czeka na najwolniejsze zapytanie.
Lepsze Core Web Vitals
Na dashboardzie każdy widżet z danymi dostaje własną granicę Suspense:
// Strona z wieloma dynamicznymi sekcjami
export default function DashboardPage() {
return (
<div className="dashboard">
{/* Statyczny layout - natychmiastowy LCP */}
<DashboardHeader />
<DashboardNav />
<main className="dashboard-content">
{/* Dynamiczne widgety - streaming */}
<Suspense fallback={<WidgetSkeleton />}>
<ActiveMissionsWidget />
</Suspense>
<Suspense fallback={<WidgetSkeleton />}>
<CrewStatusWidget />
</Suspense>
<Suspense fallback={<WidgetSkeleton />}>
<ResourcesWidget />
</Suspense>
</main>
</div>
);
}Statyczny nagłówek przyspiesza FCP i LCP, a widżety ładują się niezależnie. Ustal budżet wydajności, czyli limity metryk, jak rozmiar paczki czy czas ładowania, i sprawdzaj go przy każdym wdrożeniu.
Hierarchiczny Suspense
Granice można zagnieżdżać, żeby zależne sekcje pojawiały się warstwami:
export default function MissionDetailsPage({ params }) {
// params to obietnica: strona na nią nie czeka, tylko przekazuje ją dalej
return (
<div className="mission-details">
{/* Poziom 1: Główne dane misji */}
<Suspense fallback={<MissionHeaderSkeleton />}>
<MissionHeader params={params} />
{/* Poziom 2: Załoga (zależy od danych misji) */}
<Suspense fallback={<CrewListSkeleton />}>
<CrewList params={params} />
</Suspense>
{/* Poziom 2: Oś czasu */}
<Suspense fallback={<TimelineSkeleton />}>
<MissionTimeline params={params} />
</Suspense>
</Suspense>
</div>
);
}
async function CrewList({ params }) {
const { id } = await params; // Czekamy dopiero wewnątrz granicy Suspense
const crew = await getCrew(id);
return (
<ul>
{crew.map(member => (
<li key={member.id}>{member.name}</li>
))}
</ul>
);
}Załoga i oś czasu pojawią się po nagłówku misji, każda osobno. W Next.js 15 i 16 params jest obietnicą, dlatego strona nie czeka na nią sama, tylko przekazuje ją dzieciom, a id odczytują dopiero komponenty wewnątrz Suspense. Dzięki temu układ strony i fallbacki nadal trafiają do statycznej powłoki.
Praktyczny przykład - Dashboard kosmiczny
Pełny dashboard łączy część statyczną z dwiema sekcjami dynamicznymi:
// app/dashboard/page.jsx
import { Suspense } from 'react';
import { connection } from 'next/server';
// Statyczny układ - trafia do powłoki
function DashboardLayout({ children }) {
return (
<div className="space-dashboard">
<header className="dashboard-header">
<h1>Galaktyczne Centrum Kontroli</h1>
<Suspense fallback={<time>...</time>}>
<CurrentDate />
</Suspense>
</header>
{children}
</div>
);
}
// Data z chwili żądania, a nie z chwili budowania
async function CurrentDate() {
await connection(); // Od tego miejsca renderuj przy żądaniu
return <time>{new Date().toLocaleDateString('pl-PL')}</time>;
}
// Dynamiczny komponent - pobiera dane w czasie rzeczywistym
async function LiveMissionFeed() {
// Bez 'use cache' każde żądanie pobiera świeże dane
const missions = await fetch('https://api.space/missions/live').then(r => r.json());
return (
<section className="live-feed">
<h2>Aktywne misje</h2>
{missions.map(m => (
<article key={m.id} className="mission-item">
<h3>{m.name}</h3>
<p>Status: {m.status}</p>
<p>Postęp: {m.progress}%</p>
</article>
))}
</section>
);
}
// Dynamiczny komponent - powiadomienia
async function NotificationsPanel() {
const notifications = await fetch('https://api.space/notifications').then(r => r.json());
return (
<aside className="notifications">
<h2>Powiadomienia</h2>
{notifications.map(n => (
<div key={n.id} className={`notification ${n.priority}`}>
{n.message}
</div>
))}
</aside>
);
}
// Statyczny komponent - statystyki ogólne
function GeneralStats() {
return (
<div className="stats-panel">
<h2>Statystyki floty</h2>
<ul>
<li>Aktywne statki: 47</li>
<li>Ukończone misje: 1,234</li>
<li>Członkowie załóg: 892</li>
</ul>
</div>
);
}
// Główna strona z PPR
export default function DashboardPage() {
return (
<DashboardLayout>
{/* Statyczne - pre-rendered */}
<GeneralStats />
<div className="dynamic-content">
{/* Dynamiczne - streaming */}
<Suspense fallback={<div className="skeleton feed-skeleton" />}>
<LiveMissionFeed />
</Suspense>
<Suspense fallback={<div className="skeleton notif-skeleton" />}>
<NotificationsPanel />
</Suspense>
</div>
</DashboardLayout>
);
}GeneralStats należy do powłoki, a LiveMissionFeed i NotificationsPanel strumieniują się niezależnie. Datę obsługuje osobny komponent CurrentDate: zwykłe new Date() w powłoce zamroziłoby datę z chwili budowania, dlatego Cache Components zgłasza wtedy błąd prerenderingu. await connection() przesuwa renderowanie tego jednego komponentu na czas żądania, a Suspense pokazuje w tym czasie fallback. Datę możesz też wyświetlić w komponencie klienckim.
Kontrolowanie zachowania cache
Z Cache Components o tym, co trafia do powłoki, decydują dyrektywy i funkcje w kodzie komponentów. Dane wspólne dla wszystkich oznaczasz 'use cache' z cacheLife i cacheTag, a dane konkretnego użytkownika czytasz wewnątrz Suspense:
// app/missions/page.jsx
import { Suspense } from 'react';
import { cookies } from 'next/headers';
import { cacheLife, cacheTag } from 'next/cache';
// Wspólne dla wszystkich - trafia do statycznej powłoki
async function FleetStats() {
'use cache';
cacheLife('hours'); // Odświeżanie co godzinę
cacheTag('fleet'); // revalidateTag('fleet', 'max') odświeży dane na żądanie
const stats = await fetch('https://api.space/fleet/stats').then(r => r.json());
return <p>Aktywne statki: {stats.activeShips}</p>;
}
// Zależy od ciasteczka - renderowane przy każdym żądaniu
async function PilotGreeting() {
const pilot = (await cookies()).get('pilot')?.value ?? 'astronauto';
return <p>Witaj, {pilot}!</p>;
}
export default function MissionsPage() {
return (
<main>
<h1>Centrum Kontroli Misji</h1>
<FleetStats />
<Suspense fallback={<p>Łączenie z pilotem...</p>}>
<PilotGreeting />
</Suspense>
</main>
);
}Nagłówek i FleetStats trafią do powłoki, bo nie zależą od żądania, a powitanie każdy użytkownik dostanie osobno. Bez Cache Components o renderowaniu decydowały eksporty konfiguracji trasy, jak dynamic = 'force-static', dynamic = 'force-dynamic' czy revalidate. Po włączeniu cacheComponents takie eksporty powodują błąd: zamiast force-static oznaczasz dane dyrektywą 'use cache', zamiast revalidate ustawiasz cacheLife, a force-dynamic jest zbędne, bo bez 'use cache' wszystko jest dynamiczne.
Kiedy używać PPR?
| Scenariusz | Rekomendacja |
|---|---|
| Landing page z dynamicznym hero | PPR |
| Dashboard z danymi na żywo | PPR |
| E-commerce z cenami/dostępnością | PPR |
| Blog ze statyczną treścią | Pełny SSG |
| Aplikacja SPA bez SEO | Client-side |
| Strona z personalizacją | PPR |
Porównanie strategii renderowania
Wybór strategii to część planowania architektury: najpierw analizujesz wymagania, jak świeżość danych, SEO i personalizacja, a potem dobierasz renderowanie:
┌────────────────┬─────────────────────────────────────────┐
│ Strategia │ Charakterystyka │
├────────────────┼─────────────────────────────────────────┤
│ SSG │ Całość pre-rendered, brak dynamiki │
│ SSR │ Całość renderowana per-request │
│ ISR │ Pre-rendered z revalidation │
│ CSR │ Całość renderowana na kliencie │
│ PPR │ Statyczny shell + dynamiczny streaming │
└────────────────┴─────────────────────────────────────────┘
SSG: [████████████] → Client (instant, but stale)
SSR: [............] → [████████████] → Client (slower)
PPR: [████] → [░░░░░░░░] → Client (fast shell + streaming)PPR łączy SSG i SSR na jednej stronie, nie zastępując ich. W przeglądarce każda strategia kończy się podobnie: najpierw widać HTML (FCP), potem przychodzi JavaScript, a React hydratuje stronę, dołączając obsługę zdarzeń, więc onClick zadziała dopiero po hydracji. Identyfikatory muszą się zgadzać na serwerze i w przeglądarce, więc generuj je przez useId, nie Math.random(). Streaming opiera się na współbieżnym Reakcie z poprzedniej lokacji: createRoot, automatycznym grupowaniu aktualizacji, startTransition i useDeferredValue.
Debugging PPR
Najpewniejszym testem podziału jest produkcyjny build. next build wypisuje tabelę tras, a symbol przy każdej trasie mówi, jak będzie serwowana:
Route (app)
┌ ○ /
├ ○ /about
└ ◐ /missions
○ (Static) prerendered as static content
◐ (Partial Prerender) prerendered as static HTML with dynamic server-streamed content○ oznacza stronę w pełni statyczną, a ◐ stronę ze statyczną powłoką i dynamicznymi fragmentami dosyłanymi strumieniowo. Jeśli komponent czyta dane z żądania albo pobiera dane bez cache poza <Suspense>, build zatrzyma się z błędem i podpowie trzy wyjścia: dodać granicę Suspense, zapamiętać dane przez 'use cache' albo świadomie pozwolić trasie blokować renderowanie. Dokładny ślad stosu da next build --debug-prerender, a w trybie deweloperskim te same problemy pokazuje nakładka Next.js. Drzewo komponentów, propsy i stan podejrzysz w React DevTools, a od React 19.2 Chrome DevTools pokazują też ścieżki wydajności Reacta (Scheduler i Components).
Podsumowanie
- Najlepsze z dwóch światów - szybkość statycznego + świeżość dynamicznego
- Automatyczny podział - Next.js wyznacza powłokę na podstawie granic Suspense i danych
- Streaming HTML - użytkownik widzi treść stopniowo
- Suspense boundaries - kontrolujesz granularność dynamicznych części
- Lepsze Core Web Vitals - szczególnie LCP i FCP
Moja rada: zacznij od statycznej powłoki i przesuwaj granice Suspense jak najniżej, do najmniejszego komponentu, który naprawdę potrzebuje danych z żądania.
Pamiętaj: PPR to hybrydowy napęd statku - statyczna powłoka startuje natychmiast, a dynamiczne moduły dołączają w locie. W przykładzie poniżej kliknij "Nowe żądanie": powłoka z menu i filtrami zostaje na miejscu, a sekcje w granicach Suspense, także gotowy już widżet zasobów, dochodzą od nowa z danymi z kolejnego żądania.
Kod do tej lekcji: App.jsx
import { Suspense, use, useState } from 'react';
// === PARTIAL PRE-RENDERING (PPR) - symulacja w przeglądarce ===
// Statyczna powłoka (nagłówek, menu, filtry) jest gotowa od razu, jak HTML zbudowany
// podczas "next build". Sekcje w granicach Suspense dochodzą strumieniowo przy każdym
// żądaniu. Przycisk "Nowe żądanie" pokazuje, że powłoka zostaje, a dane są świeże.
const BUILD_TIME = new Date().toLocaleTimeString('pl-PL'); // Moment "budowania" powłoki
const requests = new Map();
// Dane dynamiczne: jedna obietnica na sekcję w danym żądaniu
function fetchForRequest(section, requestId, delay, makeData) {
const key = section + ':' + requestId;
if (!requests.has(key)) {
requests.set(key, new Promise(resolve => setTimeout(() => {
resolve({ data: makeData(requestId), time: new Date().toLocaleTimeString('pl-PL') });
}, delay)));
}
return requests.get(key);
}
const vary = (base, requestId, spread) => Math.min(100, base + ((requestId * 7) % spread));
// === STATYCZNA POWŁOKA (prerender) ===
function MissionHeader() {
return (
<header style={styles.header}>
<h1 style={styles.headerTitle}>Centrum Kontroli Misji</h1>
<nav style={styles.nav}>
<a href="#all" style={styles.navLink}>Wszystkie misje</a>
<a href="#active" style={{ ...styles.navLink, ...styles.navLinkActive }}>Aktywne</a>
<a href="#completed" style={styles.navLink}>Ukończone</a>
</nav>
</header>
);
}
function MissionSidebar() {
const filters = ['Eksploracyjne', 'Badawcze', 'Ratunkowe', 'Transportowe'];
return (
<aside style={styles.sidebar}>
<h3 style={{ color: '#00d4ff', marginTop: 0, fontSize: '16px' }}>Filtruj misje</h3>
{filters.map(filter => (
<label key={filter} style={styles.filterLabel}>
<input type="checkbox" style={{ accentColor: '#00d4ff' }} />
<span>{filter}</span>
</label>
))}
<div style={styles.staticBadge}>POWŁOKA STATYCZNA</div>
<p style={styles.meta}>Zbudowano o {BUILD_TIME}</p>
</aside>
);
}
// === DYNAMICZNE SEKCJE (streaming w granicach Suspense) ===
function StreamedBadge({ requestId, time }) {
return (
<span style={styles.dynamicBadge}>STREAMING - żądanie #{requestId}, {time}</span>
);
}
function ActiveMissionsWidget({ requestId }) {
const { data, time } = use(fetchForRequest('missions', requestId, 1500, id => [
{ id: 1, name: 'Eksploracja Mgławicy Oriona', progress: vary(70, id, 25) },
{ id: 2, name: 'Sonda Ciemnej Materii', progress: vary(40, id, 30) },
{ id: 3, name: 'Patrol Pasa Asteroid', progress: vary(85, id, 15) },
]));
return (
<section style={styles.panel}>
<div style={styles.panelHeader}>
<h3 style={styles.panelTitle}>Aktywne misje</h3>
<StreamedBadge requestId={requestId} time={time} />
</div>
<div style={styles.missionGrid}>
{data.map(m => (
<div key={m.id} style={styles.card}>
<h4 style={{ margin: '0 0 8px', fontSize: '14px' }}>{m.name}</h4>
<div style={styles.progressBar}>
<div style={{ ...styles.progressFill, width: m.progress + '%' }} />
</div>
<span style={{ color: '#00ff88', fontSize: '12px' }}>{m.progress}%</span>
</div>
))}
</div>
</section>
);
}
function CrewStatusWidget({ requestId }) {
const { data, time } = use(fetchForRequest('crew', requestId, 2200, id => [
{ name: 'Komandor Nova', location: 'Mostek', active: true },
{ name: 'Astro', location: 'Nawigacja', active: true },
{ name: 'Ra', location: 'Laboratorium', active: id % 2 === 0 },
]));
return (
<section style={styles.panel}>
<div style={styles.panelHeader}>
<h3 style={styles.panelTitle}>Status załogi</h3>
<StreamedBadge requestId={requestId} time={time} />
</div>
{data.map(c => (
<div key={c.name} style={styles.row}>
<span>{c.name}</span>
<span style={styles.meta}>{c.location}</span>
<span style={{ ...styles.dot, background: c.active ? '#00ff88' : '#ffa500' }} />
</div>
))}
</section>
);
}
function ResourcesWidget({ requestId }) {
const { data, time } = use(fetchForRequest('resources', requestId, 3000, id => [
{ name: 'Paliwo', level: vary(60, id, 30) },
{ name: 'Tlen', level: vary(85, id, 15) },
{ name: 'Energia', level: vary(70, id, 25) },
{ name: 'Woda', level: vary(50, id, 35) },
{ name: 'Żywność', level: vary(40, id, 40) },
]));
return (
<section style={styles.panel}>
<div style={styles.panelHeader}>
<h3 style={styles.panelTitle}>Zasoby statku</h3>
<StreamedBadge requestId={requestId} time={time} />
</div>
{data.map(r => (
<div key={r.name} style={styles.resource}>
<span style={{ width: '70px' }}>{r.name}</span>
<div style={styles.progressBar}>
<div style={{ ...styles.progressFill, width: r.level + '%', background: r.level < 50 ? '#ffa500' : '#00ff88' }} />
</div>
<span style={{ width: '40px', textAlign: 'right' }}>{r.level}%</span>
</div>
))}
</section>
);
}
function TelemetryReport({ requestId }) {
const { time } = use(fetchForRequest('telemetry', requestId, 3500, () => null));
return (
<section style={{ ...styles.panel, textAlign: 'center' }}>
<StreamedBadge requestId={requestId} time={time} />
<p style={{ color: '#64ffda', margin: '8px 0 0' }}>Analiza telemetrii zakończona - wszystkie systemy sprawne.</p>
</section>
);
}
function SkeletonCard({ lines = 3 }) {
return (
<div style={styles.panel}>
<div style={{ ...styles.skeletonLine, width: '50%', height: '16px' }} />
{Array.from({ length: lines }).map((_, i) => (
<div key={i} style={{ ...styles.skeletonLine, width: 85 - i * 12 + '%' }} />
))}
</div>
);
}
export default function App() {
const [requestId, setRequestId] = useState(1);
return (
<div style={styles.container}>
<MissionHeader />
<div style={styles.layout}>
<MissionSidebar />
<main key={requestId} style={styles.main}>
<div style={styles.toolbar}>
<button style={styles.button} onClick={() => setRequestId(id => id + 1)}>Nowe żądanie</button>
<span style={styles.meta}>Powłoka zostaje na miejscu, dane dochodzą od nowa (żądanie #{requestId})</span>
</div>
<Suspense fallback={<SkeletonCard lines={3} />}>
<ActiveMissionsWidget requestId={requestId} />
</Suspense>
<div style={styles.twoColumns}>
<Suspense fallback={<SkeletonCard lines={3} />}>
<CrewStatusWidget requestId={requestId} />
</Suspense>
<Suspense fallback={<SkeletonCard lines={5} />}>
<ResourcesWidget requestId={requestId} />
</Suspense>
</div>
<Suspense fallback={<SkeletonCard lines={1} />}>
<TelemetryReport requestId={requestId} />
</Suspense>
</main>
</div>
<style>{'@keyframes skeletonPulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.4; } }'}</style>
</div>
);
}
const styles = {
container: { minHeight: '100vh', background: 'linear-gradient(135deg, #0d1b2a 0%, #1a1a3e 100%)', color: '#e0e1dd', fontFamily: 'system-ui, sans-serif', fontSize: '13px' },
header: { padding: '16px 24px', borderBottom: '1px solid rgba(0,212,255,0.15)', background: 'rgba(0,0,0,0.2)' },
headerTitle: { color: '#00d4ff', margin: '0 0 10px', fontSize: '22px' },
nav: { display: 'flex', gap: '16px' },
navLink: { color: '#8892b0', textDecoration: 'none', fontSize: '14px', paddingBottom: '4px', borderBottom: '2px solid transparent' },
navLinkActive: { color: '#00d4ff', borderBottom: '2px solid #00d4ff' },
layout: { display: 'grid', gridTemplateColumns: '200px minmax(0, 1fr)' },
sidebar: { padding: '16px', borderRight: '1px solid rgba(0,212,255,0.1)', background: 'rgba(0,0,0,0.15)' },
filterLabel: { display: 'flex', alignItems: 'center', gap: '8px', padding: '6px 0', cursor: 'pointer' },
staticBadge: { display: 'inline-block', marginTop: '14px', padding: '3px 8px', background: 'rgba(0,212,255,0.15)', border: '1px solid rgba(0,212,255,0.3)', borderRadius: '4px', color: '#00d4ff', fontSize: '10px', fontWeight: 'bold' },
main: { padding: '16px', display: 'grid', gap: '12px', alignContent: 'start' },
toolbar: { display: 'flex', alignItems: 'center', gap: '10px', flexWrap: 'wrap' },
button: { padding: '6px 14px', background: '#00d4ff', color: '#0d1b2a', border: 'none', borderRadius: '6px', fontWeight: 'bold', cursor: 'pointer' },
meta: { color: '#8892b0', fontSize: '12px' },
panel: { background: 'rgba(0,0,0,0.3)', borderRadius: '12px', padding: '14px', border: '1px solid rgba(0,212,255,0.15)' },
panelHeader: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', gap: '8px', marginBottom: '10px', flexWrap: 'wrap' },
panelTitle: { color: '#00d4ff', margin: 0, fontSize: '15px' },
dynamicBadge: { display: 'inline-block', padding: '3px 8px', background: 'rgba(0,255,136,0.12)', border: '1px solid rgba(0,255,136,0.3)', borderRadius: '4px', color: '#00ff88', fontSize: '10px', fontWeight: 'bold' },
missionGrid: { display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(150px, 1fr))', gap: '10px' },
card: { padding: '12px', background: 'rgba(0,0,0,0.3)', borderRadius: '10px', border: '1px solid rgba(0,212,255,0.1)' },
progressBar: { flex: 1, height: '6px', background: 'rgba(255,255,255,0.1)', borderRadius: '3px', margin: '6px 0', overflow: 'hidden' },
progressFill: { height: '100%', background: 'linear-gradient(90deg, #00d4ff, #00ff88)' },
twoColumns: { display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))', gap: '12px' },
row: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', gap: '8px', padding: '8px', background: 'rgba(0,0,0,0.2)', borderRadius: '6px', marginBottom: '4px' },
dot: { width: '8px', height: '8px', borderRadius: '50%' },
resource: { display: 'flex', alignItems: 'center', gap: '8px', marginBottom: '6px' },
skeletonLine: { height: '12px', background: 'rgba(0,212,255,0.1)', borderRadius: '4px', marginBottom: '8px', animation: 'skeletonPulse 1.5s infinite' },
};Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Na czym polega Partial Pre-rendering (PPR)?
2. Które narzędzie z ekosystemu React służy do inspekcji drzewa komponentów i ich propsów/stanu w przeglądarce?
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj kroki procesu Server-Side Rendering i hydracji:
- Układanie w pionie
Uporządkuj kroki wdrażania funkcji współbieżnych (Concurrent React) w istniejącej aplikacji:
- Klikanie w kolejności
Ułóż deklarację i użycie hooka useId do połączenia label z input:
- Edytor kodu
Dokończ reducer centrum kontroli misji. Akcja launch startuje zaplanowaną misję, jeśli wystarczy paliwa. ___BLANK1___: nowa wartość paliwa to paliwo ze stanu pomniejszone o fuelCost startującej misji. ___BLANK2___: startująca misja staje się nowym obiektem ze wszystkimi polami starej i statusem 'w locie' (spread, bez zmieniania starego obiektu). ___BLANK3___: App tworzy stan i dispatch przez useReducer z missionReducer i initialState. Reducer nie może mutować stanu: zawsze zwraca nowe obiekty i tablice.
- Klikanie w kolejności
Ułóż kod użycia startTransition do oznaczenia aktualizacji jako niepilnej:
- Edytor kodu
Spraw, żeby mapa nawigacyjna reagowała płynnie mimo katalogu 3000 gwiazd. ___BLANK1___: deferredQuery to odroczona wersja query z useDeferredValue - pole tekstowe pokazuje wpisany tekst od razu, a lista filtruje się w tle (do tego czasu jest przygaszona, bo isStale jest true). ___BLANK2___: weź isPending i startTransition z hooka useTransition. ___BLANK3___: selectTab zmienia zakładkę przez startTransition(() => setTab(next)), więc w trakcie przełączania pojawia się komunikat z role="status".
- Układanie w pionie
Uporządkuj obsługę zdarzeń w React:
- Edytor kodu
Dokończ panel Core Web Vitals obserwatorium. Progi (web.dev): LCP dobrze do 2500 ms, wymaga poprawy do 4000 ms; INP dobrze do 200 ms, wymaga poprawy do 500 ms; CLS dobrze do 0.1, wymaga poprawy do 0.25; powyżej jest słabo (poor). ___BLANK1___: rateMetric zwraca needs-improvement, gdy wartość nie przekracza progu poor danego wskaźnika (granica też się liczy). ___BLANK2___: kolor ramki karty to kolor oceny z obiektu COLORS. ___BLANK3___: summarize zwiększa o 1 licznik kategorii, do której trafił wskaźnik. Dla pomiarów z sondy podsumowanie to: 1 dobrze, 1 wymaga poprawy, 1 słabo.
- Klikanie w kolejności
Ułóż komponent, który przez useDeferredValue odracza filtrowanie listy gwiazd i przygasza nieaktualny wynik:
- Edytor kodu
Zbuduj stronę misji w architekturze App Routera: MissionsPage to asynchroniczny Server Component, a MissionFilter to Client Component ze stanem. ___BLANK1___: MissionsPage czeka na dane z getMissions() (await). ___BLANK2___: przekaż listę misji do MissionFilter przez props missions. ___BLANK3___: gdy zaznaczone jest Tylko aktywne, filtr zostawia misje o statusie 'aktywna'. Server Component nie ma stanu ani obsługi zdarzeń - to wszystko jest w komponencie klienckim. Podgląd w edytorze udaje Next.js, więc strona pojawi się po ok. pół sekundy.
Zadania po tej lekcji
- PytaniePartial Pre-rendering (PPR)
- Ułóż w kolejnościProces SSR i hydracji
- Ułóż w kolejnościImplementacja Concurrent React
- Kliknij w kolejnościSkładnia useId dla dostępności
- Zadanie z kodemPraktyka: Złożony stan z useReducer
- Kliknij w kolejnościWzorzec użycia useTransition
- Zadanie z kodemPraktyka: Renderowanie współbieżne
- Ułóż w kolejnościObsługa zdarzeń w React
- Zadanie z kodemPraktyka: Obserwatorium wydajności
- Kliknij w kolejnościWzorzec useDeferredValue
- Zadanie z kodemPraktyka: Server i Client Components
- PytanieReact DevTools
- PytaniePlanowanie architektury produkcyjnej
- PytanieBudżetowanie wydajności