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

Struktura katalogów i plików w Next.js (app/ vs pages/)

11 min czytania ·
W tej lekcji9

W Metropolii Quantum inżynierowie projektują zaawansowane systemy transportu, które mogą działać zarówno na klasycznych drogach, jak i na nowych szlakach kwantowej teleportacji. Podobnie, Next.js oferuje dwa równoległe systemy routingu: tradycyjny Pages Router i nowoczesny App Router. W tym module szczegółowo przeanalizujemy różnice między tymi dwoma podejściami i zrozumiemy, jak organizować pliki i katalogi w naszych projektach.

Dwie filozofie routingu w Next.js

Next.js pierwotnie korzystał z routingu opartego na plikach w folderze pages/. W Next.js 13 wprowadzono nowy system routingu oparty na folderze app/. Ta ewolucja przypomina przejście od klasycznych systemów transportu do kwantowej teleportacji w Metropolii Quantum - nowa technologia jest bardziej zaawansowana, ale obie nadal współistnieją.

Pages Router: Klasyczne podejście

Pages Router to oryginalny system routingu w Next.js. Jest prosty, dobrze udokumentowany i nadal szeroko używany. W tej konwencji każdy plik JavaScript lub TypeScript w katalogu pages/ automatycznie staje się ścieżką w aplikacji.

pages/
├── index.js                # Trasa: /
├── about.js                # Trasa: /about
├── contact.tsx             # Trasa: /contact
├── products/
│   ├── index.js            # Trasa: /products
│   └── [id].js             # Trasa: /products/:id (dynamiczna)
└── api/
    └── hello.js            # Endpoint API: /api/hello

W tym systemie:

  • Pliki bezpośrednio mapują się na ścieżki URL
  • Dynamiczne segmenty ścieżki są oznaczane nawiasami kwadratowymi [param]
  • Specjalny katalog api/ służy do obsługi endpointów API
  • Każdy plik eksportuje domyślnie komponent React lub funkcję obsługi API

App Router: Nowoczesne podejście

App Router, wprowadzony w Next.js 13 i dopracowany w wersji 15, reprezentuje nowe podejście oparte na React Server Components. Jest to jak przejście od tradycyjnych pojazdów do teleportacji kwantowej - fundamentalna zmiana w sposobie myślenia o aplikacjach webowych.

app/
├── layout.tsx              # Główny układ (wymagany)
├── page.tsx                # Trasa: /
├── about/
│   └── page.tsx            # Trasa: /about
├── blog/
│   ├── page.tsx            # Trasa: /blog
│   ├── layout.tsx          # Układ specyficzny dla /blog i jego podścieżek
│   └── [slug]/
│       └── page.tsx        # Trasa: /blog/:slug (dynamiczna)
└── api/
    └── users/
        └── route.ts        # Endpoint API: /api/users

W App Routerze:

  • Tylko katalogi definiują ścieżki, a specjalne pliki wewnątrz tych katalogów pełnią konkretne funkcje
  • Plik page.tsx renderuje komponent strony dla danej ścieżki
  • Plik layout.tsx definiuje współdzielony układ dla wszystkich stron w katalogu i jego podkatalogach
  • Dynamiczne segmenty nadal używają nawiasów kwadratowych: [param]
  • Endpointy API są tworzone przy użyciu plików route.ts

Nazewnictwo plików i konwencje w App Routerze

App Router wprowadza "konwencję ponad konfiguracją" z szeregiem specjalnych plików, które mają określone role. Jest to jak wyspecjalizowane moduły w systemach Metropolii Quantum - każdy z określoną funkcją w ogólnej architekturze.

Podstawowe pliki specjalne:

  1. page.tsx: Renderuje interfejs użytkownika trasy i sprawia, że ścieżka jest publicznie dostępna.

    // app/dashboard/page.tsx
    export default function DashboardPage() {
      return (
        <section>
          <h1>Panel kontrolny Metropolii Quantum</h1>
          <p>Witaj w centrum dowodzenia!</p>
        </section>
      );
    }
  2. layout.tsx: Definiuje współdzielony interfejs dla segmentu i jego dzieci.

    // app/dashboard/layout.tsx
    export default function DashboardLayout({
      children,
    }: {
      children: React.ReactNode;
    }) {
      return (
        <div className="dashboard-layout">
          <nav className="dashboard-sidebar">
            {/* Nawigacja panelu bocznego */}
          </nav>
          <main className="dashboard-main">{children}</main>
        </div>
      );
    }
  3. route.ts: Tworzy endpoint API przy użyciu nowego API obsługi żądań.

    // app/api/status/route.ts
    import { NextResponse } from 'next/server';
    
    export async function GET() {
      return NextResponse.json({
        status: 'online',
        systemsOperational: 15,
        time: new Date().toISOString()
      });
    }
    
    export async function POST(request: Request) {
      const data = await request.json();
      // Przetwarzanie danych...
      return NextResponse.json({ success: true });
    }
  4. loading.tsx: Tworzy interfejs ładowania z React Suspense.

    // app/dashboard/loading.tsx
    export default function DashboardLoading() {
      return (
        <div className="dashboard-loading">
          <div className="spinner"></div>
          <p>Ładowanie danych systemowych Metropolii...</p>
        </div>
      );
    }
  5. error.tsx: Tworzy interfejs obsługi błędów z React Error Boundary.

    'use client'; // Komponenty obsługi błędów muszą być komponentami klienckimi
    
    import { useEffect } from 'react';
    
    export default function DashboardError({
      error,
      reset,
    }: {
      error: Error;
      reset: () => void;
    }) {
      useEffect(() => {
        // Logowanie błędu do systemu monitorowania
        console.error(error);
      }, [error]);
    
      return (
        <div className="error-container">
          <h2>Wystąpił błąd w systemach Metropolii!</h2>
          <p>{error.message}</p>
          <button onClick={reset}>Spróbuj ponownie</button>
        </div>
      );
    }
  6. not-found.tsx: Tworzy interfejs dla nieznalezionego zasobu (404).

    // app/not-found.tsx
    export default function NotFound() {
      return (
        <div className="not-found">
          <h2>Strefa nieznana</h2>
          <p>Nie znaleziono modułu Metropolii Quantum o takim identyfikatorze.</p>
          <a href="/">Powrót do centrum dowodzenia</a>
        </div>
      );
    }

Zaawansowane funkcje App Routera

App Router wprowadza kilka zaawansowanych funkcji organizacyjnych, które przypominają zaawansowane systemy transportu w Metropolii Quantum - pozwalają na bardziej skomplikowane i elastyczne trasy.

1. Grupy tras (Route Groups)

Grupy tras pozwalają na organizowanie plików bez wpływania na strukturę URL. Są oznaczane przez ujęcie nazwy katalogu w nawiasy: (nazwa-grupy).

app/
├── (marketing)/        # Grupa tras (nie wpływa na ścieżkę URL)
│   ├── about/
│   │   └── page.tsx    # Trasa: /about
│   └── contact/
│       └── page.tsx    # Trasa: /contact
└── (dashboard)/        # Inna grupa tras
    ├── layout.tsx      # Współdzielony układ dla tras dashboard
    ├── page.tsx        # Trasa: /
    └── stats/
        └── page.tsx    # Trasa: /stats

Grupy tras są jak dzielnice w Metropolii Quantum - pomagają organizować strukturę miasta, ale nie wpływają na adresy.

2. Trasy równoległe (Parallel Routes)

Trasy równoległe pozwalają na równoczesne renderowanie wielu stron w tym samym widoku, co jest przydatne dla złożonych układów. Są oznaczane przez nazwę slotu ze znakiem "@": @nazwa-slotu.

app/
├── layout.tsx          # Główny układ
├── page.tsx            # Główna strona
└── dashboard/
    ├── layout.tsx      # Układ z wieloma slotami
    │   // layout.tsx definiuje sloty {children, @stats, @notifications}
    ├── page.tsx        # Domyślna zawartość dla slotu głównego
    ├── @stats/
    │   ├── page.tsx    # Zawartość dla slotu @stats
    │   └── default.tsx # Wymagany w Next.js 16 (np. zwraca null)
    └── @notifications/
        ├── page.tsx    # Zawartość dla slotu @notifications
        └── default.tsx # Wymagany w Next.js 16 (np. zwraca null)

W Next.js 16 każdy slot musi mieć plik default.tsx (np. zwracający null albo wywołujący notFound()), inaczej next build zakończy się błędem.

// app/dashboard/layout.tsx
export default function DashboardLayout({
  children,
  stats,
  notifications,
}: {
  children: React.ReactNode;
  stats: React.ReactNode;
  notifications: React.ReactNode;
}) {
  return (
    <div className="dashboard-grid">
      <main>{children}</main>
      <aside className="stats-panel">{stats}</aside>
      <section className="notifications-panel">{notifications}</section>
    </div>
  );
}

Trasy równoległe to jak równoległe wymiary w Metropolii Quantum - różne rzeczywistości dostępne jednocześnie.

3. Przechwytujące trasy (Intercepting Routes)

Pozwalają na "przechwycenie" trasy i wyświetlenie jej inaczej, co jest idealne dla modali, które zachowują kontekst nawigacji. Są oznaczane przez nazwę segmentu ze znakiem "(.)": (.)nazwa, (..)nazwa lub (...)nazwa.

app/
├── layout.tsx
├── page.tsx            # Trasa: /
└── dashboard/
    ├── layout.tsx
    ├── page.tsx        # Trasa: /dashboard
    └── projects/
        ├── layout.tsx       # Renderuje {children} i {modal}
        ├── page.tsx         # Trasa: /dashboard/projects
        ├── [id]/
        │   └── page.tsx     # Trasa: /dashboard/projects/:id
        ├── create/
        │   └── page.tsx     # Trasa: /dashboard/projects/create (pełna strona)
        └── @modal/
            ├── default.tsx  # Zwraca null, gdy modal jest zamknięty
            └── (.)create/
                └── page.tsx # Modal nad listą przy przejściu linkiem

Przy przejściu linkiem z listy Next.js pokaże przechwyconą stronę w slocie @modal nad listą, a po odświeżeniu lub wejściu bezpośrednio z adresu wyświetli pełną stronę create/page.tsx.

Przechwytujące trasy są jak kwantowe skróty w Metropolii Quantum - pozwalają na szybki dostęp do zasobów bez zmiany kontekstu.

Organizacja kodu w Next.js 16

Oprócz struktury routingu Next.js 16 sugeruje określone sposoby organizacji kodu. Jest to jak planowanie dzielnic w Metropolii Quantum - właściwa organizacja zwiększa efektywność i czytelność.

Współdzielone komponenty i zasoby

Komponenty, które są używane w wielu miejscach, powinny być zorganizowane w spójny sposób. Oto zalecana struktura:

src/
├── app/                 # Aplikacja z App Routerem
│   ├── layout.tsx
│   └── page.tsx
├── components/          # Współdzielone komponenty
│   ├── ui/              # Podstawowe komponenty UI
│   │   ├── Button.tsx
│   │   └── Card.tsx
│   └── features/        # Komponenty specyficzne dla funkcji
│       ├── dashboard/
│       └── auth/
├── lib/                 # Współdzielone funkcje i klasy
│   ├── api/
│   └── utils/
├── hooks/               # Niestandardowe hooki React
│   ├── useAuth.ts
│   └── useLocalStorage.ts
└── styles/              # Style globalne
    └── globals.css

Co-location vs. Centralizacja

Next.js 16 i App Router wspierają podejście "co-location", gdzie pliki związane z konkretną trasą są umieszczane blisko siebie. Jest to jak mikrodystrykty w Metropolii Quantum - wszystko, czego potrzebujesz, jest blisko.

app/
└── dashboard/
    ├── page.tsx
    ├── loading.tsx       # Ładowanie dla tej trasy
    ├── error.tsx         # Obsługa błędów dla tej trasy
    ├── layout.tsx        # Układ dla tej trasy
    ├── actions.ts        # Server Actions dla tej trasy
    ├── components/       # Komponenty specyficzne dla tej trasy
    │   ├── StatusCard.tsx
    │   └── DashboardNav.tsx
    └── styles/           # Style specyficzne dla tej trasy
        └── dashboard.module.css

Porównanie App Routera i Pages Routera

Teraz, gdy poznaliśmy oba systemy routingu, porównajmy je - podobnie jak inżynierowie Metropolii Quantum mogliby porównywać klasyczny transport z teleportacją kwantową.

Renderowanie

  1. Pages Router:

    • Domyślnie każda strona jest prerenderowana do HTML (automatyczna optymalizacja statyczna), a w przeglądarce hydratowana
    • SSR i SSG dostępne przez getServerSideProps i getStaticProps
    • Stosunkowo proste modele danych
  2. App Router:

    • Domyślnie Server Components
    • Wybór między Server i Client Components
    • Bardziej zaawansowany model przepływu danych
    • Streaming renderowania

W Pages Routerze dane strony pobiera funkcja eksportowana obok komponentu, np. getStaticProps, którą Next.js wywołuje raz, podczas budowania:

// pages/posts.js (Pages Router)
export async function getStaticProps() {
  const posts = await getPosts();
  return { props: { posts } };
}

Funkcja getServerSideProps ma tę samą budowę, ale Next.js wywołuje ją przy każdym żądaniu.

Stany ładowania

  1. Pages Router:

    • Ręczne zarządzanie stanami ładowania
    • Często wykorzystuje zewnętrzne biblioteki
  2. App Router:

    • Wbudowane komponenty loading.tsx
    • Integracja z React Suspense
    • Automatyczne wskaźniki ładowania

Obsługa błędów

  1. Pages Router:

    • Ręczne zarządzanie błędami
    • Ogólny komponent dla błędów 500
  2. App Router:

    • Komponenty error.tsx z granularną obsługą błędów
    • Integracja z React Error Boundary
    • Możliwość naprawy/ponowienia po błędzie

Układy

  1. Pages Router:

    • Ręczne tworzenie układów z komponentem _app.js
    • Jeden układ dla całej aplikacji
    • Zagnieżdżone układy wymagają dodatkowej pracy
  2. App Router:

    • Wbudowany system układów poprzez layout.tsx
    • Możliwość tworzenia zagnieżdżonych układów
    • Współdzielenie układów jest proste i intuicyjne

Kiedy używać którego systemu routingu?

Wybór między App Routerem a Pages Routerem przypomina wybór między kwantową teleportacją a tradycyjnym transportem w Metropolii Quantum - zależy od konkretnych potrzeb.

Używaj App Routera, gdy:

  • Tworzysz nowy projekt od podstaw
  • Chcesz korzystać z najnowszych funkcji React i Next.js
  • Potrzebujesz zaawansowanych możliwości układu i organizacji
  • Zależy Ci na lepszej wydajności i strumieniowym renderowaniu (streamingu)
  • Chcesz korzystać z React Server Components

Używaj Pages Routera, gdy:

  • Masz istniejący projekt oparty na Pages Routerze
  • Potrzebujesz prostszego modelu mentalnego
  • Używasz bibliotek, które nie są jeszcze kompatybilne z App Routerem
  • Chcesz używać gotowych wzorców i rozwiązań

Migracja z Pages Routera do App Routera

Jeśli masz istniejący projekt używający Pages Routera, możesz stopniowo migrować do App Routera. Jest to jak modernizacja dzielnic w Metropolii Quantum - nie musisz przebudowywać wszystkiego naraz.

Next.js 16 pozwala na współistnienie obu systemów. Możesz zacząć używać app/ dla nowych funkcji, jednocześnie zachowując istniejące strony w pages/.

.
├── app/                # Nowe funkcje używające App Router
│   ├── new-feature/
│   │   └── page.tsx    # /new-feature
│   └── layout.tsx
└── pages/              # Istniejące strony używające Pages Router
    ├── index.js        # /
    └── about.js        # /about

Ważne uwagi dotyczące migracji:

  • Ścieżki w app/ mają priorytet nad ścieżkami w pages/, ale ten sam adres nie może istnieć w obu katalogach naraz: Next.js zgłosi błąd podczas budowania
  • Obie struktury używają tej samej konfiguracji Next.js
  • Możesz stopniowo przenosić strony z pages/ do app/

Najlepsze praktyki organizacji plików

Niezależnie od wybranego systemu routingu warto trzymać się pewnych najlepszych praktyk:

  1. Struktura zorientowana na funkcje: Organizuj komponenty i kod wokół funkcji biznesowych, a nie według typów technicznych.

    src/
    ├── features/
    │   ├── auth/
    │   │   ├── components/
    │   │   ├── hooks/
    │   │   └── utils/
    │   └── dashboard/
    │       ├── components/
    │       ├── hooks/
    │       └── utils/
  2. Modułowe podejście: Traktuj każdą funkcjonalność jako izolowany moduł z jasno określonym API.

  3. Spójna konwencja nazewnictwa: Ustal konwencje i trzymaj się ich w całym projekcie.

    • Pliki komponentów: PascalCase (Button.tsx)
    • Hooki: camelCase z przedrostkiem "use" (useAuth.ts)
    • Pomocnicze funkcje: camelCase (formatDate.ts)
  4. Importy względne vs. absolutne: Używaj aliasów importu (@/) dla lepszej czytelności i łatwiejszego przenoszenia plików.

  5. Kolokacja testów: Umieszczaj testy blisko testowanych komponentów.

    src/
    ├── components/
    │   ├── Button.tsx
    │   └── Button.test.tsx

Podsumowanie

Struktura katalogów i plików w Next.js 16 jest jak architektura Metropolii Quantum - z odpowiednim planowaniem może być zarówno elegancka, jak i funkcjonalna. App Router wprowadza bardziej zaawansowany, ale także bardziej elastyczny model organizacji aplikacji, podczas gdy Pages Router oferuje prostsze i bardziej bezpośrednie podejście.

Wybór między nimi zależy od specyficznych potrzeb projektu, ale w nowych projektach zaleca się korzystanie z App Routera, aby wykorzystać najnowsze funkcje i optymalizacje. Pamiętaj, że dobra organizacja projektu to klucz do łatwej konserwacji i rozszerzalności w przyszłości.

W kolejnej lekcji zagłębimy się w system komponentów Next.js 16, szczególnie w różnice między Client Components a Server Components, które są fundamentalną częścią App Routera.

Kod do tej lekcji: App.tsx
// Props i State - Metropolis Quantum
import React, { useState } from 'react';

console.log("Props i State w React");
console.log("Zarządzanie danymi w Quantum City\n");

// ==========================================
// 1. PROPS - Przekazywanie Danych
// ==========================================
console.log("=== 1. PROPS - właściwości ===");

interface UserCardProps {
  name: string;
  role: string;
  level: number;
  avatar: string;
}

const UserCard: React.FC<UserCardProps> = ({ name, role, level, avatar }) => {
  return (
    <div style={{
      background: 'rgba(255, 255, 255, 0.1)',
      padding: '20px',
      borderRadius: '12px',
      border: '2px solid #64ffda',
      display: 'flex',
      alignItems: 'center',
      gap: '15px',
      marginBottom: '15px'
    }}>
      <div style={{ fontSize: '3rem' }}>{avatar}</div>
      <div>
        <h3 style={{ color: '#64ffda', margin: '0 0 5px 0' }}>{name}</h3>
        <p style={{ margin: '5px 0', color: '#b0bec5' }}>Rola: {role}</p>
        <p style={{ margin: '5px 0', color: '#ff9800' }}>Poziom: {level}</p>
      </div>
    </div>
  );
};

// ==========================================
// 2. STATE - Stan Komponentu
// ==========================================
console.log("\n=== 2. STATE - hook useState ===");

function QuantumCounter() {
  // useState zwraca [wartość, funkcję do zmiany wartości]
  const [energy, setEnergy] = useState<number>(50);
  const [isCharging, setIsCharging] = useState<boolean>(false);

  const charge = () => {
    if (energy < 100) {
      setEnergy(energy + 10);
      setIsCharging(true);
      setTimeout(() => setIsCharging(false), 300);
      console.log(`Ładowanie energii: ${energy + 10}%`);
    }
  };

  const discharge = () => {
    if (energy > 0) {
      setEnergy(energy - 10);
      console.log(`Rozładowanie energii: ${energy - 10}%`);
    }
  };

  const reset = () => {
    setEnergy(50);
    console.log("Reset energii do 50%");
  };

  const getEnergyColor = () => {
    if (energy > 70) return '#4caf50';
    if (energy > 30) return '#ff9800';
    return '#f44336';
  };

  return (
    <div style={{
      background: 'rgba(124, 77, 255, 0.2)',
      padding: '20px',
      borderRadius: '12px',
      border: '2px solid #7c4dff'
    }}>
      <h3 style={{ color: '#7c4dff' }}>Kwantowy generator energii</h3>

      <div style={{
        background: 'rgba(0, 0, 0, 0.5)',
        padding: '15px',
        borderRadius: '8px',
        marginBottom: '15px'
      }}>
        <div style={{
          fontSize: '2rem',
          textAlign: 'center',
          color: getEnergyColor(),
          marginBottom: '10px'
        }}>
          {energy}%
        </div>
        <div style={{
          width: '100%',
          height: '20px',
          background: 'rgba(255, 255, 255, 0.1)',
          borderRadius: '10px',
          overflow: 'hidden'
        }}>
          <div style={{
            width: `${energy}%`,
            height: '100%',
            background: `linear-gradient(90deg, ${getEnergyColor()}, #64ffda)`,
            transition: 'all 0.3s ease',
            transform: isCharging ? 'scale(1.05)' : 'scale(1)'
          }}></div>
        </div>
      </div>

      <div style={{ display: 'flex', gap: '10px', justifyContent: 'center' }}>
        <button
          onClick={charge}
          disabled={energy >= 100}
          style={{
            background: energy >= 100 ? '#555' : 'linear-gradient(45deg, #4caf50, #8bc34a)',
            color: 'white',
            border: 'none',
            padding: '10px 20px',
            borderRadius: '6px',
            cursor: energy >= 100 ? 'not-allowed' : 'pointer',
            fontWeight: 'bold'
          }}
        >
          Naładuj
        </button>

        <button
          onClick={discharge}
          disabled={energy <= 0}
          style={{
            background: energy <= 0 ? '#555' : 'linear-gradient(45deg, #f44336, #e91e63)',
            color: 'white',
            border: 'none',
            padding: '10px 20px',
            borderRadius: '6px',
            cursor: energy <= 0 ? 'not-allowed' : 'pointer',
            fontWeight: 'bold'
          }}
        >
          Rozładuj
        </button>

        <button
          onClick={reset}
          style={{
            background: 'linear-gradient(45deg, #607d8b, #90a4ae)',
            color: 'white',
            border: 'none',
            padding: '10px 20px',
            borderRadius: '6px',
            cursor: 'pointer',
            fontWeight: 'bold'
          }}
        >
          Resetuj
        </button>
      </div>
    </div>
  );
}

// ==========================================
// 3. Props i State razem
// ==========================================
console.log("\n=== 3. Props i State razem ===");

interface SystemStatusProps {
  systemName: string;
  initialStatus: 'online' | 'offline' | 'maintenance';
}

const SystemStatus: React.FC<SystemStatusProps> = ({ systemName, initialStatus }) => {
  const [status, setStatus] = useState(initialStatus);
  const [uptime, setUptime] = useState(0);

  const toggleStatus = () => {
    const statuses: Array<'online' | 'offline' | 'maintenance'> = ['online', 'offline', 'maintenance'];
    const currentIndex = statuses.indexOf(status);
    const nextStatus = statuses[(currentIndex + 1) % statuses.length];
    setStatus(nextStatus);
    setUptime(0);
    console.log(`Status systemu ${systemName} zmieniony na: ${nextStatus}`);
  };

  const getStatusColor = () => {
    switch(status) {
      case 'online': return '#4caf50';
      case 'offline': return '#f44336';
      case 'maintenance': return '#ff9800';
    }
  };

  return (
    <div style={{
      background: 'rgba(255, 255, 255, 0.1)',
      padding: '15px',
      borderRadius: '10px',
      border: `2px solid ${getStatusColor()}`,
      marginBottom: '15px'
    }}>
      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
        <div>
          <h4 style={{ margin: '0 0 10px 0', color: '#64ffda' }}>{systemName}</h4>
          <div style={{ display: 'flex', alignItems: 'center', gap: '10px' }}>
            <div style={{
              width: '12px',
              height: '12px',
              borderRadius: '50%',
              background: getStatusColor(),
              boxShadow: `0 0 10px ${getStatusColor()}`
            }}></div>
            <span style={{ color: getStatusColor(), textTransform: 'uppercase', fontWeight: 'bold' }}>
              {status}
            </span>
          </div>
        </div>
        <button
          onClick={toggleStatus}
          style={{
            background: 'linear-gradient(45deg, #2196f3, #21cbf3)',
            color: 'white',
            border: 'none',
            padding: '8px 16px',
            borderRadius: '6px',
            cursor: 'pointer',
            fontWeight: 'bold'
          }}
        >
          Zmień status
        </button>
      </div>
    </div>
  );
};

// ==========================================
// Główna aplikacja
// ==========================================
function App() {
  const citizens = [
    { name: 'Alex Quantum', role: 'Główny architekt', level: 42, avatar: '' },
    { name: 'Nova Star', role: 'Analityk danych', level: 38, avatar: '' },
    { name: 'Cypher Neo', role: 'Ekspert ds. bezpieczeństwa', level: 45, avatar: '' }
  ];

  return (
    <div style={{
      padding: '20px',
      background: 'linear-gradient(135deg, #0f0f23 0%, #1a1a2e 100%)',
      minHeight: '100vh',
      color: 'white'
    }}>
      <h1 style={{ textAlign: 'center', color: '#64ffda' }}>Panel sterowania Metropolii</h1>

      <div style={{ marginTop: '30px' }}>
        <h2 style={{ color: '#7c4dff' }}>Mieszkańcy (demo Props)</h2>
        {citizens.map((citizen, index) => (
          <UserCard
            key={index}
            name={citizen.name}
            role={citizen.role}
            level={citizen.level}
            avatar={citizen.avatar}
          />
        ))}
      </div>

      <div style={{ marginTop: '30px' }}>
        <h2 style={{ color: '#7c4dff' }}>System energii (demo State)</h2>
        <QuantumCounter />
      </div>

      <div style={{ marginTop: '30px' }}>
        <h2 style={{ color: '#7c4dff' }}>Status systemów (Props + State)</h2>
        <SystemStatus systemName="Quantum Core" initialStatus="online" />
        <SystemStatus systemName="Neural Network" initialStatus="maintenance" />
        <SystemStatus systemName="Transport Grid" initialStatus="offline" />
      </div>

      <div style={{
        marginTop: '30px',
        background: 'rgba(100, 255, 218, 0.1)',
        padding: '20px',
        borderRadius: '10px',
        borderLeft: '4px solid #64ffda'
      }}>
        <h3>Props a State:</h3>
        <ul style={{ lineHeight: '1.8' }}>
          <li><strong>Props</strong>: Przekazywane z rodzica, tylko do odczytu, jak parametry funkcji</li>
          <li><strong>State</strong>: Wewnętrzny stan komponentu, można modyfikować, re-renderuje komponent</li>
          <li><strong>Props + State</strong>: Najczęściej używane razem w dynamicznych interfejsach</li>
        </ul>
      </div>
    </div>
  );
}

export default App;

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 oznacza 'deklaratywne programowanie' w kontekście React?

  2. 2. Komponenty React mogą być:

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż ścieżkę do dynamicznej strony posta w Next.js

  • Edytor kodu

    Utwórz komponent strony About dla pliku pages/about.js (export default function About). Strona ma wyświetlać nagłówek <h1> lub <h2> z nazwą firmy i akapit <p> z informacjami o firmie.

  1. PytanieProgramowanie deklaratywne w React
  2. PytanieTypy komponentów React
  3. Ułóż w kolejnościŚcieżka do dynamicznej strony
  4. Zadanie z kodemPraktyka: Strona About w Next.js

Przydatne artykuły