Kurs Next.js · Moduł 1: Konfiguracja Next.js
Środowisko deweloperskie - narzędzia i praktyki
W tej lekcji4
W Metropolii Quantum inżynierowie kwantowi potrzebują zaawansowanych stacji roboczych, precyzyjnych narzędzi i zoptymalizowanych procesów, aby efektywnie projektować i utrzymywać zaawansowane systemy miasta. Podobnie dla ciebie jako dewelopera Next.js 16 środowisko deweloperskie jest fundamentem produktywności i jakości kodu.
Centrum Dowodzenia Metropolii Quantum
Zacznijmy od skonfigurowania idealnego środowiska deweloperskiego - twojego osobistego Centrum Dowodzenia dla projektów Next.js 16.
Podstawowe narzędzia
1. Edytor kodu - Quantum Terminal
Sercem każdej stacji roboczej inżyniera kwantowego jest Quantum Terminal. Dla deweloperów Next.js 16 Visual Studio Code (VS Code) z dodatkami jest najlepszym wyborem:
# Zainstaluj podstawowy edytor
code --install-extension dbaeumer.vscode-eslint
code --install-extension esbenp.prettier-vscode
code --install-extension bradlc.vscode-tailwindcss
code --install-extension ms-vscode.vscode-typescript-next
code --install-extension dsznajder.es7-react-js-snippetsKonfiguracja VSCode dla projektów Next.js 16 - plik .vscode/settings.json:
{
"editor.formatOnSave": true,
"editor.defaultFormatter": "esbenp.prettier-vscode",
"editor.codeActionsOnSave": {
"source.fixAll.eslint": true
},
"typescript.tsdk": "node_modules/typescript/lib",
"typescript.enablePromptUseWorkspaceTsdk": true,
"tailwindCSS.includeLanguages": {
"typescript": "javascript",
"typescriptreact": "javascript"
},
"tailwindCSS.experimental.classRegex": [
["cn\\(([^)]*)\\)", "'([^']*)'"]
],
"files.associations": {
"*.css": "tailwindcss"
}
}2. System kontroli wersji - Kwantowe Archiwa
W Metropolii Quantum każda zmiana w systemach miasta jest starannie rejestrowana i przechowywana w Kwantowych Archiwach. W naszym świecie używamy Git:
# Inicjalizacja repozytorium Git dla projektu
git init
# Tworzenie pliku .gitignore dla projektów Next.js
curl -fsSL https://raw.githubusercontent.com/github/gitignore/main/Nextjs.gitignore -o .gitignorePlik .gitignore dla projektu Next.js 16:
# dependencies
/node_modules
/.pnp
.pnp.*
.yarn/*
!.yarn/patches
!.yarn/plugins
!.yarn/releases
!.yarn/versions
# testing
/coverage
# next.js
/.next/
/out/
# production
/build
# misc
.DS_Store
*.pem
# debug
npm-debug.log*
yarn-debug.log*
yarn-error.log*
.pnpm-debug.log*
# env files (can opt-in for committing if needed)
.env*
# vercel
.vercel
# typescript
*.tsbuildinfo
next-env.d.tsTak wygląda .gitignore z create-next-app w Next.js 16. Zwróć uwagę na wiersz .env*: od Next.js 15 ignorowane są wszystkie pliki środowiskowe, nie tylko .env*.local, żeby sekrety nie trafiły przypadkiem do repozytorium. Jeśli chcesz zapisać w nim plik z przykładowymi wartościami, dodaj wyjątek, np. !.env.example.
3. Zarządzanie pakietami - Matryca Zasobów Kwantowych
Inżynierowie w Metropolii Quantum korzystają z Matrycy Zasobów Kwantowych, aby uzyskiwać dokładnie te komponenty, których potrzebują. My korzystamy z npm, yarn lub pnpm:
# Inicjalizacja projektu Next.js 16 z Tailwind CSS i TypeScript
npx create-next-app@latest quantum-project
# Wybierz "Yes, use recommended defaults": TypeScript, ESLint,
# Tailwind CSS, App Router i AGENTS.md w jednym krokuOpcjonalnie, możesz skonfigurować pnpm dla lepszej wydajności:
# Instalacja pnpm
npm install -g pnpm
# Inicjalizacja projektu z pnpm
pnpm dlx create-next-app@latest quantum-projectNarzędzia zwiększające produktywność
1. ESLint - Kwantowy Detektor Anomalii
W Metropolii Quantum zaawansowane skanery nieustannie monitorują kod w poszukiwaniu potencjalnych błędów i nieoptymalnych wzorców. W świecie Next.js 16 ESLint pełni tę funkcję:
npm install --save-dev eslint-plugin-jsx-a11yPakiet eslint-config-next zawiera już zalecane reguły wtyczek react i react-hooks oraz rejestruje wtyczkę jsx-a11y z kilkoma regułami dostępności, dlatego doinstalowujemy tylko eslint-plugin-jsx-a11y, żeby włączyć jej pełny zalecany zestaw. Konfiguracja ESLint w pliku eslint.config.mjs:
// eslint.config.mjs
import { defineConfig, globalIgnores } from 'eslint/config';
import nextVitals from 'eslint-config-next/core-web-vitals';
import nextTs from 'eslint-config-next/typescript';
import jsxA11y from 'eslint-plugin-jsx-a11y';
const eslintConfig = defineConfig([
...nextVitals,
...nextTs,
{
rules: {
...jsxA11y.flatConfigs.recommended.rules,
'react/react-in-jsx-scope': 'off',
'react/prop-types': 'off',
'@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }],
'jsx-a11y/anchor-is-valid': ['error', {
components: ['Link'],
specialLink: ['hrefLeft', 'hrefRight'],
aspects: ['invalidHref', 'preferButton'],
}],
},
},
globalIgnores(['.next/**', 'out/**', 'build/**', 'next-env.d.ts']),
]);
export default eslintConfig;Reguły wpisane po rozwinięciu zestawu recommended nadpisują jego ustawienia, dlatego anchor-is-valid rozumie komponent Link z Next.js. Ustawienie wersji Reacta (settings.react.version) nie jest już potrzebne, bo eslint-config-next wykrywa ją automatycznie.
2. Prettier - Kwantowy Harmonizator Kodu
Tak jak w Metropolii Quantum wszystkie struktury muszą być idealnie zharmonizowane, tak twój kod powinien być spójnie sformatowany:
npm install --save-dev prettier eslint-config-prettierKonfiguracja Prettier w pliku .prettierrc:
{
"semi": true,
"singleQuote": true,
"tabWidth": 2,
"printWidth": 100,
"trailingComma": "es5",
"bracketSpacing": true,
"arrowParens": "avoid"
}I dodaj konfigurację eslint-config-prettier na końcu tablicy w eslint.config.mjs, żeby wyłączyć reguły ESLinta kolidujące z formatowaniem:
// eslint.config.mjs (fragment)
import prettier from 'eslint-config-prettier/flat';
const eslintConfig = defineConfig([
...nextVitals,
...nextTs,
// ...reszta konfiguracji
prettier,
globalIgnores(['.next/**', 'out/**', 'build/**', 'next-env.d.ts']),
]);3. Husky i lint-staged - Automatyczne Straże Kwantowe
W Metropolii Quantum, zanim jakikolwiek kod zostanie wprowadzony do systemów miasta, przechodzi przez szereg automatycznych testów i walidacji. Podobnie możemy skonfigurować Husky i lint-staged:
npm install --save-dev husky lint-staged
npx husky init
echo "npx lint-staged" > .husky/pre-commitKonfiguracja lint-staged w package.json:
{
"lint-staged": {
"*.{js,jsx,ts,tsx}": [
"eslint --fix",
"prettier --write"
],
"*.{json,css,md}": [
"prettier --write"
]
}
}4. TypeScript - Kwantowy System Typów
W Metropolii Quantum wszystkie komponenty muszą dokładnie przestrzegać swoich specyfikacji, aby zapewnić bezpieczeństwo całego systemu. TypeScript zapewnia podobne bezpieczeństwo dla twojego kodu:
# TypeScript jest już zainstalowany w projekcie Next.js 16
# Skonfigurujmy ściślejsze reguły TypeScriptKonfiguracja tsconfig.json:
{
"compilerOptions": {
"target": "ES2017",
"lib": ["dom", "dom.iterable", "esnext"],
"allowJs": true,
"skipLibCheck": true,
"strict": true,
"noUncheckedIndexedAccess": true,
"forceConsistentCasingInFileNames": true,
"noEmit": true,
"esModuleInterop": true,
"module": "esnext",
"moduleResolution": "bundler",
"resolveJsonModule": true,
"isolatedModules": true,
"jsx": "react-jsx",
"incremental": true,
"plugins": [
{
"name": "next"
}
],
"paths": {
"@/*": ["./src/*"]
}
},
"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts", ".next/dev/types/**/*.ts", "**/*.mts"],
"exclude": ["node_modules"]
}Tak wygląda tsconfig.json w projekcie Next.js 16 uzupełniony o opcję noUncheckedIndexedAccess (noImplicitAny i strictNullChecks włącza już "strict": true). create-next-app ustawia "jsx": "react-jsx" i "moduleResolution": "bundler", a w include dopisuje katalog .next/dev/types, bo next dev zapisuje teraz swoje pliki osobno w .next/dev.
Narzędzia testowe - Kwantowe Symulacje
Inżynierowie w Metropolii Quantum przeprowadzają tysiące symulacji przed każdą zmianą, aby zapewnić, że systemy miasta będą działać bez zarzutu. Odpowiednikiem w świecie Next.js 16 są narzędzia testowe:
1. Jest i React Testing Library - Podstawowe Symulacje
npm install --save-dev jest @testing-library/react @testing-library/jest-dom jest-environment-jsdomPlik konfiguracyjny jest.config.js:
const nextJest = require('next/jest');
const createJestConfig = nextJest({
// Folder, gdzie znajduje się plik next.config.js i folder node_modules
dir: './',
});
// Konfiguracja Jest
const customJestConfig = {
setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
testEnvironment: 'jest-environment-jsdom',
moduleNameMapper: {
'^@/(.*)$': '<rootDir>/src/$1',
},
};
// eksportujemy tę konfigurację
module.exports = createJestConfig(customJestConfig);Plik setupu jest.setup.js:
// Rozszerzenia dla Jest
import '@testing-library/jest-dom';Skrypty testowe w package.json:
{
"scripts": {
"test": "jest",
"test:watch": "jest --watch"
}
}2. Cypress - Zaawansowane Symulacje
npm install --save-dev cypressInicjalizacja Cypress:
npx cypress openDodaj skrypty do package.json:
{
"scripts": {
"cypress": "cypress open",
"cypress:headless": "cypress run"
}
}3. Storybook - Biblioteka Komponentów Kwantowych
npm create storybook@latestKreator zapyta, czy użyć wersji opartej na Vite, czy na Webpacku. Skonfiguruj Storybook dla Next.js 16 w pliku .storybook/main.ts:
// .storybook/main.ts
import type { StorybookConfig } from '@storybook/nextjs-vite';
const config: StorybookConfig = {
stories: ['../src/**/*.mdx', '../src/**/*.stories.@(js|jsx|ts|tsx)'],
addons: ['@storybook/addon-docs'],
framework: '@storybook/nextjs-vite',
staticDirs: ['../public'],
};
export default config;Framework @storybook/nextjs-vite zna specyfikę Next.js, m.in. next/image, next/font i routing, dlatego dokumentacja Storybooka poleca go dla większości projektów Next.js. Wersję opartą na Webpacku (@storybook/nextjs) wybierz tylko wtedy, gdy potrzebujesz własnej konfiguracji Webpacka lub Babela.
Praktyki zoptymalizowanego rozwoju
W Metropolii Quantum każdy inżynier przestrzega ściśle określonych standardów i procedur. Przyjrzyjmy się najlepszym praktykom dla deweloperów Next.js 16.
1. Struktura projektu - Blueprint Metropolii
Podobnie jak Metropolia Quantum jest podzielona na precyzyjnie zaprojektowane sektory, twój projekt Next.js 16 powinien mieć przejrzystą strukturę:
quantum-voyages/
├── .husky/ # Konfiguracja Husky
├── .vscode/ # Konfiguracja VS Code
├── public/ # Statyczne zasoby
├── src/
│ ├── app/ # App Router - trasy i strony
│ │ ├── (auth)/ # Grupowanie logiczne dla autoryzacji
│ │ │ ├── login/
│ │ │ └── register/
│ │ ├── destinations/ # Trasa dla destynacji
│ │ ├── bookings/ # Trasa dla rezerwacji
│ │ ├── api/ # Endpointy API
│ │ └── layout.tsx # Główny layout
│ ├── components/ # Komponenty React
│ │ ├── ui/ # Elementy interfejsu
│ │ └── features/ # Komponenty specyficzne dla funkcji
│ ├── hooks/ # Niestandardowe hooki React
│ ├── lib/ # Funkcje narzędziowe i logika biznesowa
│ ├── styles/ # Globalne style i motywy
│ ├── types/ # Definicje typów TypeScript
│ └── utils/ # Funkcje narzędziowe
├── tests/ # Testy integracyjne i end-to-end
│ ├── e2e/ # Testy Cypress
│ └── integration/ # Testy integracyjne
├── .env.example # Przykładowy plik zmiennych środowiskowych
├── .gitignore # Ignorowane pliki Git
├── .prettierrc # Konfiguracja Prettier
├── eslint.config.mjs # Konfiguracja ESLint (flat config)
├── jest.config.js # Konfiguracja Jest
├── next.config.ts # Konfiguracja Next.js
├── package.json # Zależności i skrypty
├── postcss.config.mjs # Konfiguracja PostCSS (dla Tailwind CSS 4)
└── tsconfig.json # Konfiguracja TypeScript2. Konwencje nazewnictwa - Protokoły Kwantowe
W Metropolii Quantum każdy element ma swoją precyzyjną nazwę, która odzwierciedla jego funkcję. Podobnie w kodzie:
// Komponenty: PascalCase, pliki .tsx
// components/ui/QuantumButton.tsx
export default function QuantumButton() {
return <button className="bg-blue-500 text-white px-4 py-2 rounded">Quantum</button>;
}
// Funkcje narzędziowe: camelCase, pliki .ts
// utils/formatDate.ts
export function formatDate(date: Date): string {
return new Intl.DateTimeFormat('pl-PL').format(date);
}
// Hooki: nazwa zaczyna się od 'use', camelCase, pliki .ts
// hooks/useQuantumState.ts
export function useQuantumState(initialValue: number) {
const [state, setState] = useState(initialValue);
//
return { state, increment, decrement };
}
// Konteksty: nazwa kończy się na 'Context', PascalCase
// contexts/QuantumContext.tsx
export const QuantumContext = createContext<QuantumContextType | null>(null);3. Przepływ pracy w Gicie - Protokoły kontroli wersji Metropolii
W Metropolii Quantum każda zmiana w systemach miasta musi przejść przez precyzyjny proces zatwierdzania i wdrażania. W świecie programistycznym warto stosować model Gitflow:
# Tworzenie nowej funkcji
git checkout -b feature/quantum-navigation
# Commity z opisowymi wiadomościami
git commit -m "feat: Add quantum navigation component"
git commit -m "fix: Repair positioning in quantum nav"
git commit -m "docs: Add JSdoc comments to navigation functions"
# Zakończenie funkcji i merge do developa
git checkout develop
git merge feature/quantum-navigationStandardy wiadomości commit (Conventional Commits):
- feat: nowa funkcjonalność
- fix: naprawa błędu
- docs: zmiany w dokumentacji
- style: formatowanie kodu
- refactor: refaktoryzacja kodu
- test: dodanie lub aktualizacja testów
- chore: aktualizacje zadań budowy, narzędzi itp.
4. Podejście do komponentów - Projektowanie Kwantowych Modułów
Atomic Design
W Metropolii Quantum wszystkie systemy są budowane z podstawowych cząstek kwantowych, które łączą się w coraz bardziej złożone struktury. Podobny model - Atomic Design - możemy zastosować w projektowaniu interfejsu:
- Atoms - podstawowe komponenty: przyciski, inputy, etykiety
- Molecules - grupy atomów: formularze wyszukiwania, nawigacja
- Organisms - złożone sekcje UI: nagłówki, stopki, panele boczne
- Templates - układy stron
- Pages - konkretne instancje szablonów z danymi
components/
├── atoms/
│ ├── Button.tsx
│ ├── Input.tsx
│ └── Label.tsx
├── molecules/
│ ├── SearchForm.tsx
│ └── NavLink.tsx
├── organisms/
│ ├── Header.tsx
│ └── Footer.tsx
└── templates/
├── DashboardLayout.tsx
└── AuthLayout.tsxKomponenty oparte na wzorcu "Kompozycji i API"
Tak jak w Metropolii Quantum każdy moduł ma swój interfejs i może być łączony z innymi modułami, nasze komponenty powinny być zaprojektowane modułowo:
// Przykład komponentu z wzorcem kompozycji
import { ReactNode } from 'react';
interface CardProps {
className?: string;
children: ReactNode;
}
export function Card({ className, children }: CardProps) {
return <div className={`rounded-lg shadow ${className}`}>{children}</div>;
}
Card.Header = function CardHeader({ className, children }: CardProps) {
return <div className={`p-4 border-b ${className}`}>{children}</div>;
};
Card.Body = function CardBody({ className, children }: CardProps) {
return <div className={`p-4 ${className}`}>{children}</div>;
};
Card.Footer = function CardFooter({ className, children }: CardProps) {
return <div className={`p-4 border-t ${className}`}>{children}</div>;
};
// Użycie
<Card className="bg-white">
<Card.Header>Quantum Navigation</Card.Header>
<Card.Body>Zawartość karty</Card.Body>
<Card.Footer>Actions</Card.Footer>
</Card>5. Automatyzacja zadań - Kwantowe Automatyczne Systemy
W Metropolii Quantum wiele procesów jest zautomatyzowanych, aby inżynierowie mogli skupić się na innowacjach. Podobnie w projekcie Next.js 16:
// package.json
{
"scripts": {
"dev": "next dev",
"build": "next build",
"start": "next start",
"lint": "eslint",
"format": "prettier --write .",
"test": "jest",
"test:watch": "jest --watch",
"e2e": "cypress open",
"storybook": "storybook dev -p 6006",
"build-storybook": "storybook build",
"prepare": "husky",
"type-check": "tsc --noEmit",
"validate": "npm-run-all --parallel lint type-check test"
}
}Skrypt validate uruchamia kilka poleceń naraz narzędziem npm-run-all, które trzeba doinstalować: npm install --save-dev npm-run-all2 (pakiet npm-run-all2 dostarcza polecenie npm-run-all).
6. Zarządzanie stanem - Kwantowe Zarządzanie Danymi
W Metropolii Quantum dane przepływają przez miasto za pomocą złożonego systemu kwantowego. W aplikacji Next.js 16 również potrzebujemy efektywnego zarządzania stanem:
Lokalne zarządzanie stanem
// Korzystanie z useState i useReducer dla prostego zarządzania stanem
"use client";
import { useState } from 'react';
export default function QuantumCounter() {
const [count, setCount] = useState(0);
return (
<div className="flex items-center gap-4">
<button
onClick={() => setCount(c => c - 1)}
className="px-3 py-1 bg-red-500 text-white rounded"
>
-
</button>
<span className="text-xl">{count}</span>
<button
onClick={() => setCount(c => c + 1)}
className="px-3 py-1 bg-green-500 text-white rounded"
>
+
</button>
</div>
);
}Zarządzanie stanem na poziomie aplikacji
// Context API - dla średniej wielkości aplikacji
// contexts/QuantumStateContext.tsx
"use client";
import { createContext, useContext, useReducer, ReactNode } from 'react';
type State = {
destinations: string[];
selectedDestination: string | null;
};
type Action =
| { type: 'ADD_DESTINATION'; payload: string }
| { type: 'SELECT_DESTINATION'; payload: string };
const initialState: State = {
destinations: ['Mars', 'Europa', 'Titan'],
selectedDestination: null,
};
function reducer(state: State, action: Action): State {
switch (action.type) {
case 'ADD_DESTINATION':
return {
...state,
destinations: [...state.destinations, action.payload],
};
case 'SELECT_DESTINATION':
return {
...state,
selectedDestination: action.payload,
};
default:
return state;
}
}
const QuantumStateContext = createContext<{
state: State;
dispatch: React.Dispatch<Action>;
} | undefined>(undefined);
export function QuantumStateProvider({ children }: { children: ReactNode }) {
const [state, dispatch] = useReducer(reducer, initialState);
return (
<QuantumStateContext.Provider value={{ state, dispatch }}>
{children}
</QuantumStateContext.Provider>
);
}
export function useQuantumState() {
const context = useContext(QuantumStateContext);
if (context === undefined) {
throw new Error('useQuantumState must be used within a QuantumStateProvider');
}
return context;
}Dla większych aplikacji warto rozważyć biblioteki zarządzania stanem, takie jak Zustand, Jotai czy Redux Toolkit.
7. Strategia API - Protokoły komunikacji kwantowej
W Metropolii Quantum systemy komunikują się za pomocą precyzyjnych protokołów. W Next.js 16 mamy kilka opcji implementacji API:
Route Handlers
// app/api/destinations/route.ts
import { NextResponse } from 'next/server';
export async function GET() {
// Pobieranie danych z bazy danych lub zewnętrznego API
const destinations = [
{ id: 1, name: 'Mars', distance: '54.6M km' },
{ id: 2, name: 'Europa', distance: '628.3M km' },
{ id: 3, name: 'Titan', distance: '1.2B km' },
];
return NextResponse.json(destinations);
}
export async function POST(request: Request) {
const body = await request.json();
// Walidacja i logika biznesowa
if (!body.name) {
return NextResponse.json(
{ error: 'Name is required' },
{ status: 400 }
);
}
// Zapisywanie do bazy danych...
return NextResponse.json(
{ id: 4, name: body.name, distance: body.distance },
{ status: 201 }
);
}Akcje serwerowe (Server Actions)
// app/destinations/actions.ts
'use server';
import { revalidatePath } from 'next/cache';
import { redirect } from 'next/navigation';
export async function addDestination(formData: FormData) {
const name = formData.get('name') as string;
const distance = formData.get('distance') as string;
if (!name || !distance) {
return { error: 'Name and distance are required' };
}
// Zapisywanie do bazy danych...
// Odświeżenie danych
revalidatePath('/destinations');
redirect('/destinations');
}React Query dla zarządzania stanem API
npm install @tanstack/react-query @tanstack/react-query-devtools// app/providers.tsx
'use client';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
import { useState, ReactNode } from 'react';
export function Providers({ children }: { children: ReactNode }) {
const [queryClient] = useState(() => new QueryClient());
return (
<QueryClientProvider client={queryClient}>
{children}
<ReactQueryDevtools initialIsOpen={false} />
</QueryClientProvider>
);
}// components/DestinationsList.tsx
'use client';
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
async function fetchDestinations() {
const res = await fetch('/api/destinations');
if (!res.ok) throw new Error('Failed to fetch destinations');
return res.json();
}
export default function DestinationsList() {
const queryClient = useQueryClient();
const { data: destinations, isLoading, error } = useQuery({
queryKey: ['destinations'],
queryFn: fetchDestinations,
});
const mutation = useMutation({
mutationFn: async (newDestination) => {
const res = await fetch('/api/destinations', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(newDestination),
});
return res.json();
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['destinations'] });
},
});
if (isLoading) return <div>Ładowanie destynacji...</div>;
if (error) return <div>Błąd: {error.message}</div>;
return (
<div>
<h2 className="text-2xl font-bold mb-4">Dostępne destynacje</h2>
<ul className="space-y-2">
{destinations.map((dest) => (
<li key={dest.id} className="p-3 bg-gray-100 rounded">
{dest.name} - {dest.distance}
</li>
))}
</ul>
</div>
);
}8. Ciągła integracja i wdrażanie (CI/CD) - Kwantowy Potok Produkcyjny
W Metropolii Quantum nowe technologie są systematycznie testowane i wdrażane za pomocą w pełni zautomatyzowanego procesu. Podobnie możemy skonfigurować CI/CD dla naszego projektu:
GitHub Actions dla CI/CD
Plik .github/workflows/ci.yml:
name: CI
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main, develop ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- name: Setup Node.js
uses: actions/setup-node@v7
with:
node-version: '24'
cache: 'npm'
- name: Install dependencies
run: npm ci
- name: Lint
run: npm run lint
- name: Type check
run: npm run type-check
- name: Test
run: npm test
- name: Build
run: npm run buildWdrażanie na Vercelu
Skonfiguruj integrację z Vercelem, aby każdy push do głównej gałęzi automatycznie wdrażał aplikację:
- Połącz swoje repozytorium z Vercelem
- Skonfiguruj zmienne środowiskowe
- Używaj podglądów (Preview Deployments) dla pull requestów
- Automatyczne wdrażanie na produkcję po połączeniu z główną gałęzią
Zaawansowane techniki deweloperskie
1. Monitorowanie wydajności - Kwantowa telemetria
W Metropolii Quantum inżynierowie stale monitorują wydajność wszystkich systemów. W naszej aplikacji Next.js 16:
// app/layout.tsx
import { SpeedInsights } from '@vercel/speed-insights/next';
import { Analytics } from '@vercel/analytics/react';
export default function RootLayout({
children,
}: {
children: React.ReactNode;
}) {
return (
<html lang="pl">
<body>
{children}
<SpeedInsights />
<Analytics />
</body>
</html>
);
}2. Progresywne ulepszenia i dostępność - Uniwersalne dostosowanie kwantowe
W Metropolii Quantum każdy obywatel musi mieć dostęp do systemów miasta, niezależnie od swoich ograniczeń. Podobnie, nasza aplikacja powinna być dostępna dla wszystkich:
// components/ui/QuantumButton.tsx z ulepszoną dostępnością
"use client";
import { ButtonHTMLAttributes, forwardRef } from 'react';
interface QuantumButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
variant?: 'primary' | 'secondary' | 'danger';
size?: 'sm' | 'md' | 'lg';
isLoading?: boolean;
}
export const QuantumButton = forwardRef<HTMLButtonElement, QuantumButtonProps>(
({
variant = 'primary',
size = 'md',
className = '',
isLoading = false,
disabled,
children,
...props
}, ref) => {
// Mapowanie wariantów na klasy
const variantClasses = {
primary: 'bg-blue-600 hover:bg-blue-700 text-white',
secondary: 'bg-gray-200 hover:bg-gray-300 text-gray-800',
danger: 'bg-red-600 hover:bg-red-700 text-white',
};
// Mapowanie rozmiarów na klasy
const sizeClasses = {
sm: 'text-sm px-2 py-1',
md: 'text-base px-4 py-2',
lg: 'text-lg px-6 py-3',
};
return (
<button
ref={ref}
className={`rounded font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500 ${variantClasses[variant]} ${sizeClasses[size]} ${isLoading || disabled ? 'opacity-70 cursor-not-allowed' : ''} ${className}`}
disabled={isLoading || disabled}
{...props}
>
{isLoading ? (
<span className="flex items-center justify-center">
<svg className="animate-spin -ml-1 mr-2 h-4 w-4 text-current" fill="none" viewBox="0 0 24 24">
<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
</svg>
Ładowanie...
</span>
) : children}
</button>
);
}
);
QuantumButton.displayName = 'QuantumButton';3. Dokumentowanie kodu - Kwantowy Archiwista
W Metropolii Quantum każdy system jest dokładnie udokumentowany, aby przyszli inżynierowie mogli z łatwością go zrozumieć. W naszym projekcie:
/**
* Komponent nawigacyjny dla podróży kosmicznych.
*
* @component
* @example
* ~~~tsx
* <QuantumNavigation
* destinations={['Mars', 'Europa', 'Titan']}
* onSelectDestination={(dest) => console.log(`Wybrano ${dest}`)}
* />
* ~~~
*/
export interface QuantumNavigationProps {
/** Lista dostępnych destynacji */
destinations: string[];
/** Callback wywoływany po wybraniu destynacji */
onSelectDestination: (destination: string) => void;
/** Aktualnie wybrana destynacja (opcjonalna) */
selectedDestination?: string;
}
export function QuantumNavigation({
destinations,
onSelectDestination,
selectedDestination
}: QuantumNavigationProps) {
return (
<nav className="p-4 bg-gradient-to-r from-indigo-500 to-purple-600 rounded-lg text-white">
<h2 className="text-xl font-semibold mb-2">Nawigacja Quantum</h2>
<ul className="space-y-1">
{destinations.map((dest) => (
<li key={dest}>
<button
className={`w-full text-left px-3 py-2 rounded hover:bg-white/20 ${
selectedDestination === dest ? 'bg-white/30 font-medium' : ''
}`}
onClick={() => onSelectDestination(dest)}
>
{dest}
</button>
</li>
))}
</ul>
</nav>
);
}4. Współpraca w zespole - Kwantowy Kolektyw
W Metropolii Quantum inżynierowie pracują w zsynchronizowanych zespołach, aby osiągnąć maksymalną efektywność. Podobnie, zespół deweloperów Next.js 16 powinien mieć jasne procesy współpracy:
- Code Reviews - każdy pull request powinien być przeglądany przez co najmniej jednego innego dewelopera
- Pair Programming - trudniejsze problemy rozwiązuj w parach
- Standupy - krótkie codzienne spotkania dla synchronizacji pracy
- Sprint Planning - planowanie zadań na najbliższy sprint
- Retrospektywy - regularne spotkania w celu omówienia, co działa, a co można poprawić
Podsumowanie
Podobnie jak inżynierowie Metropolii Quantum potrzebują zaawansowanych narzędzi i optymalnych procesów, deweloperzy Next.js 16 potrzebują dobrze skonfigurowanego środowiska deweloperskiego. Dzięki przedstawionym narzędziom i praktykom możesz:
- Zwiększyć produktywność - automatyzacja powtarzalnych zadań
- Poprawić jakość kodu - linting, testowanie, typowanie
- Ułatwić współpracę - spójne konwencje, CI/CD, przejrzysta struktura
- Przyspieszyć rozwój - szybki feedback, efektywne debugowanie
- Zapewnić wysoką jakość - automatyczne testy, przeglądy kodu
Pamiętaj, że podobnie jak Metropolia Quantum nieustannie się rozwija, tak i twoje środowisko deweloperskie powinno ewoluować wraz z projektem i zespołem. Regularnie przeglądaj i aktualizuj swoje narzędzia i procesy, aby utrzymać maksymalną wydajność i jakość kodu.
Cała wiedza i narzędzia przedstawione w tym module umożliwią ci efektywne tworzenie zaawansowanych aplikacji przy użyciu Next.js 16 - podobnie jak inżynierowie kwantowi w Metropolii wykorzystują swoje narzędzia do projektowania technologii jutra.
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. Które narzędzie odpowiada za automatyczne formatowanie kodu przy zapisie pliku?
2. Do czego służą Husky i lint-staged w projekcie?
3. Który menedżer pakietów oszczędza miejsce na dysku dzięki współdzielonemu magazynowi pakietów?
Zadania praktyczne w grze
- Układanie w pionie
Ułóż kolejność kroków pracy z funkcją w przepływie Gitflow