Kurs JavaScript i React · Moduł 14: Zaawansowane stylowanie
Design Tokens i Systematyczny CSS - Kosmiczny Kod Designu
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. Czym są design tokens w kontekście frontendu?
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
Zadania po tej lekcji
- PytanieCzym są design tokens
- Ułóż w kolejnościUżycie tokenu w CSS
- PytanieKolory semantyczne vs bazowe
- Ułóż w kolejnościDefinicja tokenu spacing
- Kliknij w kolejnościToken na CSS Variable
- Ułóż w kolejnościWarstwy systemu design tokens
- Ułóż w kolejnościWdrażanie design tokens w projekcie
- PytanieZalety skali spacingowej
- Zadanie z kodemPraktyka: Komponent z design tokens
- PytanieTokeny vs zakodowane wartości
- Ułóż w kolejnościSkala rozmiarów czcionek od najmniejszej
- Zadanie z kodemPraktyka: Podgląd tokenów kolorowych