Kurs JavaScript i React · Moduł 7: Stylowanie i animacje

React Transition Group - Animowanie międzygwiezdnych podróży UI

9 min czytania ·
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)}>
                &times;
              </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

  1. Unikaj animowania właściwości kosztownych obliczeniowo - właściwości takie jak width, height i top mogą powodować reflow. Preferuj transform i opacity.

  2. Używaj debugera animacji - narzędzia takie jak Chrome DevTools pozwalają analizować wydajność animacji.

  3. Przemyśl punkty początku i końca - dobrze zaprojektowana animacja ma jasno określone stany.

  4. Nie przesadzaj z czasem trwania - animacje powinny być wystarczająco krótkie, aby nie opóźniać interakcji użytkownika (zazwyczaj 150-500ms).

  5. Dodaj opóźnienia dla złożonych sekwencji - używaj delay aby stworzyć kaskadowe efekty.

  6. 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:

  1. Nazwę planety
  2. Obrazek planety
  3. 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:

  1. Ułóż w kolejnościEtapy tworzenia animacji CSS w React

Przydatne artykuły