Kurs Next.js · Moduł 1: Konfiguracja Next.js

Narzędzia deweloperskie Next.js

6 min czytania ·
W tej lekcji7

W Metropolii Quantum każdy inżynier dysponuje zaawansowanym zestawem narzędzi diagnostycznych, które pozwalają w czasie rzeczywistym monitorować systemy miasta, wykrywać anomalie i optymalizować działanie infrastruktury. Podobnie, Next.js 16 oferuje programistom potężny zestaw narzędzi deweloperskich, które znacząco przyspieszają pracę i ułatwiają znajdowanie błędów.

Fast Refresh - natychmiastowe aktualizacje

Wyobraź sobie, że inżynierowie Metropolii Quantum mogą modyfikować systemy miasta i widzieć efekty zmian w ułamku sekundy, bez konieczności restartowania całej infrastruktury. Dokładnie tak działa Fast Refresh w Next.js.

Fast Refresh to mechanizm hot reload, który automatycznie aktualizuje podgląd aplikacji w przeglądarce po zapisaniu zmian w kodzie. Kluczowe cechy:

  • Zachowuje stan komponentów - jeśli edytujesz komponent React, Fast Refresh aktualizuje go bez resetowania stanu useState czy useReducer
  • Działa błyskawicznie - zmiany widoczne są w mniej niż sekundę
  • Obsługuje błędy składni - jeśli popełnisz błąd, po poprawce aplikacja wróci do normalnego stanu
// Edytujesz ten komponent i zapisujesz plik...
export default function Dashboard() {
  const [count, setCount] = useState(0);

  return (
    <div>
      <h1>Panel Quantum: {count}</h1>
      <button onClick={() => setCount(count + 1)}>+1</button>
    </div>
  );
}
// Fast Refresh aktualizuje komponent, ale count zachowuje swoją wartość!

Kiedy Fast Refresh resetuje stan? Jeśli edytujesz plik, który eksportuje coś innego niż komponent React (np. stałą, funkcję pomocniczą), Fast Refresh przeładuje cały moduł. To normalne zachowanie.

Error Overlay - czytelne komunikaty błędów

W centrum dowodzenia Metropolii Quantum każda anomalia jest natychmiast wyświetlana na ekranie głównym z dokładnym opisem problemu i lokalizacją. Next.js oferuje analogiczny mechanizm - Error Overlay.

Gdy w kodzie pojawi się błąd, Next.js wyświetla pełnoekranową nakładkę z:

  • Typem błędu - np. TypeError, SyntaxError, ReferenceError
  • Komunikatem błędu - czytelny opis problemu
  • Lokalizacją w kodzie - dokładny plik, linia i kolumna
  • Stosem wywołań (stack trace) - ścieżka wywołań prowadząca do błędu
// Jeśli napiszesz taki kod z błędem:
export default function Page() {
  const user = null;
  return <h1>{user.name}</h1>; // TypeError: Cannot read property 'name' of null
}

// Error Overlay pokaże:
// TypeError: Cannot read properties of null (reading 'name')
// app/page.tsx (3:22)

Error Overlay działa zarówno dla błędów czasu kompilacji (np. błędy składni TypeScript) jak i błędów czasu wykonania (np. odwołanie do niezdefiniowanej zmiennej). Wystarczy naprawić błąd i zapisać plik - overlay zniknie automatycznie.

Turbopack - nowy bundler Next.js

W Metropolii Quantum stary generator energii został zastąpiony nowym, znacznie wydajniejszym reaktorem kwantowym TurboCore. Podobnie w Next.js 16 Turbopack stał się domyślnym bundlerem i zastąpił Webpacka zarówno w next dev, jak i w next build.

Turbopack to bundler napisany w Rust, stworzony przez twórcę Webpacka. Jego główne zalety:

  • 2-5x szybsze buildy produkcyjne niż z Webpackiem - według zespołu Next.js przy wydaniu Next.js 16
  • Do 10x szybszy Fast Refresh (Hot Module Replacement, HMR)
  • Inkrementalna kompilacja - przetwarza tylko zmienione pliki

W Next.js 16 nie musisz niczego włączać - Turbopack działa od razu, a flagą --webpack wracasz do Webpacka:

# Tryb deweloperski i build produkcyjny - Turbopack domyślnie
npx next dev
npx next build

# Powrót do Webpacka, jeśli projekt tego wymaga
npx next dev --webpack

# Skrypty w package.json nie potrzebują już flagi --turbopack
{
  "scripts": {
    "dev": "next dev",
    "build": "next build"
  }
}

Od Next.js 16 Turbopack jest domyślny zarówno w trybie deweloperskim, jak i przy budowaniu produkcyjnym. W Next.js 15 był stabilny tylko dla next dev i trzeba go było włączać flagą --turbopack. Znacząco skraca czas ładowania strony podczas pracy nad aplikacją, szczególnie w dużych projektach.

React DevTools z Next.js

Każdy technik w Metropolii Quantum korzysta z zaawansowanego skanera do analizy systemów miasta. Dla programistów React odpowiednikiem jest rozszerzenie React DevTools.

React DevTools to rozszerzenie przeglądarki (Chrome, Firefox, Edge), które pozwala:

  • Przeglądać drzewo komponentów - widzisz hierarchię wszystkich komponentów React
  • Sprawdzać propsy i stan - podglądasz wartości props, useState, useContext
  • Profilować wydajność - mierzysz, które komponenty renderują się najdłużej
  • Podświetlać ponowne renderowania - widzisz wizualnie, które komponenty się przerenderowują
// React DevTools pokaże strukturę:
// <RootLayout>
//   <Navbar />
//   <MainContent>
//     <Dashboard count={5} />
//     <Sidebar items={[...]} />
//   </MainContent>
//   <Footer />
// </RootLayout>

W Next.js React DevTools automatycznie rozpoznają Server Components i Client Components, wyświetlając odpowiednie oznaczenia.

Podstawy debugowania w Next.js

Każdy inżynier Metropolii Quantum musi znać podstawowe narzędzia diagnostyczne. Oto kluczowe techniki debugowania w Next.js:

Console - terminal diagnostyczny

Najprostsze, ale bardzo skuteczne narzędzie. W Next.js console.log działa zarówno po stronie serwera (terminal) jak i klienta (DevTools przeglądarki):

// Server Component - logi widoczne w terminalu
export default async function Page() {
  console.log("Ten log pojawi się w terminalu serwera");
  const data = await getData();
  console.log("Pobrane dane:", data);
  return <div>{data.title}</div>;
}

// Client Component - logi widoczne w przeglądarce
"use client";
export default function Button() {
  console.log("Ten log pojawi się w konsoli przeglądarki");
  return <button onClick={() => console.log("Kliknięto!")}>Click</button>;
}

Network tab - monitoring transmisji

Zakładka Network w DevTools przeglądarki pozwala monitorować wszystkie żądania sieciowe:

  • Żądania API - widać URL, status, czas odpowiedzi
  • Zasoby statyczne - obrazy, CSS, JavaScript
  • Prefetching - Next.js automatycznie pobiera dane dla linków widocznych na ekranie

Konfiguracja next.config.js - przegląd

Plik next.config.js (lub next.config.mjs, a w projektach z create-next-app next.config.ts) to centralny punkt konfiguracji projektu Next.js, podobny do głównego panelu sterowania Metropolii Quantum. Oto najważniejsze opcje:

// next.config.js
/** @type {import('next').NextConfig} */
const nextConfig = {
  // Optymalizacja obrazów - dozwolone serwery zewnętrzne (images.domains jest przestarzałe)
  images: {
    remotePatterns: [
      { protocol: 'https', hostname: 'example.com' },
      { protocol: 'https', hostname: 'cdn.example.com' },
    ],
  },

  // Przekierowania URL
  async redirects() {
    return [
      {
        source: '/stary-adres',
        destination: '/nowy-adres',
        permanent: true,
      },
    ];
  },

  // Zmienne środowiskowe dostępne w kodzie
  env: {
    APP_VERSION: '1.0.0',
  },
};

module.exports = nextConfig;

Najczęściej używane opcje konfiguracyjne:

  • images - konfiguracja optymalizacji obrazów
  • redirects - przekierowania URL (np. po zmianie struktury strony)
  • env - dodatkowe zmienne środowiskowe
  • experimental - eksperymentalne funkcje Next.js

Podsumowanie

Narzędzia deweloperskie Next.js to jak zaawansowany system diagnostyczny Metropolii Quantum - pozwalają ci:

  1. Fast Refresh - natychmiast widzieć efekty zmian w kodzie bez utraty stanu
  2. Error Overlay - szybko lokalizować i naprawiać błędy dzięki czytelnym komunikatom
  3. Turbopack - pracować z błyskawiczną kompilacją dzięki nowemu bundlerowi napisanemu w Rust
  4. React DevTools - analizować strukturę komponentów, props i stan
  5. Console i Network tab - debugować aplikację po stronie serwera i klienta
  6. next.config.js - centralnie konfigurować zachowanie projektu

Znajomość tych narzędzi jest fundamentem efektywnej pracy z Next.js. W kolejnych modułach będziesz je regularnie wykorzystywać podczas budowania coraz bardziej zaawansowanych aplikacji w Metropolii Quantum.

Kod do tej lekcji: App.tsx
import React, { useState } from 'react';

// Symulacja narzędzi deweloperskich Next.js
const DevToolsDemo = () => {
  const [activeTab, setActiveTab] = useState('fast-refresh');
  const [code, setCode] = useState('<h1>Witaj w Quantum!</h1>');
  const [logs, setLogs] = useState<string[]>([]);
  const [error, setError] = useState<string | null>(null);

  const tabs = [
    { id: 'fast-refresh', label: 'Fast Refresh' },
    { id: 'error-overlay', label: 'Error Overlay' },
    { id: 'console', label: 'Konsola' },
  ];

  const simulateFastRefresh = () => {
    setLogs(prev => [...prev, '[Fast Refresh] Zmiana wykryta, aktualizacja...']);
    setTimeout(() => {
      setLogs(prev => [...prev, '[Fast Refresh] Komponent zaktualizowany (12ms)']);
      setLogs(prev => [...prev, '[Fast Refresh] Stan komponentu zachowany']);
    }, 300);
  };

  const simulateError = () => {
    setError('TypeError: Cannot read properties of null (reading "name")\n  at DashboardPage (app/page.tsx:5:18)');
    setLogs(prev => [...prev, '[Error] Wykryto błąd w komponencie']);
  };

  const fixError = () => {
    setError(null);
    setLogs(prev => [...prev, '[Fast Refresh] Błąd naprawiony, nakładka zamknięta']);
  };

  const addConsoleLog = (type: string) => {
    const messages: Record<string, string> = {
      server: '[Server] console.log: Dane pobrane z API (145ms)',
      client: '[Browser] console.log: Komponent zamontowany',
      network: '[Network] GET /api/data -> 200 OK (89ms)',
    };
    setLogs(prev => [...prev, messages[type] || '[Log] Akcja wykonana']);
  };

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#fff', fontFamily: 'monospace' }}>
      <h1 style={{ color: '#64ffda', textAlign: 'center', marginBottom: '20px' }}>
        Narzędzia deweloperskie Next.js - Quantum Lab
      </h1>

      <div style={{ display: 'flex', gap: '8px', justifyContent: 'center', marginBottom: '20px' }}>
        {tabs.map(tab => (
          <button key={tab.id} onClick={() => { setActiveTab(tab.id); setError(null); }}
            style={{ padding: '8px 16px', background: activeTab === tab.id ? '#7c4dff' : 'rgba(255,255,255,0.1)',
              border: 'none', borderRadius: '6px', color: '#fff', cursor: 'pointer' }}>
            {tab.label}
          </button>
        ))}
      </div>

      <div style={{ maxWidth: '800px', margin: '0 auto' }}>
        {activeTab === 'fast-refresh' && (
          <div>
            <div style={{ background: '#1a1a2e', padding: '16px', borderRadius: '8px', marginBottom: '12px' }}>
              <p style={{ color: '#888', marginBottom: '8px' }}>Edytor kodu (symulacja):</p>
              <textarea value={code} onChange={(e) => setCode(e.target.value)}
                style={{ width: '100%', background: '#0d1117', color: '#64ffda', border: '1px solid #333',
                  borderRadius: '4px', padding: '12px', fontFamily: 'monospace', fontSize: '14px', minHeight: '60px' }} />
            </div>
            <button onClick={simulateFastRefresh}
              style={{ padding: '10px 24px', background: '#4caf50', border: 'none', borderRadius: '6px',
                color: '#fff', cursor: 'pointer', marginBottom: '12px' }}>
              Zapisz plik (Ctrl+S)
            </button>
            <div style={{ background: '#000', padding: '12px', borderRadius: '8px', marginTop: '8px', border: '1px solid #333' }}>
              <p style={{ color: '#888', marginBottom: '4px' }}>Podgląd:</p>
              <div dangerouslySetInnerHTML={{ __html: code }} style={{ color: '#64ffda' }} />
            </div>
          </div>
        )}

        {activeTab === 'error-overlay' && (
          <div>
            {error ? (
              <div style={{ background: 'rgba(244,67,54,0.15)', border: '2px solid #f44336', borderRadius: '8px', padding: '20px' }}>
                <h3 style={{ color: '#f44336', marginBottom: '12px' }}>Unhandled Runtime Error</h3>
                <pre style={{ color: '#ff8a80', whiteSpace: 'pre-wrap', marginBottom: '16px' }}>{error}</pre>
                <button onClick={fixError}
                  style={{ padding: '8px 20px', background: '#4caf50', border: 'none', borderRadius: '6px',
                    color: '#fff', cursor: 'pointer' }}>
                  Napraw błąd
                </button>
              </div>
            ) : (
              <div style={{ textAlign: 'center' }}>
                <p style={{ color: '#4caf50', marginBottom: '16px' }}>Brak błędów</p>
                <button onClick={simulateError}
                  style={{ padding: '10px 24px', background: '#f44336', border: 'none', borderRadius: '6px',
                    color: '#fff', cursor: 'pointer' }}>
                  Symuluj błąd
                </button>
              </div>
            )}
          </div>
        )}

        {activeTab === 'console' && (
          <div>
            <div style={{ display: 'flex', gap: '8px', marginBottom: '12px' }}>
              <button onClick={() => addConsoleLog('server')}
                style={{ padding: '8px 16px', background: '#1a73e8', border: 'none', borderRadius: '6px', color: '#fff', cursor: 'pointer' }}>
                Log serwera
              </button>
              <button onClick={() => addConsoleLog('client')}
                style={{ padding: '8px 16px', background: '#ff9800', border: 'none', borderRadius: '6px', color: '#fff', cursor: 'pointer' }}>
                Log klienta
              </button>
              <button onClick={() => addConsoleLog('network')}
                style={{ padding: '8px 16px', background: '#0f9d58', border: 'none', borderRadius: '6px', color: '#fff', cursor: 'pointer' }}>
                Sieć
              </button>
              <button onClick={() => setLogs([])}
                style={{ padding: '8px 16px', background: 'rgba(255,0,0,0.2)', border: 'none', borderRadius: '6px', color: '#f44336', cursor: 'pointer' }}>
                Wyczyść
              </button>
            </div>
          </div>
        )}

        <div style={{ background: '#000', borderRadius: '8px', padding: '12px', marginTop: '16px', minHeight: '150px', maxHeight: '250px', overflowY: 'auto' }}>
          <p style={{ color: '#555', marginBottom: '8px' }}>Logi:</p>
          {logs.length === 0 ? (
            <p style={{ color: '#333', textAlign: 'center', paddingTop: '40px' }}>Brak logów...</p>
          ) : (
            logs.map((log, i) => (
              <div key={i} style={{ padding: '2px 0', fontSize: '13px',
                color: log.includes('Error') ? '#f44336' : log.includes('Server') ? '#1a73e8' : log.includes('Network') ? '#0f9d58' : '#ccc' }}>
                {log}
              </div>
            ))
          )}
        </div>
      </div>
    </div>
  );
};

export default DevToolsDemo;

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. Co robi mechanizm Fast Refresh w Next.js?

  2. 2. Czym jest Turbopack w Next.js 16?

  1. PytanieMechanizm Fast Refresh
  2. PytanieTurbopack w Next.js

Przydatne artykuły