Kurs JavaScript i React · Moduł 7: Stylowanie i animacje
React Transition Group - Animowanie międzygwiezdnych podróży UI
W tej lekcji6
Poruszanie się między różnymi stanami i widokami w aplikacji kosmicznej powinno być płynne jak lot statku kosmicznego przez hiperprzestrzeń. Nagłe pojawianie się i znikanie elementów interfejsu przypomina raczej awarię systemu niż dobrze zaprojektowane doświadczenie użytkownika. W tej części misji poznamy React Transition Group - bibliotekę, która pomoże nam tworzyć płynne, kosmicznie dobre animacje przejść w naszych interfejsach.
Czym jest React Transition Group?
React Transition Group to niskopoziomowa biblioteka API dla animacji wejścia/wyjścia komponentów. W przeciwieństwie do gotowych rozwiązań animacyjnych, nie dostarcza ona predefiniowanych efektów - zamiast tego daje deweloperom pełną kontrolę nad procesem animacji poprzez zarządzanie klasami CSS lub stylami w kluczowych momentach cyklu życia komponentu.
Jest jak panel kontrolny statku kosmicznego - nie steruje bezpośrednio lotem, ale daje ci narzędzia do precyzyjnego kierowania.
Kluczowe komponenty React Transition Group
1. Transition
Podstawowy komponent niższego poziomu, który zarządza stanami przejścia komponentu:
import { Transition } from 'react-transition-group';
import React, { useState } from 'react';
// Style dla różnych stanów
const duration = 300;
const defaultStyle = {
transition: `opacity ${duration}ms ease-in-out`,
opacity: 0,
}
const transitionStyles = {
entering: { opacity: 1 },
entered: { opacity: 1 },
exiting: { opacity: 0 },
exited: { opacity: 0 },
};
function FadeExample() {
const [inProp, setInProp] = useState(false);
return (
<div>
<button onClick={() => setInProp(!inProp)}>
{inProp ? 'Zniknij' : 'Pojaw się'}
</button>
<Transition in={inProp} timeout={duration}>
{state => (
<div style={{
...defaultStyle,
...transitionStyles[state]
}}>
Komunikat z kosmosu
</div>
)}
</Transition>
</div>
);
}2. CSSTransition
Rozszerza Transition o automatyczne dodawanie/usuwanie klas CSS, co ułatwia tworzenie animacji:
import { CSSTransition } from 'react-transition-group';
import React, { useState } from 'react';
import './styles.css';
function AlertExample() {
const [showAlert, setShowAlert] = useState(false);
return (
<div>
<button onClick={() => setShowAlert(prev => !prev)}>
{showAlert ? 'Ukryj alert' : 'Pokaż alert'}
</button>
<CSSTransition
in={showAlert}
timeout={300}
classNames="alert"
unmountOnExit
>
<div className="alert">
<h4>Komunikat z centrali!</h4>
<p>Wykryto nową planetę nadającą się do kolonizacji.</p>
</div>
</CSSTransition>
</div>
);
}A w pliku CSS:
/* styles.css */
.alert {
background-color: #121a2b;
color: white;
padding: 20px;
border-radius: 8px;
box-shadow: 0 0 20px rgba(82, 161, 255, 0.5);
margin-top: 20px;
}
.alert-enter {
opacity: 0;
transform: scale(0.9);
}
.alert-enter-active {
opacity: 1;
transform: scale(1);
transition: opacity 300ms, transform 300ms;
}
.alert-exit {
opacity: 1;
transform: scale(1);
}
.alert-exit-active {
opacity: 0;
transform: scale(0.9);
transition: opacity 300ms, transform 300ms;
}3. TransitionGroup
Zarządza kolekcją komponentów Transition lub CSSTransition, idealny do animowania list:
import { TransitionGroup, CSSTransition } from 'react-transition-group';
import React, { useState } from 'react';
import './styles.css';
function StarsList() {
const [items, setItems] = useState([
{ id: 1, name: 'Alpha Centauri' },
{ id: 2, name: 'Proxima Centauri' },
{ id: 3, name: 'Betelgeuse' }
]);
const [nextId, setNextId] = useState(4);
const addStar = () => {
const newStars = [
'Sirius', 'Vega', 'Polaris', 'Canopus', 'Arcturus',
'Antares', 'Rigel', 'Procyon', 'Deneb'
];
const randomStar = newStars[Math.floor(Math.random() * newStars.length)];
setItems([...items, { id: nextId, name: randomStar }]);
setNextId(nextId + 1);
};
const removeStar = id => {
setItems(items.filter(item => item.id !== id));
};
return (
<div>
<h2>Gwiazdy do odwiedzenia</h2>
<button onClick={addStar}>Dodaj gwiazdę</button>
<TransitionGroup className="stars-list">
{items.map(({ id, name }) => (
<CSSTransition
key={id}
timeout={500}
classNames="star-item"
>
<div className="star-item">
<span>{name}</span>
<button onClick={() => removeStar(id)}>
×
</button>
</div>
</CSSTransition>
))}
</TransitionGroup>
</div>
);
}CSS do tego przykładu:
/* styles.css */
.stars-list {
margin-top: 20px;
}
.star-item {
display: flex;
justify-content: space-between;
align-items: center;
padding: 12px 20px;
margin-bottom: 10px;
background-color: #0d1b2a;
border-radius: 8px;
color: #e0f7fa;
border-left: 4px solid #4fc3f7;
}
.star-item-enter {
opacity: 0;
transform: translateX(-30px);
}
.star-item-enter-active {
opacity: 1;
transform: translateX(0);
transition: opacity 500ms, transform 500ms;
}
.star-item-exit {
opacity: 1;
}
.star-item-exit-active {
opacity: 0;
transform: translateX(30px);
transition: opacity 500ms, transform 500ms;
}Zaawansowane techniki
1. Animacje sekwencyjne
Animowanie elementów jeden po drugim dla efektu kaskadowego:
import { CSSTransition, TransitionGroup } from 'react-transition-group';
import React, { useState, useEffect } from 'react';
import './styles.css';
function LaunchSequence() {
const [steps, setSteps] = useState([]);
const allSteps = [
{ id: 1, text: "Uruchamianie systemów" },
{ id: 2, text: "Kontrola silników głównych" },
{ id: 3, text: "Sprawdzanie systemów nawigacyjnych" },
{ id: 4, text: "Zamykanie włazów" },
{ id: 5, text: "Odliczanie do startu" }
];
useEffect(() => {
if (steps.length < allSteps.length) {
const timer = setTimeout(() => {
setSteps(prevSteps => [
...prevSteps,
allSteps[prevSteps.length]
]);
}, 1000);
return () => clearTimeout(timer);
}
}, [steps]);
return (
<div className="launch-sequence">
<h2>Sekwencja startowa</h2>
<TransitionGroup>
{steps.map(step => (
<CSSTransition
key={step.id}
timeout={500}
classNames="launch-step"
>
<div className="launch-step">
<div className="step-number">{step.id}</div>
<div className="step-text">{step.text}</div>
</div>
</CSSTransition>
))}
</TransitionGroup>
</div>
);
}2. Choreografia animacji
Synchronizacja wielu animacji dla stworzenia złożonych sekwencji:
import { Transition } from 'react-transition-group';
import React, { useState } from 'react';
function SpaceshipDashboard() {
const [active, setActive] = useState(false);
// Czasy trwania dla różnych elementów
const durations = {
background: 500,
systems: 400,
controls: 600,
status: 700,
};
// Style dla różnych stanów
const getStyles = (elementName, state) => {
const baseStyles = {
transition: `all ${durations[elementName]}ms ease-out`,
};
const elementSpecificStyles = {
background: {
entering: { opacity: 1, filter: 'brightness(1)' },
entered: { opacity: 1, filter: 'brightness(1)' },
exiting: { opacity: 0.5, filter: 'brightness(0.4)' },
exited: { opacity: 0.5, filter: 'brightness(0.4)' },
},
systems: {
entering: { opacity: 1, transform: 'translateY(0)' },
entered: { opacity: 1, transform: 'translateY(0)' },
exiting: { opacity: 0, transform: 'translateY(20px)' },
exited: { opacity: 0, transform: 'translateY(20px)' },
},
controls: {
entering: { opacity: 1, transform: 'scale(1)' },
entered: { opacity: 1, transform: 'scale(1)' },
exiting: { opacity: 0, transform: 'scale(0.8)' },
exited: { opacity: 0, transform: 'scale(0.8)' },
},
status: {
entering: { opacity: 1, transform: 'translateX(0)' },
entered: { opacity: 1, transform: 'translateX(0)' },
exiting: { opacity: 0, transform: 'translateX(-20px)' },
exited: { opacity: 0, transform: 'translateX(-20px)' },
},
};
return {
...baseStyles,
...elementSpecificStyles[elementName][state],
};
};
// Początkowe style dla elementów
const initialStyles = {
background: { opacity: 0.5, filter: 'brightness(0.4)' },
systems: { opacity: 0, transform: 'translateY(20px)' },
controls: { opacity: 0, transform: 'scale(0.8)' },
status: { opacity: 0, transform: 'translateX(-20px)' },
};
return (
<div className="dashboard-container">
<button onClick={() => setActive(!active)}>
{active ? 'Wyłącz systemy' : 'Uruchom systemy'}
</button>
<div className="spaceship-dashboard">
<Transition in={active} timeout={durations.background}>
{state => (
<div
className="dashboard-background"
style={{
...initialStyles.background,
...getStyles('background', state)
}}
/>
)}
</Transition>
<Transition in={active} timeout={durations.systems}>
{state => (
<div
className="system-panels"
style={{
...initialStyles.systems,
...getStyles('systems', state)
}}
>
System Diagnostics
</div>
)}
</Transition>
<Transition in={active} timeout={durations.controls}>
{state => (
<div
className="control-panels"
style={{
...initialStyles.controls,
...getStyles('controls', state)
}}
>
Flight Controls
</div>
)}
</Transition>
<Transition in={active} timeout={durations.status}>
{state => (
<div
className="status-panels"
style={{
...initialStyles.status,
...getStyles('status', state)
}}
>
Status Monitors
</div>
)}
</Transition>
</div>
</div>
);
}Dobre praktyki dla kosmicznie płynnych animacji
Unikaj animowania właściwości kosztownych obliczeniowo - właściwości takie jak
width,heightitopmogą powodować reflow. Preferujtransformiopacity.Używaj debugera animacji - narzędzia takie jak Chrome DevTools pozwalają analizować wydajność animacji.
Przemyśl punkty początku i końca - dobrze zaprojektowana animacja ma jasno określone stany.
Nie przesadzaj z czasem trwania - animacje powinny być wystarczająco krótkie, aby nie opóźniać interakcji użytkownika (zazwyczaj 150-500ms).
Dodaj opóźnienia dla złożonych sekwencji - używaj
delayaby stworzyć kaskadowe efekty.Zadbaj o dostępność - pamiętaj o użytkownikach, którzy mogą preferować ograniczone animacje (
prefers-reduced-motion).
Przykład: Portal międzygwiezdny
Stwórzmy komponent portalu, który animuje przejście między "światami" (widokami) w naszej kosmicznej aplikacji:
import { CSSTransition } from 'react-transition-group';
import React, { useState } from 'react';
import './portal.css';
function InterstellarPortal({ children, show, onExited }) {
return (
<CSSTransition
in={show}
timeout={1000}
classNames="portal"
unmountOnExit
onExited={onExited}
>
<div className="portal-container">
<div className="portal-content">
{children}
</div>
</div>
</CSSTransition>
);
}
function App() {
const [currentWorld, setCurrentWorld] = useState('home');
const [showPortal, setShowPortal] = useState(true);
const [nextWorld, setNextWorld] = useState(null);
const worlds = {
home: {
title: "Stacja Kosmiczna Alpha",
content: "Witaj na pokładzie stacji kosmicznej Alpha, centrum dowodzenia naszej międzygwiezdnej operacji."
},
mars: {
title: "Mars Colony One",
content: "Witaj w pierwszej kolonii na Marsie. Prace terraformacyjne są w toku."
},
europa: {
title: "Podwodna baza Europa",
content: "Witaj w bazie badawczej pod lodową powłoką księżyca Jowisza - Europy."
}
};
const navigateTo = (world) => {
setNextWorld(world);
setShowPortal(false);
};
const onPortalExited = () => {
setCurrentWorld(nextWorld);
setShowPortal(true);
};
return (
<div className="app">
<nav className="navigation">
<button onClick={() => navigateTo('home')} disabled={currentWorld === 'home'}>
Stacja Alpha
</button>
<button onClick={() => navigateTo('mars')} disabled={currentWorld === 'mars'}>
Mars
</button>
<button onClick={() => navigateTo('europa')} disabled={currentWorld === 'europa'}>
Europa
</button>
</nav>
<InterstellarPortal show={showPortal} onExited={onPortalExited}>
<h1>{worlds[currentWorld].title}</h1>
<p>{worlds[currentWorld].content}</p>
</InterstellarPortal>
</div>
);
}CSS dla portalu:
/* portal.css */
.portal-container {
position: relative;
overflow: hidden;
min-height: 300px;
padding: 30px;
background: linear-gradient(135deg, #1a2a6c, #b21f1f, #fdbb2d);
border-radius: 12px;
box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
}
.portal-content {
background: rgba(0, 0, 0, 0.7);
padding: 30px;
border-radius: 8px;
color: white;
}
/* Animacja wejścia */
.portal-enter {
opacity: 0;
transform: scale(0.7);
}
.portal-enter-active {
opacity: 1;
transform: scale(1);
transition: opacity 1000ms ease-out, transform 1000ms cubic-bezier(0.34, 1.56, 0.64, 1);
}
/* Animacja wyjścia */
.portal-exit {
opacity: 1;
transform: scale(1);
}
.portal-exit-active {
opacity: 0;
transform: scale(1.3);
transition: opacity 1000ms ease-in, transform 1000ms cubic-bezier(0.36, 0, 0.66, -0.56);
}
/* Styl dla nawigacji */
.navigation {
display: flex;
justify-content: center;
gap: 15px;
margin-bottom: 30px;
}
.navigation button {
background-color: #2c3e50;
color: white;
border: none;
padding: 10px 15px;
border-radius: 5px;
cursor: pointer;
transition: all 0.3s;
}
.navigation button:hover:not(:disabled) {
background-color: #34495e;
transform: translateY(-2px);
}
.navigation button:disabled {
background-color: #95a5a6;
cursor: not-allowed;
}Zadanie praktyczne: Stwórz animowaną galerię planet
Zaprojektuj i zaimplementuj animowaną galerię planet w naszym układzie słonecznym. Kiedy użytkownik nawiguje między planetami, użyj React Transition Group, aby stworzyć płynne przejścia między widokami. Dla każdej planety wyświetl:
- Nazwę planety
- Obrazek planety
- Kilka kluczowych faktów (rozmiar, odległość od Słońca, temperatura)
Dodaj następujące animacje:
- Płynne przejście między planetami
- Efekt kaskadowy dla wyświetlania faktów o planecie
- Przycisk "Powrót do przeglądu" z animacją przejścia
Pamiętaj, że dobra animacja wzmacnia doświadczenie użytkownika, nie rozprasza go. Animacje powinny być płynne i naturalne, jak sama podróż przez kosmos - elegancka, majestatyczna i inspirująca.
Kod do tej lekcji: App.jsx
import React, { useState, useRef } from 'react';
import './styles.css';
// ===== SYMULACJA REACT TRANSITION GROUP =====
// Sandpack nie obsługuje react-transition-group,
// więc implementujemy animacje CSS z klasami przejść
// Komponent CSSTransition - uproszczona wersja
function CSSTransition({ inProp, timeout, children, classNames, unmountOnExit }) {
const [mounted, setMounted] = React.useState(inProp);
const [animClass, setAnimClass] = React.useState('');
React.useEffect(() => {
if (inProp) {
setMounted(true);
setAnimClass(classNames + '-enter');
requestAnimationFrame(() => {
requestAnimationFrame(() => {
setAnimClass(classNames + '-enter-active');
});
});
} else {
setAnimClass(classNames + '-exit');
requestAnimationFrame(() => {
requestAnimationFrame(() => {
setAnimClass(classNames + '-exit-active');
});
});
const timer = setTimeout(() => {
if (unmountOnExit) setMounted(false);
}, timeout);
return () => clearTimeout(timer);
}
}, [inProp]);
if (!mounted && unmountOnExit) return null;
return (
<div className={animClass}>
{children}
</div>
);
}
// ===== DEMO 1: Fade In/Out =====
function FadeDemo() {
const [show, setShow] = useState(false);
return (
<div className="demo-section">
<h3>Fade In / Out</h3>
<button
className="demo-btn"
onClick={() => setShow(!show)}
>
{show ? 'Ukryj' : 'Pokaż'} komunikat
</button>
<CSSTransition
inProp={show}
timeout={400}
classNames="fade"
unmountOnExit
>
<div className="alert-box">
Wykryto nową planetę nadającą się do kolonizacji!
</div>
</CSSTransition>
</div>
);
}
// ===== DEMO 2: Lista z animacjami =====
function AnimatedList() {
const [items, setItems] = useState([
{ id: 1, name: 'Alpha Centauri', visible: true },
{ id: 2, name: 'Proxima Centauri', visible: true },
{ id: 3, name: 'Betelgeuse', visible: true },
]);
const nextId = useRef(4);
const starNames = [
'Sirius', 'Vega', 'Polaris', 'Canopus',
'Arcturus', 'Antares', 'Rigel', 'Procyon',
];
const addStar = () => {
const name = starNames[Math.floor(Math.random() * starNames.length)];
const newItem = { id: nextId.current++, name, visible: false };
setItems(prev => [...prev, newItem]);
// Uruchom animację wejścia po montowaniu
setTimeout(() => {
setItems(prev =>
prev.map(item =>
item.id === newItem.id ? { ...item, visible: true } : item
)
);
}, 50);
};
const removeStar = (id) => {
// Najpierw uruchom animację wyjścia
setItems(prev =>
prev.map(item =>
item.id === id ? { ...item, visible: false } : item
)
);
// Potem usuń element
setTimeout(() => {
setItems(prev => prev.filter(item => item.id !== id));
}, 500);
};
return (
<div className="demo-section">
<h3>Animowana lista gwiazd</h3>
<button className="demo-btn" onClick={addStar}>
+ Dodaj gwiazdę
</button>
<div className="star-list">
{items.map(item => (
<div
key={item.id}
className={"star-item " + (item.visible ? 'star-item-enter-active' : 'star-item-exit-active')}
>
<span>{item.name}</span>
<button
className="remove-btn"
onClick={() => removeStar(item.id)}
>
×
</button>
</div>
))}
</div>
</div>
);
}
// TODO: Stwórz komponent SlideDemo z animacją slide
// Komponent powinien:
// 1. Mieć przycisk do przełączania widoczności
// 2. Animować element z przesunięciem od góry (translateY)
// 3. Użyć klas CSS: slide-enter, slide-enter-active, slide-exit-active
function SlideDemo() {
const [show, setShow] = useState(false);
return (
<div className="demo-section">
<h3>Slide Transition</h3>
<button className="demo-btn" onClick={() => setShow(!show)}>
{show ? 'Zwiń' : 'Rozwiń'} panel
</button>
{/* TODO: Dodaj animowany panel z klasą slide */}
{/* Użyj CSSTransition lub ręcznej logiki klas */}
<CSSTransition
inProp={show}
timeout={400}
classNames="slide"
unmountOnExit
>
<div className="slide-panel">
<h4>Panel sterowania misją</h4>
<p>Status silników: ONLINE</p>
<p>Kurs: Alpha Centauri</p>
<p>ETA: 4.37 lat świetlnych</p>
</div>
</CSSTransition>
</div>
);
}
// ===== GŁÓWNA APLIKACJA =====
function App() {
return (
<div className="app-container">
<h1 className="app-title">React Transition Group</h1>
<p className="app-subtitle">Animacje przejść w kosmicznej aplikacji</p>
<FadeDemo />
<AnimatedList />
<SlideDemo />
</div>
);
}
export default App;Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj kroki dodawania animacji CSS do komponentu React: