Kurs JavaScript i React · Moduł 14: Zaawansowane stylowanie
Zero-runtime CSS-in-JS - Kosmiczna Kompilacja Stylów
W tej lekcji8
Pilotze, wyobraź sobie dwa typy silników statku kosmicznego. Pierwszy oblicza trasę lotu w locie -- zużywa paliwo na bieżąco (runtime CSS-in-JS jak styled-components). Drugi oblicza trasę przed startem i zapisuje ją w komputerze pokładowym -- podczas lotu nie zużywa dodatkowej energii (zero-runtime CSS-in-JS). W świecie frontendu to różnica między podejściami runtime i zero-runtime do stylowania.
Problem runtime CSS-in-JS
Styled-components i Emotion działają tak: za każdym razem gdy React renderuje komponent, biblioteka w runtime parsuje template literal, generuje unikalny hash klasy i wstrzykuje <style> tag do DOM. To oznacza:
// Styled-components -- runtime
const Card = styled.div`
background: ${({ theme }) => theme.colors.surface};
padding: ${({ theme }) => theme.spacing.lg};
border-radius: 12px;
`;
// Za każdym renderem: parsuj template -> generuj hash -> wstrzyknij <style>Problemy:
- Większy bundle -- biblioteka (~12-15 KB gzip) musi być załadowana
- Wolniejsze renderowanie -- generowanie stylów w runtime kosztuje czas
- SSR komplikacje -- style muszą być wyciągnięte i wstrzyknięte do HTML
Czym jest zero-runtime CSS-in-JS?
Zero-runtime CSS-in-JS to podejście, gdzie style są generowane w czasie kompilacji (build time) -- wynikowy kod nie zawiera żadnego JavaScript do obsługi stylów. Piszesz style w TypeScript, a bundler zamienia je na zwykły plik CSS.
Vanilla-extract -- TypeScript-first styling
Vanilla-extract to najpopularniejsza biblioteka zero-runtime. Style definiujesz w plikach .css.ts:
// styles.css.ts -- plik ze stylami
import { style } from '@vanilla-extract/css';
export const card = style({
background: '#1a1a4e',
border: '2px solid #3949ab',
borderRadius: '12px',
padding: '20px',
transition: 'all 0.3s ease',
':hover': {
borderColor: '#7c4dff',
transform: 'translateY(-2px)',
},
});
export const heading = style({
color: '#7c4dff',
fontSize: '20px',
marginBottom: '16px',
});W komponencie React importujesz klasy jak zwykły string:
// Component.tsx
import { card, heading } from './styles.css.ts';
function MissionCard({ title, children }) {
return (
<div className={card}>
<h3 className={heading}>{title}</h3>
{children}
</div>
);
}Po kompilacji card i heading to zwykłe stringi z nazwami klas CSS -- zero JavaScript w runtime.
Sprinkles -- typowane klasy użytkowe
Vanilla-extract oferuje sprinkles -- typowany odpowiednik klas użytkowych (jak Tailwind, ale z pełnym typowaniem TypeScript):
// sprinkles.css.ts
import { defineProperties, createSprinkles } from '@vanilla-extract/sprinkles';
const responsiveProperties = defineProperties({
conditions: {
mobile: {},
tablet: { '@media': 'screen and (min-width: 768px)' },
desktop: { '@media': 'screen and (min-width: 1024px)' },
},
defaultCondition: 'mobile',
properties: {
display: ['none', 'flex', 'block', 'grid'],
padding: { sm: '8px', md: '16px', lg: '24px' },
gap: { sm: '8px', md: '16px', lg: '24px' },
},
});
export const sprinkles = createSprinkles(responsiveProperties);Użycie:
<div className={sprinkles({
display: { mobile: 'block', tablet: 'grid' },
padding: { mobile: 'sm', desktop: 'lg' },
gap: 'md',
})}>Wszystko jest typowane -- TypeScript podpowie dostępne wartości i złapie literówki.
Linaria -- zero-runtime z składnią styled-components
Linaria oferuje składnię identyczną jak styled-components, ale kompiluje style w build time:
import { styled } from '@linaria/react';
const Card = styled.div`
background: #1a1a4e;
border: 2px solid #3949ab;
border-radius: 12px;
padding: 20px;
&:hover {
border-color: #7c4dff;
}
`;Wygląda identycznie jak styled-components, ale po kompilacji Card renderuje <div className="hash123"> -- bez runtime JS.
Panda CSS -- nowoczesna alternatywa
Panda CSS to najnowszy gracz -- łączy podejście utility-first (jak Tailwind) z typowaniem i zero-runtime:
import { css } from '../styled-system/css';
function MissionPanel() {
return (
<div className={css({
bg: 'surface',
p: '6',
borderRadius: 'lg',
border: '2px solid',
borderColor: 'border',
_hover: { borderColor: 'primary' },
})}>
Panel misji
</div>
);
}Panda generuje CSS atomowe (jak Tailwind) w build time -- każda właściwość to osobna klasa, co minimalizuje duplikację.
Porównanie: runtime vs zero-runtime
| Cecha | styled-components | Vanilla-extract | Linaria | Panda CSS |
|---|---|---|---|---|
| Runtime JS | Tak (~12 KB) | Nie | Nie | Nie |
| Dynamiczne style | Pełne (props) | Ograniczone (recipes) | Ograniczone | Ograniczone |
| TypeScript | Dobre | Natywne | Dobre | Natywne |
| SSR | Konfiguracja | Bezproblemowy | Bezproblemowy | Bezproblemowy |
| DX (doświadczenie) | Świetne | Dobre | Świetne | Świetne |
Kiedy wybrać zero-runtime?
- Duże aplikacje -- każdy kilobajt runtime się liczy
- SSR (Next.js, Remix) -- brak problemów z hydratacją stylów
- TypeScript-first -- pełne typowanie wartości CSS
- Wydajność -- brak kosztu runtime = szybsze renderowanie
Kod do tej lekcji: App.jsx
import React, { useState } from 'react';
import './styles.css';
// Porownanie: runtime vs zero-runtime CSS-in-JS
// W Sandpack nie mozemy uzywac vanilla-extract/Linaria/Panda,
// wiec demonstrujemy koncept 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 ApproachCard({ name, desc, runtime, bundle, typescript, ssr, active, onClick }) {
return (
<div className={`approach-card ${active ? 'approach-active' : ''}`} onClick={onClick}>
<h3 className="approach-name">{name}</h3>
<p className="approach-desc">{desc}</p>
<div className="approach-badges">
<span className={`badge ${runtime === 'Zero' ? 'badge-green' : 'badge-red'}`}>
Runtime: {runtime}
</span>
<span className={`badge ${bundle === 'Minimalny' ? 'badge-green' : 'badge-yellow'}`}>
Bundle: {bundle}
</span>
<span className={`badge ${typescript === 'Natywne' ? 'badge-green' : 'badge-blue'}`}>
TS: {typescript}
</span>
<span className={`badge ${ssr === 'Bezproblemowy' ? 'badge-green' : 'badge-yellow'}`}>
SSR: {ssr}
</span>
</div>
</div>
);
}
const approaches = [
{
name: 'Vanilla-extract',
desc: 'TypeScript-first, zero-runtime. Style w plikach .css.ts',
runtime: 'Zero', bundle: 'Minimalny', typescript: 'Natywne', ssr: 'Bezproblemowy',
code: `// styles.css.ts
import { style } from '@vanilla-extract/css';
export const card = style({
background: '#1a1a4e',
border: '2px solid #3949ab',
borderRadius: '12px',
padding: '20px',
':hover': {
borderColor: '#7c4dff',
},
});
// Component.tsx
import { card } from './styles.css.ts';
<div className={card}>Panel misji</div>`,
},
{
name: 'Linaria',
desc: 'Skladnia styled-components, ale zero-runtime',
runtime: 'Zero', bundle: 'Minimalny', typescript: 'Dobre', ssr: 'Bezproblemowy',
code: `import { styled } from '@linaria/react';
const Card = styled.div\`
background: #1a1a4e;
border: 2px solid #3949ab;
border-radius: 12px;
padding: 20px;
&:hover {
border-color: #7c4dff;
}
\`;
// Wyglada jak styled-components
// ale kompiluje sie do zwyklego CSS`,
},
{
name: 'Panda CSS',
desc: 'Utility-first + zero-runtime. Nowoczesna alternatywa',
runtime: 'Zero', bundle: 'Minimalny', typescript: 'Natywne', ssr: 'Bezproblemowy',
code: `import { css } from '../styled-system/css';
function Panel() {
return (
<div className={css({
bg: 'surface',
p: '6',
borderRadius: 'lg',
border: '2px solid',
borderColor: 'border',
_hover: { borderColor: 'primary' },
})}>
Panel misji
</div>
);
}`,
},
{
name: 'Styled-components (runtime)',
desc: 'Pelne dynamiczne style, ale z kosztem runtime JS',
runtime: '~12KB', bundle: 'Duzy', typescript: 'Dobre', ssr: 'Konfiguracja',
code: `import styled from 'styled-components';
const Card = styled.div\`
background: \${({ theme }) => theme.colors.surface};
border: 2px solid \${({ active }) =>
active ? '#7c4dff' : '#3949ab'};
border-radius: 12px;
padding: 20px;
\`;
// Pelne dynamiczne style z propsami
// ale runtime JS parsuje template przy kazdym renderze`,
},
];
export default function App() {
const [selected, setSelected] = useState(0);
return (
<div className="app">
<h1 className="heading">Zero-runtime CSS-in-JS</h1>
<p className="subtitle">Porownanie podejsc: build-time vs runtime</p>
<div className="grid">
{approaches.map((a, i) => (
<ApproachCard key={a.name} {...a} active={i === selected} onClick={() => setSelected(i)} />
))}
</div>
<div className="detail-panel">
<h2 className="detail-title">{approaches[selected].name} -- przykladowy kod</h2>
<CodeBlock
title={approaches[selected].name}
language={approaches[selected].name === 'Vanilla-extract' ? 'TypeScript' : 'JSX'}
code={approaches[selected].code}
/>
</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. Co oznacza 'zero-runtime' w kontekście bibliotek CSS-in-JS?
2. W jakim formacie pliku definiujemy style w vanilla-extract?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Zaimplementuj porównanie metod stylowania z warunkowym podświetleniem
- Układanie w poziomie
Ułóż składnię importu stylu z pliku vanilla-extract w komponencie:
- Edytor kodu
Zaimplementuj tabelę porównania podejść CSS-in-JS z podświetleniem