Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React
Streaming SSR i Edge Runtime
W tej lekcji8
Wyobraź sobie, że zamiast wysyłać cały statek kosmiczny jednym transportem, wysyłasz go moduł po module - kokpit natychmiast, a systemy nawigacyjne i ładownie dolatują w tle. Dokładnie tak działa Streaming SSR - serwer zaczyna wysyłać HTML do przeglądarki jeszcze zanim cały rendering zostanie ukończony. A Edge Runtime przenosi ten proces bliżej użytkownika - jak stacje przekaźnikowe rozmieszczone po całej galaktyce.
Tradycyjny SSR vs Streaming SSR
Tradycyjny SSR generuje cały HTML na serwerze, zanim wyśle go do przeglądarki. Użytkownik czeka na najwolniejszy komponent:
// Tradycyjny SSR - użytkownik czeka na WSZYSTKO
// Serwer: [renderuj Header][renderuj Dane][renderuj Footer] -> wyślij całość
// Czas: 500ms + 2000ms + 100ms = 2600ms zanim cokolwiek zobaczy
// Streaming SSR - fragmenty wysyłane natychmiast
// Serwer: [Header gotowy] -> wyślij! [Dane gotowe] -> wyślij! [Footer] -> wyślij!
// Czas: 500ms do pierwszego fragmentu, reszta dochodzi w tlerenderToPipeableStream - API streamingu
React 18 wprowadził renderToPipeableStream, strumieniowego następcę renderToString, który musiał wyrenderować całą stronę przed wysłaniem pierwszego bajtu:
import { renderToPipeableStream } from 'react-dom/server';
// Serwer Node.js z Streaming SSR
app.get('/', (req, res) => {
const { pipe } = renderToPipeableStream(
<App />,
{
bootstrapScripts: ['/main.js'],
onShellReady() {
// Powłoka (shell) gotowa - wyślij natychmiast
res.setHeader('Content-Type', 'text/html');
pipe(res);
},
onShellError(error) {
// Błąd w krytycznej części - wyślij fallback
res.statusCode = 500;
res.send('<h1>Server Error</h1>');
},
onAllReady() {
// Wszystko gotowe (przydatne dla crawlerów/SEO)
},
onError(error) {
console.error('Streaming error:', error);
}
}
);
});onShellReady jest wywoływany gdy główna "powłoka" strony jest gotowa - czyli wszystko poza granicami <Suspense>. Użytkownik widzi szkielet strony natychmiast.
renderToReadableStream - Edge Runtime API
Dla Edge Runtime (Cloudflare Workers, Vercel Edge, Deno Deploy) używamy renderToReadableStream, które zwraca Web Streams API:
import { renderToReadableStream } from 'react-dom/server';
// Edge Runtime handler
export default async function handler(request) {
const stream = await renderToReadableStream(
<App />,
{
bootstrapScripts: ['/main.js'],
onError(error) {
console.error('Edge streaming error:', error);
}
}
);
return new Response(stream, {
headers: { 'Content-Type': 'text/html' },
});
}Różnica między API:
renderToPipeableStream- Node.js Streams (Node.js runtime)renderToReadableStream- Web Streams API (Edge Runtime, Deno, przeglądarki)
Od React 19.2 renderToReadableStream działa też w Node.js, ale zespół Reacta nadal zaleca tam renderToPipeableStream: strumienie Node.js są w Node szybsze, a Web Streams domyślnie nie obsługują kompresji.
Suspense jako granica streamingu
<Suspense> definiuje granice streamingu - serwer wysyła fallback i później podmienia go na gotowy HTML:
function SpaceStationDashboard() {
return (
<div>
{/* Renderowane natychmiast - część "shell" */}
<Header title="Stacja Kosmiczna Alpha" />
<Navigation />
{/* Każda sekcja streamuje się niezależnie */}
<Suspense fallback={<Skeleton type="missions" />}>
<MissionList /> {/* Dane ładują 800ms */}
</Suspense>
<Suspense fallback={<Skeleton type="crew" />}>
<CrewStatus /> {/* Dane ładują 1500ms */}
</Suspense>
<Suspense fallback={<Skeleton type="telemetry" />}>
<TelemetryData /> {/* Dane ładują 2200ms */}
</Suspense>
</div>
);
}
// Przebieg streamingu:
// 1. [0ms] Serwer wysyła: Header + Navigation + 3x Skeleton
// 2. [800ms] Serwer dosyła: MissionList (podmienia Skeleton)
// 3. [1500ms] Serwer dosyła: CrewStatus (podmienia Skeleton)
// 4. [2200ms] Serwer dosyła: TelemetryData (podmienia Skeleton)Błędy i dane w granicach Suspense
Suspense obsługuje tylko czekanie na dane. Jeśli pobieranie się nie uda, komponent rzuci błąd, a ten złapie najbliższy Error Boundary. Dlatego wolną sekcję owija się w dwie warstwy: Error Boundary na zewnątrz i Suspense w środku. Dane w takim komponencie wygodnie pobierzesz hookiem useSuspenseQuery z TanStack Query, który zawiesza komponent do chwili nadejścia danych:
import { Suspense } from 'react';
import { ErrorBoundary } from 'react-error-boundary';
import { useSuspenseQuery } from '@tanstack/react-query';
function MissionList() {
// data jest zawsze zdefiniowane: ładowanie obsługuje Suspense, a błędy Error Boundary
const { data } = useSuspenseQuery({ queryKey: ['missions'], queryFn: fetchMissions });
return (
<ul>
{data.map(mission => (
<li key={mission.id}>{mission.name}</li>
))}
</ul>
);
}
function MissionsSection() {
return (
<ErrorBoundary fallback={<MissionsError />}>
<Suspense fallback={<Skeleton type="missions" />}>
<MissionList />
</Suspense>
</ErrorBoundary>
);
}Podczas ładowania widać szkielet z Suspense, a gdy zapytanie się nie powiedzie, ErrorBoundary z pakietu react-error-boundary pokaże MissionsError w miejscu całej sekcji. Na serwerze działa to podobnie: jeśli komponent wewnątrz granicy Suspense rzuci błąd w trakcie streamingu, React nie przerywa odpowiedzi, tylko wysyła fallback tej granicy i ponawia renderowanie już w przeglądarce. Dopiero gdy i tam się nie uda, błąd trafia do najbliższego Error Boundary. Błąd w samej powłoce, poza wszystkimi granicami, wywołuje onShellError.
Edge Runtime - obliczenia bliżej użytkownika
Edge Runtime to lekkie środowisko wykonawcze działające na "krawędzi" sieci (edge), czyli na serwerach CDN rozsianych po całym świecie, blisko użytkownika. Zamiast pełnego Node.js uruchamia kod w izolatach silnika V8 (tego samego, który wykonuje JavaScript w Chrome) i daje mu Web APIs: fetch, Request, Response i Web Streams. Izolat startuje mniej więcej sto razy szybciej niż proces Node.js, dlatego zimny start trwa tu zaledwie kilka milisekund. Tak wygląda strumieniowanie Reacta w Cloudflare Workers:
// worker.jsx - Cloudflare Workers (izolaty V8, Web APIs zamiast Node.js)
import { renderToReadableStream } from 'react-dom/server';
import App from './App';
export default {
async fetch(request) {
// Cloudflare dołącza do żądania dane o lokalizacji użytkownika
const city = request.cf?.city ?? 'nieznane miasto';
const stream = await renderToReadableStream(<App city={city} />, {
bootstrapScripts: ['/main.js'],
});
return new Response(stream, {
headers: { 'Content-Type': 'text/html; charset=utf-8' },
});
},
};Worker nie ma dostępu do systemu plików ani modułów Node.js, za to odpowiada z serwera najbliższego użytkownikowi. Lokalizację dostarcza tu platforma przez request.cf, a nie React. W Next.js obiekt request.geo zniknął w wersji 15, a na Vercel miasto odczytasz funkcją geolocation() z pakietu @vercel/functions.
Różnice: Node.js vs Edge Runtime
Tabela pokazuje, czym płacisz za błyskawiczny start na brzegu sieci. Czasy zimnego startu są orientacyjne i zależą od platformy:
| Cecha | Node.js Runtime | Edge Runtime |
|---|---|---|
| Lokalizacja | Jeden lub kilka regionów | Serwery CDN na całym świecie |
| Zimny start (cold start) | 200-500ms (zimna funkcja serverless) | 1-5ms (izolat V8) |
| Rozmiar kodu | Duży limit (np. 250 MB na Vercel) | 1-4 MB po kompresji (Vercel, zależnie od planu) |
| API | Pełne Node.js API | Web APIs, bez systemu plików i modułów Node.js |
| Streaming | renderToPipeableStream | renderToReadableStream |
| Bazy danych | Dowolne | Sterowniki działające przez HTTP (np. Turso, Neon) |
Edge Runtime w Next.js 16
Przewaga szybkiego startu maleje, bo platformy skracają też zimny start Node.js. Fluid compute na Vercel przechowuje skompilowany bajtkod i rozgrzewa funkcje w produkcji, dlatego Vercel zaleca dziś przenoszenie funkcji z Edge na Node.js. Next.js poszedł tą samą drogą: w wersji 16 plik middleware.ts zmienił nazwę na proxy.ts i działa zawsze na Node.js, a w wersji 16.3 eksport runtime = 'edge' w plikach stron i route handlerów stał się przestarzały. Next.js ostrzega przy nim i radzi go usunąć, bo domyślny Node.js nie wymaga żadnej konfiguracji, a Vercel uruchamia takie trasy na Node.js:
// proxy.js (Next.js 16, dawniej middleware.js) - zawsze Node.js runtime
import { NextResponse } from 'next/server';
export function proxy(request) {
const isDashboard = request.nextUrl.pathname.startsWith('/dashboard');
// Bez sesji przekieruj na logowanie, zanim strona zacznie się renderować
if (isDashboard && !request.cookies.has('session')) {
return NextResponse.redirect(new URL('/login', request.url));
}
return NextResponse.next();
}Proxy uruchamia się przed renderowaniem każdej trasy, więc w prawdziwym projekcie zawęź go opcją matcher w obiekcie config. Edge Runtime nie znika jednak z ekosystemu: zostaje naturalnym środowiskiem platform zbudowanych na izolatach, jak Cloudflare Workers czy Deno Deploy, a renderToReadableStream działa tam bez zmian.
Progressive Hydration
Streaming SSR naturalnie wspiera progressive hydration - React hydruje komponenty w miarę ich pojawiania się:
// Schemat progressive hydration:
// 1. Serwer streamuje HTML -> przeglądarka wyświetla
// 2. JavaScript się ładuje
// 3. React hydruje komponenty które już są w DOM
// 4. Nowe fragmenty HTML przychodzą ze streamu
// 5. React hydruje je natychmiast po otrzymaniu
// Selective hydration - React priorytetyzuje
// komponenty z którymi użytkownik interaguje:
function App() {
return (
<div>
{/* Użytkownik kliknął tu - React hydruje to PIERWSZE */}
<Suspense fallback={<Skeleton />}>
<InteractivePanel />
</Suspense>
{/* To czeka w kolejce */}
<Suspense fallback={<Skeleton />}>
<HeavyDataTable />
</Suspense>
</div>
);
}Podsumowanie
Streaming SSR i Edge Runtime to potężne narzędzia przyspieszające dostarczanie aplikacji:
- Streaming SSR - wysyła HTML fragmentami, użytkownik widzi stronę natychmiast
- renderToPipeableStream - API Node.js do streamingu
- renderToReadableStream - API Web Streams (Edge Runtime, Cloudflare Workers, Deno)
- Suspense boundaries - definiują granice streamingu, a Error Boundary nad nimi łapie błędy
- Edge Runtime - kod blisko użytkownika i szybki zimny start, ale w Next.js 16 domyślnym i zalecanym środowiskiem jest Node.js
- Progressive Hydration - React hydruje komponenty w miarę ich pojawiania się
Streaming SSR zmienia dostarczanie aplikacji jak systemy modułowe na stacji kosmicznej - każdy moduł startuje niezależnie, użytkownik nie czeka na całość. W przykładzie poniżej sekcje dopływają w kolejności gotowości danych, a po zaznaczeniu awarii przekaźnika i wysłaniu nowego żądania zobaczysz, jak Error Boundary łapie błąd jednej sekcji, a reszta strony działa dalej.
Kod do tej lekcji: App.jsx
import { Component, Suspense, use, useCallback, useEffect, useState } from 'react';
// === STREAMING SSR - symulacja w przeglądarce ===
// Shell (nagłówek i układ) pojawia się od razu, a każda granica Suspense
// pokazuje szkielet, dopóki jej dane nie dotrą. Sekcje przychodzą w kolejności
// gotowości danych, a nie w kolejności na stronie.
const DATA = {
missions: [
{ id: 1, name: 'Ekspedycja na Marsa', status: 'aktywna', eta: '47 dni' },
{ id: 2, name: 'Sonda Europa', status: 'planowana', eta: '182 dni' },
{ id: 3, name: 'Baza Księżycowa', status: 'zakończona', eta: '-' },
],
crew: [
{ id: 1, name: 'Komandor Nova', role: 'Dowódca', ready: true },
{ id: 2, name: 'Astro', role: 'Nawigator', ready: true },
{ id: 3, name: 'Ra', role: 'Przewodnik', ready: false },
],
telemetry: [
{ label: 'Tlen', value: 96 },
{ label: 'Paliwo', value: 78 },
{ label: 'Kadłub', value: 99 },
{ label: 'Łączność', value: 87 },
],
earth: 'Centrum Ziemia potwierdza kurs. Powodzenia, załogo!',
};
const DELAYS = { missions: 600, earth: 900, crew: 1200, telemetry: 2000 };
// Jedna obietnica na sekcję w danym żądaniu. Ta sama obietnica przy kolejnym
// renderze pozwala hookowi use() odczytać gotowe dane.
const requests = new Map();
// Moment startu bieżącego żądania (do osi czasu)
let requestStart = performance.now();
function loadSection(section, requestKey, fail = false) {
const key = section + ':' + requestKey;
if (!requests.has(key)) {
requests.set(key, new Promise((resolve, reject) => {
setTimeout(() => {
if (fail) reject(new Error('Brak sygnału z przekaźnika na orbicie'));
else resolve(DATA[section]);
}, DELAYS[section]);
}));
}
return requests.get(key);
}
// Error Boundary: łapie błąd rzucony podczas renderowania sekcji
class RelayBoundary extends Component {
constructor(props) {
super(props);
this.state = { error: null };
}
static getDerivedStateFromError(error) {
return { error };
}
componentDidCatch(error) {
this.props.onError(error.message);
}
render() {
if (this.state.error) {
return (
<div style={styles.errorBox}>
<strong>Łączność przerwana</strong>
<p style={{ margin: '4px 0 8px' }}>{this.state.error.message}</p>
<button
style={styles.smallButton}
onClick={() => {
this.props.onRetry();
this.setState({ error: null });
}}
>
Spróbuj ponownie
</button>
</div>
);
}
return this.props.children;
}
}
function Skeleton({ label }) {
return (
<div style={styles.skeleton}>
<div style={styles.shimmer} />
<p style={styles.skeletonLabel}>Czekam na sekcję: {label}...</p>
</div>
);
}
function MissionPanel({ requestId, onReady }) {
const missions = use(loadSection('missions', requestId));
useEffect(() => {
onReady('Misje', '#00ff88');
}, [onReady]);
return (
<div style={styles.panel}>
<h3 style={styles.panelTitle}>Misje (600 ms)</h3>
{missions.map(m => (
<div key={m.id} style={styles.item}>
<span style={styles.badge}>{m.status}</span>
<strong>{m.name}</strong>
<span style={styles.muted}>ETA: {m.eta}</span>
</div>
))}
</div>
);
}
function CrewPanel({ requestId, onReady }) {
const crew = use(loadSection('crew', requestId));
useEffect(() => {
onReady('Załoga', '#ffaa00');
}, [onReady]);
return (
<div style={styles.panel}>
<h3 style={styles.panelTitle}>Załoga (1200 ms)</h3>
{crew.map(c => (
<div key={c.id} style={styles.item}>
<span style={{ ...styles.dot, background: c.ready ? '#00ff88' : '#ff6b6b' }} />
<strong>{c.name}</strong>
<span style={styles.muted}>{c.role}</span>
</div>
))}
</div>
);
}
function TelemetryPanel({ requestId, onReady }) {
const telemetry = use(loadSection('telemetry', requestId));
useEffect(() => {
onReady('Telemetria', '#ff6b6b');
}, [onReady]);
return (
<div style={styles.panel}>
<h3 style={styles.panelTitle}>Telemetria (2000 ms)</h3>
<div style={styles.telGrid}>
{telemetry.map(t => (
<div key={t.label} style={styles.telItem}>
<span style={styles.telLabel}>{t.label}</span>
<div style={styles.bar}>
<div style={{ ...styles.barFill, width: t.value + '%' }} />
</div>
<span>{t.value}%</span>
</div>
))}
</div>
</div>
);
}
function EarthPanel({ requestKey, fail, label, onReady }) {
const message = use(loadSection('earth', requestKey, fail));
useEffect(() => {
onReady(label, '#00d4ff');
}, [onReady, label]);
return (
<div style={styles.panel}>
<h3 style={styles.panelTitle}>Łączność z Ziemią (900 ms)</h3>
<p style={{ margin: 0, fontSize: '12px' }}>{message}</p>
</div>
);
}
export default function App() {
const [request, setRequest] = useState({ id: 1, fail: false });
const [failNext, setFailNext] = useState(false);
const [attempt, setAttempt] = useState(0);
const [events, setEvents] = useState([{ label: 'Shell (nagłówek i układ)', ms: 0, color: '#8892b0' }]);
// Sekcja zgłasza się po wyrenderowaniu, więc oś czasu pokazuje prawdziwą kolejność
const report = useCallback((label, color) => {
const ms = Math.round(performance.now() - requestStart);
setEvents(prev => (prev.some(e => e.label === label) ? prev : [...prev, { label, ms, color }]));
}, []);
const reportError = useCallback(message => {
report('Błąd łączności: ' + message, '#ff6b6b');
}, [report]);
const startRequest = () => {
requestStart = performance.now();
setAttempt(0);
setEvents([{ label: 'Shell (nagłówek i układ)', ms: 0, color: '#8892b0' }]);
setRequest(r => ({ id: r.id + 1, fail: failNext }));
};
const earthFails = request.fail && attempt === 0;
const earthLabel = attempt === 0 ? 'Łączność z Ziemią' : 'Łączność z Ziemią (ponowna próba)';
return (
<div style={styles.container}>
<header style={styles.header}>
<h1 style={styles.title}>Streaming SSR - symulacja</h1>
<p style={styles.subtitle}>
Shell pojawia się od razu, a każda granica Suspense dosyła swoją sekcję, gdy dane są gotowe
</p>
<div style={styles.toolbar}>
<button style={styles.button} onClick={startRequest}>Nowe żądanie</button>
<label style={styles.checkbox}>
<input type="checkbox" checked={failNext} onChange={e => setFailNext(e.target.checked)} />
Awaria przekaźnika w następnym żądaniu
</label>
</div>
</header>
<section style={styles.shell}>
<h2 style={{ color: '#00d4ff', margin: 0, fontSize: '16px' }}>Stacja Alpha - Dashboard (żądanie #{request.id})</h2>
<p style={{ color: '#8892b0', margin: '2px 0 0', fontSize: '11px' }}>Shell: wysłany natychmiast (0 ms)</p>
</section>
<div style={styles.mainGrid}>
<div key={request.id} style={styles.grid}>
<Suspense fallback={<Skeleton label="Misje" />}>
<MissionPanel requestId={request.id} onReady={report} />
</Suspense>
<RelayBoundary onError={reportError} onRetry={() => setAttempt(a => a + 1)}>
<Suspense fallback={<Skeleton label="Łączność z Ziemią" />}>
<EarthPanel
requestKey={request.id + '-' + attempt}
fail={earthFails}
label={earthLabel}
onReady={report}
/>
</Suspense>
</RelayBoundary>
<Suspense fallback={<Skeleton label="Załoga" />}>
<CrewPanel requestId={request.id} onReady={report} />
</Suspense>
<Suspense fallback={<Skeleton label="Telemetria" />}>
<TelemetryPanel requestId={request.id} onReady={report} />
</Suspense>
</div>
<aside style={styles.timeline}>
<h3 style={styles.panelTitle}>Kolejność streamingu</h3>
{events.map(e => (
<div key={e.label} style={styles.timelineItem}>
<span style={{ ...styles.dot, background: e.color }} />
<span style={styles.time}>{e.ms} ms</span>
<span>{e.label}</span>
</div>
))}
</aside>
</div>
</div>
);
}
const styles = {
container: { fontFamily: 'system-ui, sans-serif', background: '#0a0e17', color: '#e0e1dd', minHeight: '100vh', padding: '14px' },
header: { textAlign: 'center', marginBottom: '12px' },
title: { fontSize: '20px', color: '#00d4ff', margin: '0 0 4px' },
subtitle: { fontSize: '12px', color: '#8892b0', margin: '0 0 10px' },
toolbar: { display: 'flex', gap: '12px', justifyContent: 'center', alignItems: 'center', flexWrap: 'wrap' },
button: { padding: '6px 14px', background: '#00d4ff', color: '#0a0e17', border: 'none', borderRadius: '6px', fontWeight: 'bold', cursor: 'pointer' },
smallButton: { padding: '4px 10px', background: 'transparent', color: '#ff6b6b', border: '1px solid #ff6b6b', borderRadius: '6px', cursor: 'pointer', fontSize: '11px' },
checkbox: { display: 'flex', alignItems: 'center', gap: '6px', fontSize: '12px', color: '#8892b0' },
shell: { background: 'rgba(0,212,255,0.08)', border: '1px solid rgba(0,212,255,0.2)', borderRadius: '8px', padding: '10px 12px', marginBottom: '12px' },
mainGrid: { display: 'grid', gridTemplateColumns: 'minmax(0, 1fr) 210px', gap: '12px' },
grid: { display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))', gap: '10px', alignContent: 'start' },
panel: { background: 'rgba(0,212,255,0.05)', borderRadius: '8px', padding: '12px', border: '1px solid rgba(0,212,255,0.15)' },
panelTitle: { fontSize: '13px', color: '#00d4ff', margin: '0 0 8px' },
item: { display: 'flex', alignItems: 'center', gap: '6px', padding: '5px 8px', background: 'rgba(0,0,0,0.3)', borderRadius: '4px', marginBottom: '4px', fontSize: '11px' },
badge: { padding: '1px 6px', borderRadius: '6px', fontSize: '9px', background: 'rgba(0,255,136,0.15)', color: '#00ff88' },
muted: { marginLeft: 'auto', color: '#8892b0', fontSize: '10px' },
dot: { width: '8px', height: '8px', borderRadius: '50%', flexShrink: 0, display: 'inline-block' },
skeleton: { minHeight: '110px', background: 'rgba(0,212,255,0.03)', border: '1px dashed rgba(0,212,255,0.2)', borderRadius: '8px', display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center' },
shimmer: { width: '50%', height: '8px', background: 'rgba(0,212,255,0.12)', borderRadius: '4px', marginBottom: '6px' },
skeletonLabel: { color: '#8892b0', fontSize: '11px', margin: 0 },
errorBox: { minHeight: '110px', background: 'rgba(255,107,107,0.08)', border: '1px solid rgba(255,107,107,0.4)', borderRadius: '8px', padding: '12px', fontSize: '12px', color: '#ffb3b3' },
telGrid: { display: 'grid', gap: '6px' },
telItem: { display: 'flex', alignItems: 'center', gap: '6px', fontSize: '11px' },
telLabel: { color: '#8892b0', width: '60px' },
bar: { flex: 1, height: '8px', background: 'rgba(255,255,255,0.08)', borderRadius: '4px', overflow: 'hidden' },
barFill: { height: '100%', background: 'linear-gradient(90deg, #00d4ff, #00ff88)' },
timeline: { background: 'rgba(0,212,255,0.05)', borderRadius: '8px', padding: '12px', border: '1px solid rgba(0,212,255,0.15)', alignSelf: 'start' },
timelineItem: { display: 'flex', alignItems: 'center', gap: '6px', marginBottom: '8px', fontSize: '11px' },
time: { color: '#8892b0', width: '48px', textAlign: 'right', flexShrink: 0 },
};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. Jaka jest główna różnica między renderToPipeableStream a renderToReadableStream?
2. Która cecha jest GŁÓWNĄ zaletą Edge Runtime w porównaniu do tradycyjnego Node.js?
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj etapy Streaming SSR od pierwszego do ostatniego:
- Układanie w poziomie
Ułóż opakowywanie komponentu w ErrorBoundary + Suspense od lewej do prawej:
- Klikanie w kolejności
Ułóż składnię useSuspenseQuery z TanStack React Query: