Kurs JavaScript i React · Moduł 7: Stylowanie i animacje

Sass (SCSS) - Kosmiczna syntaktyczna supersiła

12 min czytania ·
W tej lekcji9

W kosmosie stylowania React, Sass (Syntactically Awesome Style Sheets) jest jak statek kosmiczny nowej generacji - oferuje wszystkie możliwości standardowego CSS, ale z dodatkowymi mocami, które czynią stylowanie bardziej wydajnym, modułowym i łatwiejszym w utrzymaniu. Poruszając się w galaktyce React, warto opanować tę technologię, która może znacząco usprawnić tworzenie zaawansowanych stylizacji.

Czym jest Sass/SCSS?

Sass to preprocesor CSS, który rozszerza standardowy CSS o zmienne, zagnieżdżone reguły, mixiny, dziedziczenie selektorów i wiele innych funkcji. Istnieją dwie składnie Sass:

  1. Składnia indentacyjna (.sass) - oparta na wcięciach, bez nawiasów klamrowych i średników
  2. SCSS (.scss) - nowsza składnia, która jest nadzbiorem CSS (każdy poprawny CSS jest poprawnym SCSS)

W tym module skupimy się na SCSS, ponieważ jest bardziej popularna i łatwiejsza do nauki dla osób znających CSS. Wyobraźmy sobie SCSS jako ulepszone paliwo rakietowe, które zachowuje wszystkie właściwości standardowego paliwa, ale dodaje więcej mocy.

Konfiguracja Sass w projekcie React

Aby używać Sass w projekcie React, najpierw musimy zainstalować odpowiednie pakiety:

Create React App

Jeśli korzystasz z Create React App, instalacja jest prosta:

npm install sass

To wszystko! CRA ma wbudowaną obsługę Sass, więc po instalacji możesz po prostu tworzyć pliki .scss/.sass i importować je do komponentów.

Vite

W projektach Vite, proces jest podobny:

npm install sass

Vite ma natywne wsparcie dla Sass, więc nie potrzeba dodatkowej konfiguracji.

Inne konfiguracje (np. własny Webpack)

Jeśli tworzysz własną konfigurację, potrzebujesz:

npm install sass sass-loader

I dodać odpowiednią konfigurację do pliku webpack.config.js:

// Uproszczona konfiguracja webpack
module.exports = {
  //
  module: {
    rules: [
      {
        test: /\.s[ac]ss$/i,
        use: [
          'style-loader',
          'css-loader',
          'sass-loader',
        ],
      },
    ],
  },
};

Używanie SCSS w projekcie React

Po skonfigurowaniu, możesz tworzyć pliki SCSS i importować je do komponentów:

// SpacePanel.jsx
import React from 'react';
import './SpacePanel.scss'; // Importujemy SCSS zamiast CSS

function SpacePanel() {
  return (
    <div className="space-panel">
      <h2 className="panel-title">Panel Sterowania Statkiem</h2>
      <div className="control-area">
        <div className="button-group">
          <button className="control-button primary">Uruchom silniki</button>
          <button className="control-button secondary">Nawigacja</button>
        </div>
        <div className="status-display">Status: Gotowy do startu</div>
      </div>
    </div>
  );
}

export default SpacePanel;

Kluczowe funkcje SCSS

1. Zmienne

W kosmicznym interfejsie, często używamy tych samych kolorów, marginesów czy fontów. Zmienne SCSS pozwalają nam zdefiniować je raz i używać wielokrotnie:

// variables.scss
$primary-color: #8a2be2;      // Kosmiczny fiolet
$secondary-color: #4a90e2;    // Niebieski kosmosu
$danger-color: #ff4d4f;       // Czerwony alarm
$success-color: #52c41a;      // Zielony "go"

$border-radius-small: 4px;
$border-radius-medium: 8px;
$border-radius-large: 16px;

$font-main: 'Space Grotesk', sans-serif;
$font-display: 'Nova Mono', monospace;

// Używanie zmiennych
.control-button {
  background-color: $secondary-color;
  border-radius: $border-radius-medium;
  font-family: $font-main;

  &.primary {
    background-color: $primary-color;
  }

  &.danger {
    background-color: $danger-color;
  }
}

2. Zagnieżdżanie selektorów

Zagnieżdżanie selektorów pozwala na tworzenie bardziej czytelnej hierarchii, która odzwierciedla strukturę HTML:

.space-panel {
  background-color: #1a1a2e;
  padding: 20px;
  border-radius: 10px;

  .panel-title {
    color: white;
    font-size: 24px;
    margin-bottom: 15px;
  }

  .control-area {
    display: flex;
    justify-content: space-between;

    .button-group {
      display: flex;
      gap: 10px;

      .control-button {
        padding: 10px 15px;
        // Inne style przycisku...
      }
    }

    .status-display {
      background-color: rgba(0, 0, 0, 0.3);
      padding: 10px;
      border-radius: 5px;
    }
  }
}

Taki zapis jest nie tylko bardziej czytelny, ale również pomaga uniknąć duplikacji selektorów i czyni strukturę bardziej oczywistą.

3. Selektor & (ampersand)

Ampersand (&) reprezentuje bieżący selektor i jest szczególnie przydatny do:

Pseudoklas i pseudoelementów

.control-button {
  background-color: #4a90e2;
  transition: all 0.3s;

  &:hover {
    background-color: darken(#4a90e2, 10%);
    transform: translateY(-2px);
  }

  &:active {
    transform: translateY(1px);
  }

  &::before {
    content: "▲";
    margin-right: 5px;
  }
}

Modyfikatorów klasy

.control-button {
  // Bazowe style...

  &.primary {
    background-color: #8a2be2;
  }

  &.secondary {
    background-color: #4a90e2;
  }

  &.large {
    padding: 12px 20px;
    font-size: 18px;
  }
}

Łączenia selektorów

.space-theme {
  .control-button {
    // Style dla .space-theme .control-button
  }

  // Używając & możemy wybierać różne kombinacje selektorów
  &__dark .control-button {
    // Style dla .space-theme__dark .control-button
  }
}

4. Mixiny - wielokrotne wykorzystanie kodu

Mixiny to zbiory deklaracji CSS, które można wielokrotnie używać w kodzie. To jak reużywalne moduły statku kosmicznego:

// mixins.scss
@mixin flex-center {
  display: flex;
  justify-content: center;
  align-items: center;
}

@mixin glass-effect {
  background: rgba(255, 255, 255, 0.1);
  backdrop-filter: blur(10px);
  border: 1px solid rgba(255, 255, 255, 0.2);
  box-shadow: 0 8px 32px rgba(31, 38, 135, 0.2);
}

@mixin button-variant($bg-color, $text-color) {
  background-color: $bg-color;
  color: $text-color;

  &:hover {
    background-color: darken($bg-color, 10%);
  }

  &:active {
    background-color: darken($bg-color, 15%);
  }
}

Użycie mixinów:

.control-panel {
  @include glass-effect;
  padding: 20px;
}

.button-container {
  @include flex-center;
  gap: 10px;
}

.launch-button {
  @include button-variant(#ff4d4f, white);
  padding: 10px 20px;
}

.navigation-button {
  @include button-variant(#4a90e2, white);
  padding: 8px 15px;
}

5. Dziedziczenie - @extend

Dziedziczenie pozwala jednej klasie dziedziczyć właściwości innej, redukując duplikację kodu:

.base-button {
  padding: 10px 15px;
  border: none;
  border-radius: 4px;
  font-weight: bold;
  cursor: pointer;
  transition: all 0.3s;
}

.primary-button {
  @extend .base-button;
  background-color: #8a2be2;
  color: white;
}

.secondary-button {
  @extend .base-button;
  background-color: #4a90e2;
  color: white;
}

.ghost-button {
  @extend .base-button;
  background-color: transparent;
  color: #8a2be2;
  border: 1px solid currentColor;
}

6. Funkcje matematyczne i kolorystyczne

SCSS oferuje wiele wbudowanych funkcji do manipulacji kolorami i wartościami:

.panel {
  // Matematyczne operacje
  width: 100% - 40px;
  padding: 10px * 2;

  // Funkcje kolorów
  background-color: lighten(#1a1a2e, 10%);
  border: 1px solid darken(#1a1a2e, 5%);

  .warning-label {
    color: transparentize(#ff4d4f, 0.2); // Dodaje przezroczystość
  }

  .accent-element {
    background-color: mix(#8a2be2, #4a90e2, 30%); // Miesza kolory
  }
}

7. Importowanie i organizacja plików

SCSS umożliwia dzielenie kodu na modułowe pliki, co jest kluczowe dla dużych projektów. Pliki wczytujemy regułą @use (dawny @import jest od Dart Sass 1.80 przestarzały), a dopisek as * udostępnia zmienne i mixiny bez prefiksu przestrzeni nazw:

// styles/variables.scss
$primary-color: #8a2be2;
// Inne zmienne...

// styles/mixins.scss
@mixin flex-center { /* ... */ }
// Inne mixiny...

// styles/buttons.scss
@use 'variables' as *;
@use 'mixins' as *;

.button { /* ... */ }
// Style przycisków...

// styles/panels.scss
@use 'variables' as *;
@use 'mixins' as *;

.panel { /* ... */ }
// Style paneli...

// styles/main.scss
@use 'variables' as *;
@use 'mixins' as *;
@use 'buttons';
@use 'panels';
// Możemy importować wszystko razem lub wybiórczo w komponentach

8. Operatory warunkowe i pętle

SCSS oferuje także konstrukcje kontrolne znane z języków programowania:

// Warunki
$theme: 'dark';

.space-control {
  @if $theme == 'dark' {
    background-color: #121212;
    color: white;
  } @else {
    background-color: #f5f5f5;
    color: #333;
  }
}

// Pętle
$sizes: (
  'small': 8px,
  'medium': 16px,
  'large': 24px,
  'xlarge': 32px
);

@each $name, $size in $sizes {
  .margin-#{$name} {
    margin: $size;
  }

  .padding-#{$name} {
    padding: $size;
  }
}

// Generuje:
// .margin-small { margin: 8px; }
// .padding-small { padding: 8px; }
// ...itd. dla wszystkich rozmiarów

Integracja SCSS z CSS Modules w React

SCSS można doskonale połączyć z CSS Modules, tworząc potężne rozwiązanie stylowania:

// SpacePanel.module.scss
@use 'src/styles/variables' as *;
@use 'src/styles/mixins' as *;

.panel {
  @include glass-effect;
  background-color: $panel-bg-color;

  .title {
    color: $text-primary;
    font-family: $font-display;
  }

  .controls {
    display: flex;
    gap: $spacing-md;

    .button {
      @include button-base;

      &.primary {
        @include button-variant($primary-color, white);
      }

      &.secondary {
        @include button-variant($secondary-color, white);
      }
    }
  }
}

Użycie w komponencie:

import React from 'react';
import styles from './SpacePanel.module.scss';

function SpacePanel() {
  return (
    <div className={styles.panel}>
      <h2 className={styles.title}>Panel kontrolny</h2>
      <div className={styles.controls}>
        <button className={`${styles.button} ${styles.primary}`}>
          Uruchom
        </button>
        <button className={`${styles.button} ${styles.secondary}`}>
          Anuluj
        </button>
      </div>
    </div>
  );
}

Najlepsze praktyki używania SCSS w React

1. Struktura plików

Organizuj swoje pliki SCSS w sposób, który odzwierciedla strukturę komponentów:

src/
├── styles/                    # Globalne style i zasoby
│   ├── _variables.scss        # Konwencja: pliki z podkreśleniem są tylko do importowania
│   ├── _mixins.scss
│   ├── _functions.scss
│   ├── _reset.scss
│   └── global.scss            # Główny plik globalnych stylów
├── components/
│   ├── Button/
│   │   ├── Button.jsx
│   │   └── Button.module.scss
│   ├── Panel/
│   │   ├── Panel.jsx
│   │   └── Panel.module.scss
│   └──
└──

2. Konwencje nazewnicze

Używaj konsekwentnych konwencji nazewniczych:

  • BEM (Block, Element, Modifier) - dla klas CSS
  • camelCase - dla zmiennych SCSS i mixinów
  • PascalCase - dla komponentów React
  • kebab-case - dla plików SCSS
// _variables.scss
$primaryColor: #8a2be2;
$secondaryColor: #4a90e2;

// Button.module.scss (wykorzystuje BEM)
.button {
  // Block
  background-color: $primaryColor;

  &__icon {
    // Element
    margin-right: 8px;
  }

  &--large {
    // Modifier
    padding: 12px 24px;
  }
}

3. Unikaj nadmiernego zagnieżdżania

Zbyt głębokie zagnieżdżenie może prowadzić do nadspecyficznych selektorów, co utrudnia ich nadpisywanie:

// Unikaj:
.panel {
  .content {
    .section {
      .title {
        .icon {
          // 5 poziomów zagnieżdżenia!
          color: red;
        }
      }
    }
  }
}

// Lepiej:
.panel {
  // Ogólne style panelu
}

.panel-content {
  // Style dla zawartości
}

.section-title-icon {
  color: red;
}

4. Używaj zmiennych dla powtarzających się wartości

// _spacing.scss
$spacing-xs: 4px;
$spacing-sm: 8px;
$spacing-md: 16px;
$spacing-lg: 24px;
$spacing-xl: 32px;

// _colors.scss
$blue-100: #e3f2fd;
$blue-200: #bbdefb;
//
$blue-900: #0d47a1;

$color-primary: $blue-500;
$color-secondary: $purple-500;

5. Twórz systemowe mixiny

@mixin media-breakpoint-up($breakpoint) {
  @if $breakpoint == sm {
    @media (min-width: 576px) { @content; }
  } @else if $breakpoint == md {
    @media (min-width: 768px) { @content; }
  } @else if $breakpoint == lg {
    @media (min-width: 992px) { @content; }
  } @else if $breakpoint == xl {
    @media (min-width: 1200px) { @content; }
  }
}

// Użycie:
.responsive-element {
  font-size: 14px;

  @include media-breakpoint-up(md) {
    font-size: 16px;
  }

  @include media-breakpoint-up(lg) {
    font-size: 18px;
  }
}

Praktyczny przykład: Panel sterowania statkiem kosmicznym

Zobaczmy, jak zastosować SCSS do stworzenia interaktywnego panelu sterowania:

// _variables.scss
$primary-color: #7b2cbf;
$secondary-color: #3a86ff;
$success-color: #06d6a0;
$warning-color: #ffd166;
$danger-color: #ef476f;
$dark-bg: #1a1a2e;
$panel-bg: #252941;
$text-light: #e6e6ff;

$border-radius-sm: 4px;
$border-radius-md: 8px;
$border-radius-lg: 12px;

$transition-fast: 0.2s ease;
$transition-normal: 0.3s ease;

// _mixins.scss
@mixin glass-morphism {
  background: rgba(37, 41, 65, 0.8);
  backdrop-filter: blur(10px);
  border: 1px solid rgba(255, 255, 255, 0.1);
  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
}

@mixin button-glow($color) {
  box-shadow: 0 0 15px rgba($color, 0.5);
  &:hover {
    box-shadow: 0 0 25px rgba($color, 0.7);
  }
}

// SpaceControlPanel.module.scss
@use 'src/styles/variables' as *;
@use 'src/styles/mixins' as *;

.controlPanel {
  @include glass-morphism;
  padding: 24px;
  border-radius: $border-radius-lg;
  color: $text-light;

  .panelHeader {
    display: flex;
    justify-content: space-between;
    align-items: center;
    margin-bottom: 24px;
    padding-bottom: 16px;
    border-bottom: 1px solid rgba(255, 255, 255, 0.1);

    .title {
      font-size: 28px;
      font-weight: 600;

      &::before {
        content: "▲";
        margin-right: 10px;
      }
    }

    .status {
      padding: 6px 12px;
      border-radius: $border-radius-sm;
      font-size: 14px;
      font-weight: 500;

      &.ready {
        background-color: rgba($success-color, 0.2);
        color: $success-color;
      }

      &.standby {
        background-color: rgba($warning-color, 0.2);
        color: $warning-color;
      }

      &.error {
        background-color: rgba($danger-color, 0.2);
        color: $danger-color;
      }
    }
  }

  .controlGrid {
    display: grid;
    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
    gap: 20px;

    .controlSection {
      background-color: rgba(0, 0, 0, 0.2);
      border-radius: $border-radius-md;
      padding: 16px;

      .sectionTitle {
        font-size: 18px;
        margin-bottom: 16px;
        color: rgba($text-light, 0.8);
      }

      .buttonGroup {
        display: flex;
        flex-direction: column;
        gap: 12px;
      }
    }
  }

  .button {
    padding: 12px 16px;
    border: none;
    border-radius: $border-radius-sm;
    font-weight: 500;
    letter-spacing: 0.5px;
    cursor: pointer;
    transition: all $transition-normal;
    position: relative;
    overflow: hidden;

    &::before {
      content: "";
      position: absolute;
      top: 0;
      left: -100%;
      width: 100%;
      height: 100%;
      background: linear-gradient(
        90deg,
        transparent,
        rgba(255, 255, 255, 0.2),
        transparent
      );
      transition: all 0.6s;
    }

    &:hover::before {
      left: 100%;
    }

    &.primary {
      background-color: $primary-color;
      color: white;
      @include button-glow($primary-color);
    }

    &.secondary {
      background-color: $secondary-color;
      color: white;
      @include button-glow($secondary-color);
    }

    &.success {
      background-color: $success-color;
      color: black;
      @include button-glow($success-color);
    }

    &.warning {
      background-color: $warning-color;
      color: black;
      @include button-glow($warning-color);
    }

    &.danger {
      background-color: $danger-color;
      color: white;
      @include button-glow($danger-color);
    }

    &.disabled {
      opacity: 0.5;
      cursor: not-allowed;
      pointer-events: none;
    }
  }

  .monitorDisplay {
    margin-top: 24px;
    padding: 16px;
    background-color: rgba(0, 0, 0, 0.4);
    border-radius: $border-radius-md;
    font-family: monospace;
    height: 120px;
    overflow-y: auto;

    .logLine {
      margin: 4px 0;
      font-size: 14px;

      &.info {
        color: $secondary-color;
      }

      &.success {
        color: $success-color;
      }

      &.warning {
        color: $warning-color;
      }

      &.error {
        color: $danger-color;
      }

      &::before {
        content: "> ";
      }
    }
  }
}

// Użycie w komponencie React
import React, { useState } from 'react';
import styles from './SpaceControlPanel.module.scss';

function SpaceControlPanel() {
  const [status, setStatus] = useState('standby');
  const [logs, setLogs] = useState([
    { type: 'info', text: 'System initialized' },
    { type: 'info', text: 'Waiting for commands' }
  ]);

  const addLog = (text, type = 'info') => {
    setLogs(prev => [...prev, { type, text }]);
  };

  const initiateSequence = () => {
    setStatus('ready');
    addLog('Launch sequence initiated', 'success');
  };

  const abortSequence = () => {
    setStatus('standby');
    addLog('Launch sequence aborted', 'warning');
  };

  const triggerAlert = () => {
    setStatus('error');
    addLog('ALERT: Critical system failure detected', 'error');
  };

  return (
    <div className={styles.controlPanel}>
      <div className={styles.panelHeader}>
        <h2 className={styles.title}>Kosmiczny Panel Sterowania</h2>
        <div className={`${styles.status} ${styles[status]}`}>
          Status: {status === 'standby' ? 'Oczekiwanie' :
                  status === 'ready' ? 'Gotowy' : 'Błąd'}
        </div>
      </div>

      <div className={styles.controlGrid}>
        <div className={styles.controlSection}>
          <h3 className={styles.sectionTitle}>Kontrola Startu</h3>
          <div className={styles.buttonGroup}>
            <button
              className={`${styles.button} ${styles.success}`}
              onClick={initiateSequence}
            >
              Inicjuj Start
            </button>
            <button
              className={`${styles.button} ${styles.warning}`}
              onClick={abortSequence}
            >
              Przerwij Sekwencję
            </button>
          </div>
        </div>

        <div className={styles.controlSection}>
          <h3 className={styles.sectionTitle}>Systemy Pokładowe</h3>
          <div className={styles.buttonGroup}>
            <button
              className={`${styles.button} ${styles.primary}`}
              onClick={() => addLog('Navigation systems online', 'info')}
            >
              System Nawigacji
            </button>
            <button
              className={`${styles.button} ${styles.secondary}`}
              onClick={() => addLog('Life support activated', 'info')}
            >
              Podtrzymanie Życia
            </button>
          </div>
        </div>

        <div className={styles.controlSection}>
          <h3 className={styles.sectionTitle}>Bezpieczeństwo</h3>
          <div className={styles.buttonGroup}>
            <button
              className={`${styles.button} ${styles.danger}`}
              onClick={triggerAlert}
            >
              Alarm Awaryjny
            </button>
            <button
              className={`${styles.button} ${styles.disabled}`}
            >
              Protokół Ewakuacji
            </button>
          </div>
        </div>
      </div>

      <div className={styles.monitorDisplay}>
        {logs.map((log, index) => (
          <div key={index} className={`${styles.logLine} ${styles[log.type]}`}>
            {log.text}
          </div>
        ))}
      </div>
    </div>
  );
}

export default SpaceControlPanel;

Sass vs CSS-in-JS: Kiedy używać?

Zalety SCSS

  1. Wydajność - CSS jest generowany podczas budowania, nie w czasie rzeczywistym
  2. Znajoma składnia - bardzo podobna do standardowego CSS
  3. Wsparcie narzędzi - pełne wsparcie dla narzędzi deweloperskich (DevTools)
  4. Możliwość ekstrakcji CSS - można wyodrębnić style do osobnych plików CSS
  5. Mniejszy bundle size - nie wymaga dodatkowych bibliotek JS

Kiedy wybierać SCSS?

  • W większych projektach z kompleksowymi stylami
  • Gdy preferujesz separację logiki od stylu
  • Gdy wydajność jest kluczowa
  • Gdy pracujesz z designerami używającymi tradycyjnego CSS/SCSS
  • Gdy zespół ma doświadczenie z SCSS

Podsumowanie

Sass (SCSS) to potężne narzędzie, które znacząco rozszerza możliwości CSS, pozostając przy tym bliskie jego oryginalnej składni. W ekosystemie React, SCSS doskonale integruje się zarówno z podejściem modułowym (CSS Modules), jak i z innymi technikami stylowania.

Dzięki zmiennym, mixinom, zagnieżdżaniu i innym funkcjom, SCSS pozwala na tworzenie bardziej modułowego, łatwiejszego w utrzymaniu kodu CSS, co jest szczególnie ważne w większych aplikacjach React.

Jak każdy zaawansowany statek kosmiczny, SCSS wymaga pewnego czasu na opanowanie, ale inwestycja w naukę szybko zwraca się w postaci bardziej wydajnej pracy i lepiej zorganizowanego kodu. W przypadku aplikacji React, gdzie zarządzanie komponentami i ich stylami jest kluczowe, SCSS stanowi jedną z najlepszych opcji stylowania, oferując doskonałą równowagę między mocą a prostotą.

Kod do tej lekcji: App.jsx
import React, { useState } from 'react';
import styled, { ThemeProvider, createGlobalStyle, keyframes } from 'styled-components';

// Definicja motywów
const themes = {
  space: {
    primary: '#00d4ff',
    secondary: '#ffd700',
    background: 'linear-gradient(135deg, #0f0c29 0%, #302b63 50%, #24243e 100%)',
    cardBg: 'rgba(255, 255, 255, 0.05)',
    text: '#ffffff',
    textSecondary: '#a0a0a0',
  },
  nebula: {
    primary: '#ff6b9d',
    secondary: '#c44569',
    background: 'linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%)',
    cardBg: 'rgba(255, 107, 157, 0.1)',
    text: '#ffffff',
    textSecondary: '#b0b0b0',
  },
  solar: {
    primary: '#ffa502',
    secondary: '#ff6348',
    background: 'linear-gradient(135deg, #2c2c54 0%, #474787 50%, #706fd3 100%)',
    cardBg: 'rgba(255, 165, 2, 0.1)',
    text: '#ffffff',
    textSecondary: '#c0c0c0',
  },
};

// Global styles
const GlobalStyle = createGlobalStyle`
  * {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
  }

  body {
    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
    min-height: 100vh;
  }
`;

// Animacje
const float = keyframes`
  0%, 100% { transform: translateY(0); }
  50% { transform: translateY(-10px); }
`;

const pulse = keyframes`
  0%, 100% { opacity: 1; }
  50% { opacity: 0.7; }
`;

// Styled components
const AppContainer = styled.div`
  min-height: 100vh;
  background: ${props => props.theme.background};
  padding: 30px;
  color: ${props => props.theme.text};
  transition: all 0.5s ease;
`;

const Header = styled.header`
  text-align: center;
  margin-bottom: 40px;
`;

const Title = styled.h1`
  font-size: 2.5em;
  color: ${props => props.theme.primary};
  text-shadow: 0 0 20px ${props => props.theme.primary}40;
  animation: ${float} 3s ease-in-out infinite;
`;

const Subtitle = styled.p`
  color: ${props => props.theme.textSecondary};
  margin-top: 10px;
`;

const ThemeSelector = styled.div`
  display: flex;
  justify-content: center;
  gap: 15px;
  margin-bottom: 40px;
`;

const ThemeButton = styled.button`
  padding: 12px 24px;
  border: 2px solid ${props => props.active ? props.theme.primary : 'transparent'};
  border-radius: 8px;
  background: ${props => props.theme.cardBg};
  color: ${props => props.theme.text};
  cursor: pointer;
  font-weight: bold;
  transition: all 0.3s ease;

  &:hover {
    background: ${props => props.theme.primary}30;
    transform: translateY(-2px);
  }
`;

const CardsGrid = styled.div`
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
  gap: 25px;
  max-width: 1200px;
  margin: 0 auto;
`;

const Card = styled.div`
  background: ${props => props.theme.cardBg};
  border-radius: 15px;
  padding: 25px;
  border: 1px solid ${props => props.theme.primary}30;
  transition: all 0.3s ease;

  &:hover {
    transform: translateY(-5px);
    box-shadow: 0 10px 30px ${props => props.theme.primary}20;
  }
`;

const CardTitle = styled.h3`
  color: ${props => props.theme.secondary};
  margin-bottom: 15px;
  font-size: 1.4em;
`;

const CardText = styled.p`
  color: ${props => props.theme.textSecondary};
  line-height: 1.6;
  margin-bottom: 20px;
`;

const Button = styled.button`
  padding: 10px 20px;
  background: ${props => props.variant === 'primary'
    ? props.theme.primary
    : 'transparent'};
  color: ${props => props.variant === 'primary'
    ? '#000'
    : props.theme.primary};
  border: 2px solid ${props => props.theme.primary};
  border-radius: 6px;
  cursor: pointer;
  font-weight: bold;
  transition: all 0.3s ease;

  &:hover {
    background: ${props => props.theme.primary};
    color: #000;
    transform: scale(1.05);
  }

  &:disabled {
    opacity: 0.5;
    cursor: not-allowed;
  }
`;

const StatusBadge = styled.span`
  display: inline-block;
  padding: 4px 12px;
  border-radius: 20px;
  font-size: 0.85em;
  font-weight: bold;
  background: ${props => {
    switch(props.status) {
      case 'active': return 'rgba(76, 175, 80, 0.2)';
      case 'pending': return 'rgba(255, 152, 0, 0.2)';
      case 'inactive': return 'rgba(244, 67, 54, 0.2)';
      default: return 'rgba(255, 255, 255, 0.1)';
    }
  }};
  color: ${props => {
    switch(props.status) {
      case 'active': return '#4CAF50';
      case 'pending': return '#ff9800';
      case 'inactive': return '#f44336';
      default: return '#fff';
    }
  }};
  animation: ${props => props.status === 'active' ? pulse : 'none'} 2s infinite;
`;

const Footer = styled.footer`
  text-align: center;
  margin-top: 50px;
  color: ${props => props.theme.textSecondary};
  padding: 20px;
  border-top: 1px solid ${props => props.theme.primary}20;
`;

// Komponenty danych
const missions = [
  {
    id: 1,
    name: 'Eksploracja Marsa',
    description: 'Misja badawcza na powierzchni Czerwonej Planety',
    status: 'active',
  },
  {
    id: 2,
    name: 'Stacja Orbitalna',
    description: 'Budowa nowej stacji kosmicznej na orbicie Ziemi',
    status: 'pending',
  },
  {
    id: 3,
    name: 'Sonda Jowiszowa',
    description: 'Badanie atmosfery największej planety Układu Słonecznego',
    status: 'inactive',
  },
];

function App() {
  const [currentTheme, setCurrentTheme] = useState('space');

  return (
    <ThemeProvider theme={themes[currentTheme]}>
      <GlobalStyle />
      <AppContainer>
        <Header>
          <Title>Styled Components Demo</Title>
          <Subtitle>Dynamiczne stylowanie z motywami w React</Subtitle>
        </Header>

        <ThemeSelector>
          {Object.keys(themes).map(themeName => (
            <ThemeButton
              key={themeName}
              active={currentTheme === themeName}
              onClick={() => setCurrentTheme(themeName)}
            >
              {themeName.charAt(0).toUpperCase() + themeName.slice(1)}
            </ThemeButton>
          ))}
        </ThemeSelector>

        <CardsGrid>
          {missions.map(mission => (
            <Card key={mission.id}>
              <CardTitle>{mission.name}</CardTitle>
              <StatusBadge status={mission.status}>
                {mission.status}
              </StatusBadge>
              <CardText>{mission.description}</CardText>
              <Button variant="primary">Szczegóły</Button>
            </Card>
          ))}
        </CardsGrid>

        <Footer>
          <p>Styled-components umożliwia pisanie CSS w JavaScript</p>
          <p>z pełnym wsparciem dla motywów i dynamicznych stylów</p>
        </Footer>
      </AppContainer>
    </ThemeProvider>
  );
}

export default App;

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 składnia SCSS jest kompatybilna z CSS?

  2. 2. Co oznacza operator & w zagnieżdżonych selektorach SCSS?

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

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż komendę instalacji SCSS w projekcie React:

  • Klikanie w kolejności

    Ułóż definicję zmiennej SCSS:

  • Edytor kodu

    System zmiennych SCSS

  • Edytor kodu

    SCSS nesting i operator &

  • Klikanie w kolejności

    Ułóż definicję mixina w SCSS:

  • Układanie w pionie

    Ułóż etapy dodawania SCSS do projektu React:

  • Układanie w pionie

    Ułóż elementy dyrektywy @extend w SCSS od lewej do prawej:

  • Edytor kodu

    SCSS mixins dla komponentów

  • Układanie w pionie

    Ułóż zagnieżdżony selektor SCSS z pseudoklasą hover:

  • Edytor kodu

    SCSS functions

  • Klikanie w kolejności

    Ułóż składnię BEM w SCSS od bloku do modyfikatora:

  • Układanie w pionie

    Uporządkuj etapy kompilacji SCSS:

  • Edytor kodu

    CSS Modules z SCSS

  1. Ułóż w kolejnościInstalacja SCSS
  2. PytanieSCSS vs Sass
  3. Kliknij w kolejnościZmienne w SCSS
  4. Zadanie z kodemPraktyka: SCSS variables
  5. PytanieZagnieżdżanie selektorów w SCSS
  6. Zadanie z kodemPraktyka: SCSS nesting
  7. Kliknij w kolejnościMixins w SCSS
  8. Ułóż w kolejnościEtapy konfiguracji SCSS w React
  9. PytanieMixiny w SCSS
  10. Ułóż w kolejnościDyrektywa @extend w SCSS
  11. Zadanie z kodemPraktyka: SCSS mixins
  12. Ułóż w kolejnościZagnieżdżanie w SCSS
  13. PytanieNajlepsze praktyki zagnieżdżania SCSS
  14. PytanieDyrektywa importu w SCSS
  15. Zadanie z kodemPraktyka: SCSS functions
  16. Kliknij w kolejnościMetodologia nazewnictwa BEM
  17. Ułóż w kolejnościKolejność kompilacji SCSS
  18. Zadanie z kodemPraktyka: CSS Modules + SCSS

Przydatne artykuły