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

React 19.2 - Partial Pre-rendering (PPR)

12 min czytania ·
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ą HTML

prelude 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?

ScenariuszRekomendacja
Landing page z dynamicznym heroPPR
Dashboard z danymi na żywoPPR
E-commerce z cenami/dostępnościąPPR
Blog ze statyczną treściąPełny SSG
Aplikacja SPA bez SEOClient-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

  1. Najlepsze z dwóch światów - szybkość statycznego + świeżość dynamicznego
  2. Automatyczny podział - Next.js wyznacza powłokę na podstawie granic Suspense i danych
  3. Streaming HTML - użytkownik widzi treść stopniowo
  4. Suspense boundaries - kontrolujesz granularność dynamicznych części
  5. 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. 1. Na czym polega Partial Pre-rendering (PPR)?

  2. 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.

  1. PytaniePartial Pre-rendering (PPR)
  2. Ułóż w kolejnościProces SSR i hydracji
  3. Ułóż w kolejnościImplementacja Concurrent React
  4. Kliknij w kolejnościSkładnia useId dla dostępności
  5. Zadanie z kodemPraktyka: Złożony stan z useReducer
  6. Kliknij w kolejnościWzorzec użycia useTransition
  7. Zadanie z kodemPraktyka: Renderowanie współbieżne
  8. Ułóż w kolejnościObsługa zdarzeń w React
  9. Zadanie z kodemPraktyka: Obserwatorium wydajności
  10. Kliknij w kolejnościWzorzec useDeferredValue
  11. Zadanie z kodemPraktyka: Server i Client Components
  12. PytanieReact DevTools
  13. PytaniePlanowanie architektury produkcyjnej
  14. PytanieBudżetowanie wydajności

Przydatne artykuły