Kurs JavaScript i React · Moduł 12: React i TypeScript
Projekt Główny: Typowany Dashboard Kosmiczny
W tej lekcji5
Centrum kontroli misji dostaje dane z całej galaktyki: planety, gwiazdy i asteroidy, każde z innymi polami. Operator filtruje je, dodaje nowe odkrycia i przełącza motyw pulpitu na nocną wachtę. Jeden błędny typ w takim systemie i na ekranie pojawia się "undefined" zamiast temperatury gwiazdy. Czas połączyć całą wiedzę z tego modułu w jeden projekt! Zbudujesz typowany dashboard kosmiczny, który wykorzystuje:
- Interfejsy i typy - dla danych planet, misji i załogi
- Typowane komponenty - z pełnym typowaniem props
- useState z generykami - dla zarządzania stanem
- Typowane zdarzenia - w formularzach i interakcjach
- Discriminated unions - dla różnych typów danych
- Context API z TypeScript - dla globalnego stanu
Opis projektu
Dashboard kosmiczny składa się z kilku sekcji:
- Panel główny - wyświetla statystyki misji
- Lista obiektów kosmicznych - z filtrowaniem według typu (planety, gwiazdy, asteroidy)
- Formularz dodawania - z pełnym typowaniem zdarzeń
- Przełącznik motywu - ciemny/jasny z Context API
Moja rada: zacznij od typów, nie od JSX. Gdy mapa danych jest gotowa, komponenty praktycznie piszą się same, bo edytor podpowiada każde pole.
Architektura typów
Pierwszy krok to bazowy interfejs ze wspólnymi polami każdego obiektu oraz trzy warianty, które go rozszerzają słowem extends. Każdy wariant dodaje dyskryminator kind z typem literalnym, dokładnie jak w lekcji o discriminated unions:
// Bazowy interfejs
interface SpaceEntity {
id: string;
name: string;
discoveredYear: number;
}
// Discriminated union - różne typy obiektów
interface PlanetEntity extends SpaceEntity {
kind: "planet";
radius: number;
habitable: boolean;
}
interface StarEntity extends SpaceEntity {
kind: "star";
temperature: number;
spectralClass: "O" | "B" | "A" | "F" | "G" | "K" | "M";
}
interface AsteroidEntity extends SpaceEntity {
kind: "asteroid";
diameter: number;
composition: string;
}Pole spectralClass przyjmuje tylko siedem prawdziwych klas widmowych gwiazd, od najgorętszych O do najchłodniejszych M. Teraz łączymy warianty w unię i opisujemy stan dashboardu:
type CosmicObject = PlanetEntity | StarEntity | AsteroidEntity;
// Stan dashboardu
interface DashboardState {
objects: CosmicObject[];
filter: CosmicObject["kind"] | "all";
searchQuery: string;
}Zapis CosmicObject["kind"] wyciąga z unii wszystkie wartości dyskryminatora, czyli "planet" | "star" | "asteroid". Dopisujemy do tego "all" i filtr zna każdą dozwoloną opcję. Gdy dodasz czwarty wariant, filtr zaktualizuje się sam - nic nie trzeba zmieniać ręcznie.
Generyczny komponent DataTable
Tabela ma wyświetlać dowolne obiekty, więc jest generyczna. Nowym elementem jest operator keyof T, który zwraca unię nazw pól typu T. Dzięki niemu kolumna może wskazać tylko pole, które naprawdę istnieje. T[keyof T] oznacza z kolei typ wartości dowolnego z tych pól.
// Generyczny komponent tabeli z pełnym typowaniem
interface Column<T> {
key: keyof T;
label: string;
render?: (value: T[keyof T], item: T) => React.ReactNode;
}
interface DataTableProps<T extends { id: string }> {
data: T[];
columns: Column<T>[];
onRowClick?: (item: T) => void;
}Ograniczenie T extends { id: string } gwarantuje klucz dla każdego wiersza. Opcjonalny render pozwala kolumnie narysować wartość po swojemu, na przykład dodać jednostkę. Sam komponent:
function DataTable<T extends { id: string }>({
data, columns, onRowClick
}: DataTableProps<T>) {
return (
<table>
<thead>
<tr>
{columns.map(col => (
<th key={String(col.key)}>{col.label}</th>
))}
</tr>
</thead>
<tbody>
{data.map(item => (
<tr key={item.id} onClick={() => onRowClick?.(item)}>
{columns.map(col => (
<td key={String(col.key)}>
{col.render
? col.render(item[col.key], item)
: String(item[col.key])}
</td>
))}
</tr>
))}
</tbody>
</table>
);
}String(col.key) jest potrzebne, bo keyof T może teoretycznie zawierać symbole, a key w React oczekuje tekstu lub liczby. onRowClick?.(item) wywoła funkcję tylko wtedy, gdy rodzic ją przekazał.
Typowany formularz dodawania
Formularz też korzysta z discriminated union: każdy rodzaj obiektu ma inne pola, a wartości z pól tekstowych przechowujemy jako string, bo tak zwraca je e.target.value. Zamiana na liczby następuje dopiero przy tworzeniu obiektu.
type NewObjectForm =
| { kind: "planet"; name: string; radius: string; habitable: boolean }
| { kind: "star"; name: string; temperature: string; spectralClass: string }
| { kind: "asteroid"; name: string; diameter: string; composition: string };Komponent przyjmuje callback onAdd i trzyma w stanie wybrany rodzaj obiektu oraz nazwę. Handler wysłania korzysta z React.SubmitEvent (w starszych projektach zobaczysz tu przestarzały już React.FormEvent):
function AddObjectForm({ onAdd }: { onAdd: (obj: CosmicObject) => void }) {
const [kind, setKind] = useState<CosmicObject["kind"]>("planet");
const [name, setName] = useState("");
const handleSubmit = (e: React.SubmitEvent<HTMLFormElement>) => {
e.preventDefault();
// Tworzy odpowiedni obiekt na podstawie wybranego typu
const id = crypto.randomUUID();
const year = new Date().getFullYear();
// ... logika tworzenia obiektu
};
return (
<form onSubmit={handleSubmit}>
<select
value={kind}
onChange={(e: React.ChangeEvent<HTMLSelectElement>) =>
setKind(e.target.value as CosmicObject["kind"])
}
>
<option value="planet">Planeta</option>
<option value="star">Gwiazda</option>
<option value="asteroid">Asteroida</option>
</select>
<input value={name} onChange={e => setName(e.target.value)} />
<button type="submit">Dodaj</button>
</form>
);
}crypto.randomUUID() to wbudowana funkcja przeglądarki generująca unikalny identyfikator - działa na stronach HTTPS i na localhost. W polu input nie podaliśmy typu zdarzenia, bo przy funkcji wpisanej bezpośrednio w atrybut TypeScript wywnioskuje go sam. Brakującą logikę tworzenia obiektu dopiszesz jako ćwiczenie: switch po kind i assertNever w gałęzi default.
Cały projekt
Poniżej znajdziesz kompletną implementację dashboardu kosmicznego z pełnym typowaniem TypeScript. Przeanalizuj kod, zmodyfikuj go i eksperymentuj z typami! Spróbuj dodać czwarty rodzaj obiektu, na przykład kometę, i obserwuj, ile miejsc wskaże kompilator.
Kod do tej lekcji: App.tsx
import React, { createContext, useContext, useReducer, useState, useRef } from 'react';
// ===== TYPY DANYCH =====
interface SpaceEntity {
id: string;
name: string;
discoveredYear: number;
}
interface PlanetEntity extends SpaceEntity {
kind: "planet";
radius: number;
habitable: boolean;
}
interface StarEntity extends SpaceEntity {
kind: "star";
temperature: number;
spectralClass: "O" | "B" | "A" | "F" | "G" | "K" | "M";
}
interface AsteroidEntity extends SpaceEntity {
kind: "asteroid";
diameter: number;
composition: string;
}
type CosmicObject = PlanetEntity | StarEntity | AsteroidEntity;
// ===== STAN I AKCJE =====
interface DashboardState {
objects: CosmicObject[];
filter: CosmicObject["kind"] | "all";
searchQuery: string;
theme: "dark" | "light";
}
type DashboardAction =
| { type: "ADD_OBJECT"; payload: CosmicObject }
| { type: "REMOVE_OBJECT"; payload: string }
| { type: "SET_FILTER"; payload: DashboardState["filter"] }
| { type: "SET_SEARCH"; payload: string }
| { type: "TOGGLE_THEME" };
function dashboardReducer(state: DashboardState, action: DashboardAction): DashboardState {
switch (action.type) {
case "ADD_OBJECT":
return { ...state, objects: [...state.objects, action.payload] };
case "REMOVE_OBJECT":
return { ...state, objects: state.objects.filter(o => o.id !== action.payload) };
case "SET_FILTER":
return { ...state, filter: action.payload };
case "SET_SEARCH":
return { ...state, searchQuery: action.payload };
case "TOGGLE_THEME":
return { ...state, theme: state.theme === "dark" ? "light" : "dark" };
default:
return state;
}
}
// ===== CONTEXT =====
interface DashboardContextType {
state: DashboardState;
dispatch: React.Dispatch<DashboardAction>;
}
const DashboardContext = createContext<DashboardContextType | undefined>(undefined);
function useDashboard(): DashboardContextType {
const ctx = useContext(DashboardContext);
if (!ctx) throw new Error("useDashboard wymaga DashboardProvider");
return ctx;
}
// ===== GENERYCZNY KOMPONENT =====
interface HasId { id: string; }
function DataList<T extends HasId>({
items, renderItem, emptyMsg = "Brak danych"
}: {
items: T[];
renderItem: (item: T) => React.ReactNode;
emptyMsg?: string;
}) {
if (items.length === 0) return <p className="empty">{emptyMsg}</p>;
return (
<div className="data-list">
{items.map(item => <div key={item.id} className="data-item">{renderItem(item)}</div>)}
</div>
);
}
// ===== KOMPONENT KARTY =====
function ObjectCard({ obj, onRemove }: { obj: CosmicObject; onRemove: (id: string) => void }) {
const icons = { planet: "P", star: "S", asteroid: "A" };
const colors = { planet: "#22c55e", star: "#f59e0b", asteroid: "#ef4444" };
const renderDetails = (): React.ReactNode => {
switch (obj.kind) {
case "planet":
return <><p>Promien: {obj.radius} km</p><p>{obj.habitable ? "Zamieszkiwalna" : "Niezamieszkiwalna"}</p></>;
case "star":
return <><p>Temp: {obj.temperature}K</p><p>Klasa: {obj.spectralClass}</p></>;
case "asteroid":
return <><p>Srednica: {obj.diameter} km</p><p>Sklad: {obj.composition}</p></>;
}
};
return (
<div className="object-card" style={{ borderLeftColor: colors[obj.kind] }}>
<div className="card-top">
<span className="obj-icon" style={{ background: colors[obj.kind] }}>{icons[obj.kind]}</span>
<div>
<h3>{obj.name}</h3>
<span className="year">Odkryto: {obj.discoveredYear}</span>
</div>
<button className="remove-btn" onClick={() => onRemove(obj.id)}>X</button>
</div>
{renderDetails()}
</div>
);
}
// ===== FORMULARZ =====
function AddForm() {
const { dispatch } = useDashboard();
const [kind, setKind] = useState<CosmicObject["kind"]>("planet");
const [name, setName] = useState("");
const nameRef = useRef<HTMLInputElement>(null);
const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
e.preventDefault();
if (!name.trim()) return;
const base = { id: Date.now().toString(), name, discoveredYear: 2026 };
let obj: CosmicObject;
switch (kind) {
case "planet":
obj = { ...base, kind: "planet", radius: 6371, habitable: false };
break;
case "star":
obj = { ...base, kind: "star", temperature: 5778, spectralClass: "G" };
break;
case "asteroid":
obj = { ...base, kind: "asteroid", diameter: 100, composition: "skala" };
break;
}
dispatch({ type: "ADD_OBJECT", payload: obj });
setName("");
nameRef.current?.focus();
};
return (
<form onSubmit={handleSubmit} className="add-form">
<select value={kind} onChange={(e: React.ChangeEvent<HTMLSelectElement>) =>
setKind(e.target.value as CosmicObject["kind"])
}>
<option value="planet">Planeta</option>
<option value="star">Gwiazda</option>
<option value="asteroid">Asteroida</option>
</select>
<input ref={nameRef} value={name} onChange={e => setName(e.target.value)} placeholder="Nazwa obiektu" />
<button type="submit">Dodaj</button>
</form>
);
}
// ===== STATYSTYKI =====
function Stats() {
const { state } = useDashboard();
const total = state.objects.length;
const planets = state.objects.filter(o => o.kind === "planet").length;
const stars = state.objects.filter(o => o.kind === "star").length;
const asteroids = state.objects.filter(o => o.kind === "asteroid").length;
return (
<div className="stats">
<div className="stat"><span className="stat-num">{total}</span><span>Razem</span></div>
<div className="stat"><span className="stat-num" style={{color:"#22c55e"}}>{planets}</span><span>Planety</span></div>
<div className="stat"><span className="stat-num" style={{color:"#f59e0b"}}>{stars}</span><span>Gwiazdy</span></div>
<div className="stat"><span className="stat-num" style={{color:"#ef4444"}}>{asteroids}</span><span>Asteroidy</span></div>
</div>
);
}
// ===== GLOWNA APLIKACJA =====
const initialState: DashboardState = {
objects: [
{ id: "1", kind: "planet", name: "Kepler-442b", discoveredYear: 2015, radius: 8200, habitable: true },
{ id: "2", kind: "star", name: "Betelgeuse", discoveredYear: 1603, temperature: 3500, spectralClass: "M" },
{ id: "3", kind: "asteroid", name: "Apophis", discoveredYear: 2004, diameter: 370, composition: "zelazo, nikiel" },
{ id: "4", kind: "planet", name: "Proxima b", discoveredYear: 2016, radius: 7100, habitable: true },
{ id: "5", kind: "star", name: "Sirius", discoveredYear: -200, temperature: 9940, spectralClass: "A" },
],
filter: "all",
searchQuery: "",
theme: "dark"
};
function Dashboard() {
const { state, dispatch } = useDashboard();
const filtered = state.objects
.filter(o => state.filter === "all" || o.kind === state.filter)
.filter(o => o.name.toLowerCase().includes(state.searchQuery.toLowerCase()));
return (
<>
<header className="header">
<h1>Dashboard Kosmiczny</h1>
<button onClick={() => dispatch({ type: "TOGGLE_THEME" })}>
{state.theme === "dark" ? "Jasny" : "Ciemny"}
</button>
</header>
<Stats />
<AddForm />
<div className="toolbar">
<input
className="search"
value={state.searchQuery}
onChange={(e: React.ChangeEvent<HTMLInputElement>) =>
dispatch({ type: "SET_SEARCH", payload: e.target.value })
}
placeholder="Szukaj..."
/>
<div className="filter-btns">
{(["all","planet","star","asteroid"] as const).map(f => (
<button key={f}
className={"fbtn " + (state.filter === f ? "active" : "")}
onClick={() => dispatch({ type: "SET_FILTER", payload: f })}
>
{f === "all" ? "Wszystkie" : f === "planet" ? "Planety" : f === "star" ? "Gwiazdy" : "Asteroidy"}
</button>
))}
</div>
</div>
<DataList<CosmicObject>
items={filtered}
renderItem={(obj) => (
<ObjectCard obj={obj} onRemove={(id) => dispatch({ type: "REMOVE_OBJECT", payload: id })} />
)}
emptyMsg="Nie znaleziono obiektow"
/>
</>
);
}
function App() {
const [state, dispatch] = useReducer(dashboardReducer, initialState);
return (
<DashboardContext.Provider value={{ state, dispatch }}>
<div className={"app " + state.theme}>
<Dashboard />
</div>
</DashboardContext.Provider>
);
}
export default App;Po tym projekcie jesteś gotów na typowane aplikacje w kolejnych światach, gdzie TypeScript będzie towarzyszył Ci w Next.js i na serwerze.
Pamiętaj: dobrze otypowany dashboard to centrum kontroli misji, w którym każdy wskaźnik pokazuje dokładnie to, co obiecuje.
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?