Kurs JavaScript i React · Moduł 14: Zaawansowane stylowanie

CSS-in-JS - Zaawansowane Systemy Nawigacyjne

4 min czytania ·
W tej lekcji5

Styled-components to nie jedyna biblioteka CSS-in-JS. Istnieją inne, każda z unikalnymi zaletami. Poznajmy dwie najważniejsze: Emotion i vanilla-extract.

Emotion

Emotion to biblioteka CSS-in-JS, która oferuje dwa sposoby używania:

API obiektowe (@emotion/react)

/** @jsxImportSource @emotion/react */
import { css } from '@emotion/react';

function SpacePanel({ isActive }) {
  return (
    <div css={css`
      background: #0d1137;
      border: 2px solid ${isActive ? '#00e676' : '#3949ab'};
      border-radius: 12px;
      padding: 20px;
      transition: border-color 0.3s ease;
    `}>
      <h2>Navigation Panel</h2>
    </div>
  );
}

Styled API (@emotion/styled)

import styled from '@emotion/styled';

const Card = styled.div`
  background: #1a1a4e;
  padding: 20px;
  border-radius: 12px;
`;

// Lub obiektowa składnia:
const CardObj = styled.div({
  background: '#1a1a4e',
  padding: 20,
  borderRadius: 12,
});

Zalety Emotion

  • Dwa API -- możesz używać template literals lub obiektów JS
  • Lekki -- mniejszy bundle niż styled-components
  • Wysoka wydajność -- zoptymalizowany runtime
  • Prop css -- możesz dodać style bezpośrednio przez prop css

Vanilla-extract -- Zero-runtime CSS-in-JS

Vanilla-extract to zupełnie inne podejście: style są generowane w czasie kompilacji, nie w runtime. Zero JavaScript w bundlu klienta!

// styles.css.ts
import { style, globalStyle } from '@vanilla-extract/css';

export const panel = style({
  background: '#0d1137',
  border: '2px solid #3949ab',
  borderRadius: 12,
  padding: 20,
  ':hover': {
    borderColor: '#7c4dff',
  },
});

export const title = style({
  color: '#7c4dff',
  fontSize: 24,
});
// Component.tsx
import { panel, title } from './styles.css.ts';

function SpacePanel() {
  return (
    <div className={panel}>
      <h2 className={title}>Panel</h2>
    </div>
  );
}

Zalety vanilla-extract

  • Zero runtime -- brak dodatkowego JS w przeglądarce
  • TypeScript-first -- pełne typowanie, autouzupełnianie
  • Bezpieczne typy -- błąd kompilacji gdy używasz nieistniejącego stylu
  • Theming -- wbudowany system tematów ze zmiennymi CSS

Porównanie CSS-in-JS

CechaStyled-componentsEmotionVanilla-extract
RuntimeTakTakNie (zero-runtime)
BundleWiększyŚredniMinimalny
TypeScriptDobre wsparcieDobre wsparcieNatywny TS
SSRWymaga konfiguracjiWymaga konfiguracjiBezproblemowy
DXBardzo dobryBardzo dobryWymaga buildu

Kiedy użyć której biblioteki?

Wybór biblioteki CSS-in-JS zależy od kilku czynników:

Wybierz styled-components gdy:

  • Twój zespół zna już tę bibliotekę -- jest najpopularniejsza i ma największą społeczność
  • Potrzebujesz bogatego ekosystemu pluginów i narzędzi
  • Zależy ci na czytelności kodu -- tagged template literals są intuicyjne dla programistów znających CSS

Wybierz Emotion gdy:

  • Chcesz elastyczności -- możesz używać zarówno template literals, jak i obiektów JS
  • Zależy ci na mniejszym rozmiarze bundla
  • Używasz Next.js lub innego frameworka, gdzie Emotion ma lepszą integrację
  • Potrzebujesz propa css do szybkiego dodawania stylów inline-like, ale z pełną mocą CSS

Wybierz vanilla-extract gdy:

  • Wydajność jest priorytetem numer jeden -- zero JS w bundlu klienta
  • Używasz TypeScript i chcesz pełne bezpieczeństwo typów
  • Budujesz dużą aplikację, gdzie rozmiar bundla ma znaczenie
  • Nie potrzebujesz dynamicznych stylów opartych na runtime props

Trend: zero-runtime CSS-in-JS

Coraz więcej projektów przechodzi na rozwiązania zero-runtime, takie jak vanilla-extract, Panda CSS czy Linaria. Powód? W dużych aplikacjach runtime CSS-in-JS (styled-components, Emotion) może spowalniać renderowanie, ponieważ generuje style w JavaScript podczas działania aplikacji.

Zero-runtime generuje klasy CSS w czasie kompilacji -- to jak przygotowanie mapy nawigacyjnej przed startem zamiast obliczania trasy w locie. Efekt: szybsze ładowanie strony i lepsze wyniki Core Web Vitals.

// Panda CSS -- kolejna popularna zero-runtime alternatywa
import { css } from '../styled-system/css';

function Panel() {
  return (
    <div className={css({
      bg: 'slate.900',
      p: '4',
      rounded: 'xl',
      border: '2px solid',
      borderColor: 'indigo.700'
    })}>
      Panel content
    </div>
  );
}

Niezależnie od wyboru biblioteki, kluczowe jest trzymanie się jednego podejścia w ramach projektu i ustalenie konwencji z zespołem.

Kod do tej lekcji: App.jsx
import React from 'react';
import './styles.css';

// Pokaz roznych CSS-in-JS: Emotion, vanilla-extract
// (W Sandpack nie mozemy uzywac Emotion/vanilla-extract,
//  wiec demonstrujemy skladnie w formie porownania)

function CodeBlock({ title, code, language }) {
  return (
    <div className="code-block">
      <div className="code-header">
        <span className="code-lang">{language}</span>
        <span className="code-title">{title}</span>
      </div>
      <pre className="code-content">{code}</pre>
    </div>
  );
}

function ComparisonSection({ title, children }) {
  return (
    <div className="section">
      <h2 className="section-title">{title}</h2>
      {children}
    </div>
  );
}

export default function App() {
  return (
    <div className="app">
      <h1 className="heading">CSS-in-JS: Emotion vs Vanilla-extract</h1>
      <p className="subtitle">Zaawansowane biblioteki stylowania</p>

      <ComparisonSection title="Emotion -- css prop">
        <CodeBlock
          title="Inline styles z css prop"
          language="JSX"
          code={`/** @jsxImportSource @emotion/react */
import { css } from '@emotion/react';

function Panel({ isActive }) {
  return (
    <div css={css\`
      background: #0d1137;
      border: 2px solid \${isActive ? '#00e676' : '#3949ab'};
      padding: 20px;
    \`}>
      Panel content
    </div>
  );
}`}
        />
        <div className="feature-list">
          <div className="feature">
            <span className="feature-icon good">+</span>
            <span>Prop css -- style bezposrednio na elemencie</span>
          </div>
          <div className="feature">
            <span className="feature-icon good">+</span>
            <span>Mniejszy bundle niz styled-components</span>
          </div>
          <div className="feature">
            <span className="feature-icon good">+</span>
            <span>Obsluguje skladnie obiektowa i template literals</span>
          </div>
        </div>
      </ComparisonSection>

      <ComparisonSection title="Vanilla-extract -- zero runtime">
        <CodeBlock
          title="Style generowane w czasie kompilacji"
          language="TypeScript"
          code={`// styles.css.ts
import { style } from '@vanilla-extract/css';

export const panel = style({
  background: '#0d1137',
  border: '2px solid #3949ab',
  padding: 20,
  ':hover': {
    borderColor: '#7c4dff',
  },
});

// Component.tsx
import { panel } from './styles.css.ts';
<div className={panel}>Panel</div>`}
        />
        <div className="feature-list">
          <div className="feature">
            <span className="feature-icon good">+</span>
            <span>Zero runtime -- brak JS do stylow w bundlu</span>
          </div>
          <div className="feature">
            <span className="feature-icon good">+</span>
            <span>TypeScript-first -- pelne typowanie</span>
          </div>
          <div className="feature">
            <span className="feature-icon warn">!</span>
            <span>Wymaga konfiguracji buildowania</span>
          </div>
        </div>
      </ComparisonSection>

      <div className="comparison-table">
        <h2 className="section-title">Porownanie</h2>
        <table>
          <thead>
            <tr>
              <th>Cecha</th>
              <th>Styled-comp.</th>
              <th>Emotion</th>
              <th>Vanilla-extract</th>
            </tr>
          </thead>
          <tbody>
            <tr><td>Runtime JS</td><td>Tak</td><td>Tak</td><td className="highlight">Nie</td></tr>
            <tr><td>Bundle size</td><td>Duzy</td><td>Sredni</td><td className="highlight">Minimalny</td></tr>
            <tr><td>TypeScript</td><td>Dobre</td><td>Dobre</td><td className="highlight">Natywny</td></tr>
            <tr><td>SSR</td><td>Konfiguracja</td><td>Konfiguracja</td><td className="highlight">Bezproblemowy</td></tr>
            <tr><td>DX</td><td className="highlight">Swietny</td><td className="highlight">Swietny</td><td>Dobry</td></tr>
          </tbody>
        </table>
      </div>
    </div>
  );
}

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. Która biblioteka CSS-in-JS generuje style w czasie kompilacji (zero runtime)?

  2. 2. Czym różni się Emotion z css prop od styled-components?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż etapy przetwarzania stylów w vanilla-extract od początku do końca:

  • Układanie w poziomie

    Ułóż elementy potrzebne do używania prop css w Emotion:

  • Edytor kodu

    Zaimplementuj rozwijany accordion z warunkowym clsx

  • Klikanie w kolejności

    Ułóż składnię definicji stylu w vanilla-extract:

  1. PytanieZero-runtime CSS-in-JS
  2. PytanieEmotion css prop vs styled-components
  3. PytanieRuntime JS w metodach stylowania
  4. Ułóż w kolejnościEtapy przetwarzania stylów vanilla-extract
  5. Ułóż w kolejnościEmotion css prop
  6. Zadanie z kodemPraktyka: Accordion z clsx
  7. Kliknij w kolejnościDefinicja stylu w vanilla-extract

Przydatne artykuły