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

Turbopack i optymalizacja kompilacji

11 min czytania ·
W tej lekcji14

W sercu Metropolii Quantum działa potężny generator energii o nazwie TurboCore, który zasila całe miasto znacznie efektywniej niż przestarzałe reaktory. Podobnie w świecie Next.js pojawił się nowy silnik bundlowania - Turbopack - który w Next.js 16 stał się domyślnym bundlerem i rewolucjonizuje szybkość kompilacji aplikacji internetowych.

Czym jest Turbopack?

Turbopack to nowoczesny bundler napisany w języku Rust, stworzony przez autorów Next.js i Webpacka. Został zaprojektowany z myślą o maksymalnej wydajności i skalowalności, szczególnie dla dużych aplikacji.

W przeciwieństwie do starszych narzędzi, Turbopack:

  • Kompiluje tylko wymagane elementy, a nie całą aplikację
  • Wykorzystuje inteligentne buforowanie, aby uniknąć niepotrzebnych rekalkulacji
  • Działa znacznie szybciej niż Webpack, szczególnie w trybie deweloperskim

Turbopack w projekcie Next.js 16 - domyślnie włączony

W Metropolii Quantum nowe budynki są od razu podłączone do sieci energetycznej TurboCore, a do starej sieci przełącza się je jednym przełącznikiem. Podobnie w Next.js 16 Turbopack działa od razu i nie potrzebuje żadnej flagi:

# Serwer deweloperski - Turbopack domyślnie
npx next dev

# Powrót do Webpacka (tylko gdy projekt tego wymaga)
npx next dev --webpack

W pliku package.json skrypty nie potrzebują już flagi --turbo ani --turbopack, którymi w Next.js 15 włączało się Turbopack:

{
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start"
  }
}

Wtedy po prostu uruchamiasz:

npm run dev
# lub
yarn dev

Zalety Turbopacka

1. Błyskawiczne czasy kompilacji

Podobnie jak TurboCore w Metropolii Quantum dostarcza energię niemal natychmiastowo, Turbopack drastycznie skraca czas kompilacji:

  • 2-5x szybsze buildy produkcyjne (next build) - według zespołu Next.js przy wydaniu Next.js 16
  • Do 10x szybszy Fast Refresh (HMR) przy zmianach komponentów
  • Cache na dysku - od Next.js 16.1 dla next dev, a od 16.3 także dla next build, dzięki czemu ponowne uruchomienia są jeszcze szybsze

2. Selektywna kompilacja i inteligentne buforowanie

Turbopack analizuje strukturę zależności aplikacji i kompiluje tylko te części, które są rzeczywiście potrzebne. To jak inteligentny system energetyczny w Metropolii, który kieruje energię tylko tam, gdzie jest aktualnie wymagana.

// Turbopack skompiluje tylko ten komponent i jego zależności,
// jeśli jest aktualnie używany w aplikacji
export default function QuantumNavigation() {
  return (
    <div className="p-4 bg-gradient-to-r from-indigo-500 to-purple-600 rounded-lg">
      <h2 className="text-xl font-semibold text-white">System Nawigacji Quantum</h2>
      <p className="text-white/80">
        Wybierz destynację w układzie słonecznym
      </p>
      {/* ... */}
    </div>
  );
}

3. Kompilacja przyrostowa

Przy zmianach kodu Turbopack rekompiluje tylko pliki, które zostały zmienione, i te, które są od nich bezpośrednio zależne. Tak samo w Metropolii Quantum modernizacja jednego systemu nie wymaga restartu całego miasta.

Kompatybilność z Next.js 16

W Next.js 16 Turbopack jest stabilny i domyślny zarówno dla next dev, jak i dla next build. W Next.js 15 stabilny był tylko tryb deweloperski, a budowanie produkcyjne dostało wersję beta dopiero w Next.js 15.5. Oto funkcje, które są wspierane:

  • app Directory (App Router)
  • Kompatybilność z narzędziami deweloperskimi (HMR, Fast Refresh)
  • Obsługa import aliases i jsconfig.json/tsconfig.json
  • Obsługa zmiennych środowiskowych (.env)
  • Obsługa CSS Modules i Global CSS
  • Obsługa Tailwind CSS
  • Proxy (proxy.ts, w starszych wersjach middleware.ts)
  • Wsparcie dla API Routes
  • Obsługa Sass, PostCSS i React Server Components

Turbopack nie obsługuje natomiast pluginów Webpacka ani funkcji webpack() w next.config: projekty, które ich potrzebują, uruchamiasz z flagą --webpack.

Benchmarking i wydajność - dane TurboCore Metropolii

Podobnie jak inżynierowie w Metropolii Quantum przeprowadzają testy wydajności nowego systemu TurboCore, możemy zmierzyć wydajność Turbopacka w naszym projekcie. Poniższe liczby są przykładowe: rzeczywisty zysk zależy od projektu, dlatego zawsze mierz go na własnej aplikacji.

OperacjaWebpackTurbopackPoprawa
Cold start40s2.2s~18x szybciej
Rebuild (komponent)180ms15ms~12x szybciej
Rebuild (strona)300ms25ms~12x szybciej
Rebuild (CSS)160ms10ms~16x szybciej

Ciekawostka z Metropolii Quantum: W Metropolii Quantum system TurboCore zmniejszył zużycie energii o 94% przy jednoczesnym zwiększeniu wydajności o 1200%.

Optymalizacja Turbopacka i rozwiązywanie problemów

Diagnostyka wydajności Turbopacka

Turbopack posiada wbudowane narzędzia diagnostyczne. Jeśli kompilacja zwalnia, zapisz ślad (trace) działania bundlera:

# Zapisz ślad działania Turbopacka podczas pracy serwera deweloperskiego
npm run dev -- --internal-trace

# Po zatrzymaniu serwera otwórz zapisany plik w przeglądarce śladów
npx next internal trace .next-profiles/trace-turbopack.bin

Zobaczysz wtedy dokładne informacje o tym, co dzieje się podczas kompilacji, podobnie jak diagnostyka energetyczna w Metropolii Quantum. Drugie polecenie uruchamia lokalny serwer śladów, a sam wykres oglądasz na stronie trace.nextjs.org.

Analiza rozmiaru bundla

Aby monitorować rozmiar bundla, w Next.js 16 masz dwa narzędzia. Przy Turbopacku, czyli domyślnym bundlerze, użyj wbudowanego analizatora, dostępnego eksperymentalnie od Next.js 16.1:

npx next experimental-analyze

Otworzy się interaktywny widok modułów, w którym filtrujesz trasy i sprawdzasz, dlaczego dany moduł trafił do paczki. Klasyczna wtyczka @next/bundle-analyzer działa natomiast tylko z Webpackiem:

npm install --save-dev @next/bundle-analyzer

Konfiguracja w next.config.js:

const withBundleAnalyzer = require('@next/bundle-analyzer')({
  enabled: process.env.ANALYZE === 'true',
});

/** @type {import('next').NextConfig} */
const nextConfig = {
  // Inne opcje konfiguracji...
};

module.exports = withBundleAnalyzer(nextConfig);

Uruchomienie analizy:

ANALYZE=true npx next build --webpack

Flaga --webpack jest tu konieczna: bez niej next build użyje Turbopacka, wykryje konfigurację Webpacka dodaną przez wtyczkę i zakończy się błędem.

Typowe problemy z Turbopackiem i ich rozwiązania

ProblemRozwiązanie
Brak wsparcia dla niektórych loaderów WebpackaSkonfiguruj loader w opcji turbopack.rules w next.config albo sprawdź w dokumentacji Turbopacka, czy istnieje alternatywa
Pluginy Webpacka (Turbopack ich nie obsługuje)Poszukaj alternatywy zgodnej z Turbopackiem albo uruchom next dev i next build z flagą --webpack
Problemy z HMR w dużych projektachPodziel kod na mniejsze moduły i używaj leniwego ładowania

Strategie optymalizacji kompilacji poza Turbopackiem

Nawet jeśli używasz Turbopacka, istnieją dodatkowe strategie optymalizacji kompilacji w Next.js 16:

1. Code Splitting i lazy loading

Podobnie jak w Metropolii Quantum dystrybuuje się zasoby w miarę potrzeb, możesz użyć leniwego ładowania komponentów w Next.js 16:

// components/MapaGalaktykiLazy.tsx
"use client";

import dynamic from 'next/dynamic';

// Leniwe ładowanie komponentu mapy, który może być ciężki
const InteraktywnaMapaGalaktyki = dynamic(
  () => import('@/components/InteraktywnaMapaGalaktyki'),
  {
    loading: () => <div className="h-96 bg-gray-200 animate-pulse rounded-lg" />,
    ssr: false, // Wyłączenie SSR działa tylko w Client Component
  }
);

export default InteraktywnaMapaGalaktyki;

Strona zostaje Server Componentem i importuje gotowy, leniwie ładowany komponent (ssr: false wpisane w Server Component kończy się błędem kompilacji):

// app/eksploracja/page.tsx
import { Suspense } from 'react';
import InteraktywnaMapaGalaktyki from '@/components/MapaGalaktykiLazy';

export default function StronaEksploracji() {
  return (
    <div className="container mx-auto py-8">
      <h1 className="text-3xl font-bold mb-6">Eksploracja Galaktyki</h1>

      <div className="prose max-w-none mb-8">
        <p>Wybierz swoją destynację w naszej interaktywnej mapie galaktyki...</p>
      </div>

      <Suspense fallback={<div className="h-96 bg-gray-200 animate-pulse rounded-lg" />}>
        <InteraktywnaMapaGalaktyki />
      </Suspense>
    </div>
  );
}

2. Optymalizacja importów

W Metropolii Quantum transportery energii są zoptymalizowane tak, aby przenosić energię najkrótszą możliwą drogą. Podobnie, możesz zoptymalizować importy w swoim kodzie:

// Zły import - importuje cały lodash
import _ from 'lodash';

// Też zły import - pakiet lodash (CommonJS) i tak trafia do paczki w całości
import { debounce, throttle } from 'lodash';

// Dobry import - importuje konkretne funkcje z podmodułów
import debounce from 'lodash/debounce';
import throttle from 'lodash/throttle';

3. Mikrofrontendy i modułowa budowa aplikacji

Podobnie jak Metropolia Quantum jest podzielona na autonomiczne sektory, które można ulepszać niezależnie, możesz rozważyć podejście modułowe:

quantum-voyages/
  ├── main/               # Główna aplikacja Next.js
  ├── modules/
  │   ├── bookings/       # Moduł rezerwacji (niezależna aplikacja)
  │   ├── destinations/   # Moduł destynacji (niezależna aplikacja)
  │   └── profiles/       # Moduł profili użytkowników (niezależna aplikacja)
  └── shared/
      └── ui-components/  # Współdzielone komponenty interfejsu użytkownika

4. Optymalizacja obrazów i zasobów statycznych

Podobnie jak Metropolia Quantum optymalizuje przesył danych wizualnych, możesz zoptymalizować swoje obrazy:

// Użycie zoptymalizowanego komponentu Image z Next.js
import Image from 'next/image';

export default function GaleriaDestynacji() {
  return (
    <div className="grid grid-cols-3 gap-4">
      <div className="relative h-48">
        <Image
          src="/images/mars-colony.jpg"
          alt="Kolonia na Marsie"
          fill
          sizes="(max-width: 768px) 100vw, (max-width: 1200px) 50vw, 33vw"
          className="object-cover rounded-lg"
          loading="lazy"
        />
      </div>
      {/* ... więcej obrazów ... */}
    </div>
  );
}

Monitorowanie wydajności kompilacji

Podobnie jak inżynierowie w Metropolii Quantum nieustannie monitorują wydajność systemu TurboCore, możesz monitorować wydajność swojej kompilacji. W Next.js 16 nie musisz niczego włączać: next dev przy każdym żądaniu pokazuje w terminalu czas kompilacji (Compile) i renderowania (Render), a next build podaje czas każdego etapu budowania:

npm run build

# Przykładowy wynik w Next.js 16:
#    ▲ Next.js 16 (Turbopack)
#  ✓ Compiled successfully in 615ms
#  ✓ Finished TypeScript in 1114ms
#  ✓ Collecting page data in 208ms
#  ✓ Generating static pages in 239ms
#  ✓ Finalizing page optimization in 5ms

Dla bardziej zaawansowanego monitorowania możesz użyć wtyczek do narzędzi CI/CD, które śledzą czasy budowania w każdej iteracji.

Turbopack - przyszłość

Podobnie jak TurboCore w Metropolii Quantum przechodzi nieustanne ulepszenia, Turbopack jest aktywnie rozwijany z myślą o przyszłości:

  • Pełne wsparcie dla wszystkich funkcji Next.js
  • Rozszerzony ekosystem wtyczek i loaderów
  • Większa kompatybilność z istniejącymi narzędziami i bibliotekami
  • Jeszcze szybsze czasy kompilacji i mniejsze zużycie pamięci

Kiedy NIE używać Turbopacka?

Mimo wszystkich zalet, czasami TurboCore w Metropolii Quantum nie jest używany w niektórych starszych sektorach miasta ze względu na problemy z kompatybilnością. Podobnie, są sytuacje, kiedy lepiej pozostać przy Webpacku:

  • Gdy używasz wtyczek lub loaderów Webpacka, które nie są jeszcze obsługiwane przez Turbopack
  • Gdy twoja aplikacja ma specyficzną konfigurację budowania, która nie jest wspierana przez Turbopack
  • Gdy next.config zawiera własną funkcję webpack(): w Next.js 16 next build z taką konfiguracją kończy się błędem, dopóki nie przeniesiesz jej na opcje Turbopacka albo nie dodasz flagi --webpack

Narzędzia deweloperskie i wtyczki przyspieszające pracę

Tak jak inżynierowie Metropolii Quantum używają zaawansowanych narzędzi do pracy z TurboCore, tak my również możemy usprawnić nasz workflow:

  • VSCode Extension dla Next.js: Podpowiedzi, nawigacja i podświetlanie składni
  • ESLint: Natychmiastowa informacja zwrotna o potencjalnych problemach
  • TypeScript: Wykrywanie błędów na etapie kompilacji
  • Prettier: Automatyczne formatowanie kodu

Praktyki projektowe wspierające wydajną kompilację

Struktura Metropolii Quantum

Architekci Metropolii Quantum zaprojektowali miasto w sposób modułowy - tak samo możemy zaprojektować naszą aplikację:

  1. Zorganizuj kod według funkcjonalności:
app/
  ├── (auth)/               # Grupowanie logiczne dla funkcji autoryzacji
  │   ├── login/
  │   └── register/
  ├── (main)/               # Główna funkcjonalność
  │   ├── dashboard/
  │   └── settings/
  └── (bookings)/           # Funkcjonalność rezerwacji
      ├── destinations/
      └── checkout/
  1. Projektuj komponenty z myślą o wydajności:
// components/ui/QuantumButton.tsx
import { ButtonHTMLAttributes, forwardRef } from 'react';
import { cva, type VariantProps } from 'class-variance-authority';

// Definiowanie wariantów przycisków z Tailwind CSS
const buttonVariants = cva(
  "relative inline-flex items-center justify-center rounded-md text-sm font-medium transition-colors",
  {
    variants: {
      variant: {
        default: "bg-blue-600 text-white hover:bg-blue-700",
        destructive: "bg-red-600 text-white hover:bg-red-700",
        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
        ghost: "hover:bg-accent hover:text-accent-foreground",
        link: "text-primary underline-offset-4 hover:underline",
      },
      size: {
        default: "h-10 px-4 py-2",
        sm: "h-9 rounded-md px-3",
        lg: "h-11 rounded-md px-8",
        icon: "h-10 w-10",
      },
    },
    defaultVariants: {
      variant: "default",
      size: "default",
    },
  }
);

export interface ButtonProps
  extends ButtonHTMLAttributes<HTMLButtonElement>,
    VariantProps<typeof buttonVariants> {}

const QuantumButton = forwardRef<HTMLButtonElement, ButtonProps>(
  ({ className, variant, size, ...props }, ref) => {
    return (
      <button
        className={buttonVariants({ variant, size, className })}
        ref={ref}
        {...props}
      />
    );
  }
);
QuantumButton.displayName = "QuantumButton";

export { QuantumButton, buttonVariants };

Praktyczny przykład przyspieszenia kompilacji projektu Quantum Voyages

Wyobraźmy sobie, że mamy duży projekt Quantum Voyages z wieloma komponentami i stronami, który kompiluje się wolno. Tak go zoptymalizujemy:

  1. Upewnimy się, że działa Turbopack - w Next.js 16 jest domyślny, więc wystarczy uruchomić serwer bez flagi --webpack:
npm run dev
  1. Zoptymalizujemy importy:
// components/ui/Dashboard.tsx

// Przed optymalizacją
import _ from 'lodash';

// Po optymalizacji - importujemy tylko potrzebną funkcję
import debounce from 'lodash/debounce';
  1. Leniwe ładowanie ciężkich komponentów:
// components/maps/QuantumMap3DLazy.tsx - Client Component
"use client";

import dynamic from 'next/dynamic';

// Ciężki komponent mapy 3D ładowany leniwie
const QuantumMap3D = dynamic(() => import('@/components/maps/QuantumMap3D'), {
  loading: () => <p>Ładowanie mapy kwantowej...</p>,
  ssr: false,
});

export default QuantumMap3D;

Strona app/destinations/page.tsx zostaje Server Componentem i tylko importuje QuantumMap3DLazy.

  1. Modularyzacja aplikacji:
// Podziel duże pliki na mniejsze, skupione na konkretnych zadaniach
// bookings/BookingForm.tsx -> podzielony na:
// - bookings/components/PassengerDetails.tsx
// - bookings/components/DestinationPicker.tsx
// - bookings/components/DateSelection.tsx
// - bookings/components/PaymentForm.tsx

Podsumowanie

Tak jak TurboCore zrewolucjonizował dostarczanie energii w Metropolii Quantum, Turbopack zmienia sposób, w jaki kompilujemy aplikacje Next.js 16. Dzięki niemu:

  1. Znacznie przyspieszasz cykl deweloperski
  2. Oszczędzasz zasoby dzięki selektywnej kompilacji
  3. Zyskujesz wydajniejszą aplikację dzięki nowoczesnym technikom optymalizacji
  4. Przygotowujesz swoją aplikację na przyszłe innowacje w ekosystemie Next.js

W kolejnym rozdziale przyjrzymy się konfiguracji środowiska deweloperskiego i praktykom, które pozwolą ci maksymalnie efektywnie pracować z Next.js 16 - niczym inżynier Metropolii Quantum kontrolujący rozległe systemy miasta z jednego terminala.

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. Turbopack jest w Next.js 16 domyślnym bundlerem. Jaką flagę dodajesz do polecenia next dev, aby zamiast niego użyć Webpacka?

  2. 2. Której funkcji z next/dynamic używamy do leniwego ładowania ciężkiego komponentu?

  3. 3. Który sposób importu jest najlepszy dla rozmiaru bundla?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Ułóż polecenie, które uruchamia serwer deweloperski z Webpackiem zamiast domyślnego Turbopacka

  1. PytanieFlaga powrotu do Webpacka
  2. Kliknij w kolejnościUruchomienie z Webpackiem
  3. PytanieLeniwe ładowanie komponentu
  4. PytanieOptymalizacja importów

Przydatne artykuły