Kurs JavaScript i React · Moduł 14: Zaawansowane stylowanie

Zero-runtime CSS-in-JS - Kosmiczna Kompilacja Stylów

4 min czytania ·
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

Cechastyled-componentsVanilla-extractLinariaPanda CSS
Runtime JSTak (~12 KB)NieNieNie
Dynamiczne stylePełne (props)Ograniczone (recipes)OgraniczoneOgraniczone
TypeScriptDobreNatywneDobreNatywne
SSRKonfiguracjaBezproblemowyBezproblemowyBezproblemowy
DX (doświadczenie)ŚwietneDobreŚ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. 1. Co oznacza 'zero-runtime' w kontekście bibliotek CSS-in-JS?

  2. 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

  1. PytanieZero-runtime CSS-in-JS
  2. PytanieVanilla-extract -- rozszerzenie plików
  3. Zadanie z kodemPraktyka: Porównanie metod stylowania
  4. Ułóż w kolejnościImport stylu z vanilla-extract
  5. PytanieGłówna zaleta zero-runtime CSS-in-JS
  6. Zadanie z kodemPraktyka: Tabela porównania CSS-in-JS

Przydatne artykuły