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

Streaming SSR i Edge Runtime

8 min czytania ·
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 tle

renderToPipeableStream - 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:

CechaNode.js RuntimeEdge Runtime
LokalizacjaJeden lub kilka regionówSerwery CDN na całym świecie
Zimny start (cold start)200-500ms (zimna funkcja serverless)1-5ms (izolat V8)
Rozmiar koduDuży limit (np. 250 MB na Vercel)1-4 MB po kompresji (Vercel, zależnie od planu)
APIPełne Node.js APIWeb APIs, bez systemu plików i modułów Node.js
StreamingrenderToPipeableStreamrenderToReadableStream
Bazy danychDowolneSterowniki 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:

  1. Streaming SSR - wysyła HTML fragmentami, użytkownik widzi stronę natychmiast
  2. renderToPipeableStream - API Node.js do streamingu
  3. renderToReadableStream - API Web Streams (Edge Runtime, Cloudflare Workers, Deno)
  4. Suspense boundaries - definiują granice streamingu, a Error Boundary nad nimi łapie błędy
  5. Edge Runtime - kod blisko użytkownika i szybki zimny start, ale w Next.js 16 domyślnym i zalecanym środowiskiem jest Node.js
  6. 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. 1. Jaka jest główna różnica między renderToPipeableStream a renderToReadableStream?

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

  1. PytanierenderToPipeableStream vs renderToReadableStream
  2. Ułóż w kolejnościStreaming SSR - kolejność zdarzeń
  3. PytanieEdge Runtime - charakterystyka
  4. Ułóż w kolejnościSkładnia ErrorBoundary z Suspense
  5. Kliknij w kolejnościSkładnia useSuspenseQuery z React Query

Przydatne artykuły