Kurs JavaScript i React · Moduł 14: Zaawansowane stylowanie

Design Tokens i Systematyczny CSS - Kosmiczny Kod Designu

5 min czytania ·
W tej lekcji10

Pilotze, wyobraź sobie, że każdy statek w flocie galaktycznej używa dokładnie tych samych kolorów statusu, tych samych odstępów między panelami i tej samej typografii na monitorach. To nie przypadek -- to design system. W świecie frontendu odpowiednikiem są design tokens -- centralne źródło prawdy dla wszystkich wartości wizualnych w aplikacji.

Czym są Design Tokens?

Design tokens to nazwane wartości reprezentujące decyzje designowe: kolory, odstępy, rozmiary czcionek, cienie, promienie zaokrągleń. Zamiast rozrzucać magiczne liczby po kodzie, definiujesz je w jednym miejscu:

// tokens.js -- centralne źródło prawdy
const tokens = {
  colors: {
    primary: '#7c4dff',
    primaryLight: '#b388ff',
    primaryDark: '#651fff',
    success: '#00e676',
    warning: '#ffa726',
    danger: '#f44336',
    bgDark: '#0a0a2e',
    bgSurface: '#1a1a4e',
    textPrimary: '#e0e0e0',
    textMuted: '#9e9e9e',
    border: '#3949ab',
  },
  spacing: {
    xs: '4px',
    sm: '8px',
    md: '16px',
    lg: '24px',
    xl: '32px',
    xxl: '48px',
  },
  fontSize: {
    xs: '12px',
    sm: '14px',
    md: '16px',
    lg: '20px',
    xl: '28px',
    xxl: '36px',
  },
  borderRadius: {
    sm: '4px',
    md: '8px',
    lg: '12px',
    xl: '20px',
    full: '9999px',
  },
  shadows: {
    sm: '0 2px 4px rgba(0,0,0,0.1)',
    md: '0 4px 12px rgba(0,0,0,0.2)',
    lg: '0 8px 24px rgba(0,0,0,0.3)',
    glow: '0 0 20px rgba(124,77,255,0.3)',
  },
};

Używanie tokenów w komponentach

Gdy masz zdefiniowane tokeny, używasz ich zamiast bezpośrednich wartości:

import { tokens } from './tokens';

// W inline styles
function Card({ children }) {
  return (
    <div style={{
      background: tokens.colors.bgSurface,
      padding: tokens.spacing.lg,
      borderRadius: tokens.borderRadius.lg,
      border: `1px solid ${tokens.colors.border}`,
    }}>
      {children}
    </div>
  );
}
// W styled-components
const Card = styled.div`
  background: ${tokens.colors.bgSurface};
  padding: ${tokens.spacing.lg};
  border-radius: ${tokens.borderRadius.lg};
  border: 1px solid ${tokens.colors.border};
`;

Tokeny jako CSS Variables

Najlepszy sposób to połączenie tokenów JavaScript z CSS Variables -- definiujesz tokeny w JS (łatwe do zarządzania), a przekazujesz do CSS jako zmienne (wydajne renderowanie):

function applyTokens(tokens) {
  const vars = {};
  vars['--color-primary'] = tokens.colors.primary;
  vars['--color-bg'] = tokens.colors.bgDark;
  vars['--color-surface'] = tokens.colors.bgSurface;
  vars['--color-text'] = tokens.colors.textPrimary;
  vars['--spacing-md'] = tokens.spacing.md;
  vars['--spacing-lg'] = tokens.spacing.lg;
  vars['--radius-lg'] = tokens.borderRadius.lg;
  return vars;
}

function App() {
  return (
    <div style={applyTokens(tokens)} className="app">
      {/* CSS używa var(--color-primary) itd. */}
    </div>
  );
}

Spójny system kolorów

Dobry system kolorów ma strukturę:

const colorSystem = {
  // Kolory bazowe
  blue: { 50: '#e3f2fd', 100: '#bbdefb', 500: '#2196f3', 900: '#0d47a1' },
  purple: { 50: '#f3e5f5', 100: '#e1bee7', 500: '#9c27b0', 900: '#4a148c' },

  // Kolory semantyczne (używane w kodzie)
  primary: 'var(--blue-500)',
  success: 'var(--green-500)',
  warning: 'var(--orange-500)',
  danger: 'var(--red-500)',

  // Kolory powierzchni
  background: '#0a0a2e',
  surface: '#1a1a4e',
  surfaceHover: '#2a2a5e',
};

Kolory semantyczne (primary, success, danger) oddzielasz od kolorów bazowych (blue-500, red-400). Dzięki temu zmiana motywu to zmiana mapowania, nie szukanie po całym kodzie.

System spacingu

Spacing (odstępy) oparty na skali -- każda następna wartość jest wielokrotnością bazowej:

// Skala 4px (Tailwind-style)
const spacing = {
  0: '0px',
  1: '4px',
  2: '8px',
  3: '12px',
  4: '16px',
  5: '20px',
  6: '24px',
  8: '32px',
  10: '40px',
  12: '48px',
  16: '64px',
};

Używanie skali zamiast dowolnych wartości gwarantuje wizualną spójność -- elementy na ekranie są równomiernie rozmieszczone, co daje profesjonalny wygląd.

Typografia jako system

const typography = {
  fontFamily: {
    sans: "'Inter', 'Segoe UI', sans-serif",
    mono: "'Fira Code', monospace",
  },
  fontSize: {
    xs: ['12px', { lineHeight: '16px' }],
    sm: ['14px', { lineHeight: '20px' }],
    base: ['16px', { lineHeight: '24px' }],
    lg: ['20px', { lineHeight: '28px' }],
    xl: ['28px', { lineHeight: '36px' }],
    '2xl': ['36px', { lineHeight: '44px' }],
  },
  fontWeight: {
    normal: 400,
    medium: 500,
    semibold: 600,
    bold: 700,
  },
};

Każdy rozmiar czcionki ma przyporządkowaną wysokość linii -- to eliminuje chaos typograficzny.

Token Composition -- składanie tokenów

Zaawansowany wzorzec to składanie tokenów -- tworzenie bardziej szczegółowych tokenów z bazowych:

// Tokeny bazowe (primitive)
const primitives = {
  blue500: '#7c4dff',
  blue300: '#b388ff',
  green500: '#00e676',
  red500: '#f44336',
  gray900: '#0a0a2e',
  gray800: '#1a1a4e',
  gray100: '#e0e0e0',
  gray400: '#9e9e9e',
};

// Tokeny semantyczne (złożone z bazowych)
const semantic = {
  colorPrimary: primitives.blue500,
  colorPrimaryLight: primitives.blue300,
  colorSuccess: primitives.green500,
  colorDanger: primitives.red500,
  colorBackground: primitives.gray900,
  colorSurface: primitives.gray800,
  colorText: primitives.gray100,
  colorTextMuted: primitives.gray400,
};

// Tokeny komponentowe (złożone z semantycznych)
const components = {
  buttonPrimaryBg: semantic.colorPrimary,
  buttonPrimaryText: '#ffffff',
  buttonDangerBg: semantic.colorDanger,
  cardBg: semantic.colorSurface,
  cardBorder: primitives.blue500 + '40',
};

Trzy warstwy: bazowe (wartości) -> semantyczne (znaczenie) -> komponentowe (użycie). Zmiana jednego bazowego tokenu kaskadowo aktualizuje wszystko.

Style Dictionary -- automatyzacja tokenów

W dużych projektach tokeny przechowuje się w formacie JSON i automatycznie generuje pliki dla różnych platform za pomocą narzędzia Style Dictionary:

{
  "color": {
    "primary": { "value": "#7c4dff" },
    "success": { "value": "#00e676" },
    "background": { "value": "#0a0a2e" }
  },
  "spacing": {
    "sm": { "value": "8px" },
    "md": { "value": "16px" },
    "lg": { "value": "24px" }
  }
}

Style Dictionary generuje z tego:

  • CSS Variables -- dla aplikacji webowych
  • JavaScript/TypeScript -- dla React
  • Swift/Kotlin -- dla aplikacji mobilnych

Jedno źródło prawdy, wiele formatów wyjściowych.

Automatyzacja spójności

Tworzenie komponentu TokenPreview pomaga kontrolować cały system:

function TokenPreview({ tokens }) {
  return (
    <div>
      <h2>Kolory</h2>
      {Object.entries(tokens.colors).map(([name, value]) => (
        <div key={name} style={{ display: 'flex', alignItems: 'center', gap: '12px' }}>
          <div style={{ width: 40, height: 40, background: value, borderRadius: 8 }} />
          <span>{name}: {value}</span>
        </div>
      ))}

      <h2>Spacing</h2>
      {Object.entries(tokens.spacing).map(([name, value]) => (
        <div key={name} style={{ display: 'flex', alignItems: 'center', gap: '12px' }}>
          <div style={{ width: value, height: 16, background: '#7c4dff' }} />
          <span>{name}: {value}</span>
        </div>
      ))}
    </div>
  );
}

Kiedy używać design tokens?

  • Każdy projekt większy niż landing page -- tokeny oszczędzają czas w dłuższej perspektywie
  • Praca zespołowa -- każdy developer używa tych samych wartości
  • Wiele motywów -- zmiana jednego obiektu zmienia cały wygląd
  • Spójność między platformami -- Style Dictionary generuje tokeny dla React, React Native, iOS, Android
  • Składanie tokenów -- trzy warstwy (bazowe -> semantyczne -> komponentowe) dają pełną kontrolę
Kod do tej lekcji: App.jsx
import React, { useState } from 'react';
import './styles.css';

// Design tokens -- centralne zrodlo prawdy
const tokens = {
  colors: {
    primary: '#7c4dff', primaryLight: '#b388ff', primaryDark: '#651fff',
    success: '#00e676', warning: '#ffa726', danger: '#f44336',
    bgDark: '#0a0a2e', bgSurface: '#1a1a4e',
    textPrimary: '#e0e0e0', textMuted: '#9e9e9e', border: '#3949ab',
  },
  spacing: { xs: '4px', sm: '8px', md: '16px', lg: '24px', xl: '32px' },
  fontSize: { xs: '12px', sm: '14px', md: '16px', lg: '20px', xl: '28px' },
  borderRadius: { sm: '4px', md: '8px', lg: '12px', full: '9999px' },
};

// Konwersja tokenow na CSS Variables
function tokensToVars(t) {
  return {
    '--color-primary': t.colors.primary,
    '--color-primary-light': t.colors.primaryLight,
    '--color-success': t.colors.success,
    '--color-warning': t.colors.warning,
    '--color-danger': t.colors.danger,
    '--color-bg': t.colors.bgDark,
    '--color-surface': t.colors.bgSurface,
    '--color-text': t.colors.textPrimary,
    '--color-text-muted': t.colors.textMuted,
    '--color-border': t.colors.border,
    '--spacing-sm': t.spacing.sm,
    '--spacing-md': t.spacing.md,
    '--spacing-lg': t.spacing.lg,
    '--radius-lg': t.borderRadius.lg,
  };
}

// Podglad kolorow
function ColorSwatch({ name, value }) {
  return (
    <div className="swatch">
      <div className="swatch-color" style={{ background: value }} />
      <div className="swatch-info">
        <span className="swatch-name">{name}</span>
        <span className="swatch-value">{value}</span>
      </div>
    </div>
  );
}

// Podglad spacing
function SpacingBar({ name, value }) {
  return (
    <div className="spacing-row">
      <span className="spacing-name">{name}</span>
      <div className="spacing-bar" style={{ width: value, background: 'var(--color-primary)' }} />
      <span className="spacing-value">{value}</span>
    </div>
  );
}

// Przyklad uzycia tokenow w komponencie
function TokenCard({ title, children }) {
  return (
    <div className="token-card">
      <h3 className="token-card-title">{title}</h3>
      {children}
    </div>
  );
}

function TokenButton({ variant, children }) {
  return (
    <button className={`token-btn token-btn-${variant}`}>{children}</button>
  );
}

export default function App() {
  return (
    <div style={tokensToVars(tokens)} className="app">
      <h1 className="heading">Design Tokens</h1>
      <p className="subtitle">Centralne zrodlo prawdy -- wszystkie wartosci w jednym miejscu</p>

      <TokenCard title="Kolory">
        <div className="swatch-grid">
          {Object.entries(tokens.colors).map(([name, value]) => (
            <ColorSwatch key={name} name={name} value={value} />
          ))}
        </div>
      </TokenCard>

      <TokenCard title="Spacing">
        {Object.entries(tokens.spacing).map(([name, value]) => (
          <SpacingBar key={name} name={name} value={value} />
        ))}
      </TokenCard>

      <TokenCard title="Komponenty uzywajace tokenow">
        <div className="component-demo">
          <TokenButton variant="primary">Primary</TokenButton>
          <TokenButton variant="success">Success</TokenButton>
          <TokenButton variant="danger">Danger</TokenButton>
          <TokenButton variant="outline">Outline</TokenButton>
        </div>
        <p className="demo-note">
          Kazdy przycisk uzywa var(--color-...) z tokenow.
          Zmiana tokenu zmienia wszystkie komponenty naraz!
        </p>
      </TokenCard>
    </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. Czym są design tokens w kontekście frontendu?

  2. 2. Dlaczego w systemie design tokens warto oddzielać kolory semantyczne (primary, danger) od bazowych (blue-500, red-400)?

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

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż składnię użycia tokenu koloru w CSS z CSS Variable:

  • Układanie w poziomie

    Ułóż składnię definicji tokenu spacing w obiekcie JavaScript:

  • Klikanie w kolejności

    Ułóż kroki konwersji tokenu JavaScript na CSS Variable w React:

  • Układanie w pionie

    Ułóż warstwy systemu design tokens od najbardziej podstawowej do najbardziej konkretnej:

  • Układanie w pionie

    Ułóż kroki wdrażania design tokens w nowym projekcie React:

  • Edytor kodu

    Stwórz system design tokens i użyj go w komponencie

  • Układanie w pionie

    Ułóż tokeny rozmiarów czcionek od najmniejszego do największego:

  • Edytor kodu

    Stwórz wizualny podgląd tokenów kolorowych

  1. PytanieCzym są design tokens
  2. Ułóż w kolejnościUżycie tokenu w CSS
  3. PytanieKolory semantyczne vs bazowe
  4. Ułóż w kolejnościDefinicja tokenu spacing
  5. Kliknij w kolejnościToken na CSS Variable
  6. Ułóż w kolejnościWarstwy systemu design tokens
  7. Ułóż w kolejnościWdrażanie design tokens w projekcie
  8. PytanieZalety skali spacingowej
  9. Zadanie z kodemPraktyka: Komponent z design tokens
  10. PytanieTokeny vs zakodowane wartości
  11. Ułóż w kolejnościSkala rozmiarów czcionek od najmniejszej
  12. Zadanie z kodemPraktyka: Podgląd tokenów kolorowych

Przydatne artykuły