Kurs Vue.js · Moduł 9: Composables i VueUse

Projekt: Lab Manager z Composables

6 min czytania ·
W tej lekcji4

Kompleksowy system zarządzania laboratorium NOVA LAB wykorzystujący wszystkie poznane techniki! Dr. Nova potrzebuje panelu, który pobierze listę eksperymentów z serwera, pozwoli ją przeszukiwać, filtrować i sortować, podzieli wyniki na strony i umożliwi usuwanie wpisów. Gdybyś wpisał to wszystko do jednego komponentu, dostałbyś kilkaset linii, w których pobieranie danych miesza się z paginacją. Zamiast tego zbudujemy trzy composables, z których każdy ma jedno zadanie, i komponent, który je łączy. Dane płyną jedną drogą: useExperiments() pobiera i przechowuje eksperymenty, useLabFilters(experiments) je filtruje, usePagination(filtered) dzieli wynik na strony, a template wyświetla paginatedItems.

Warstwa danych: useExperiments

Pierwszy plik, composables/useExperiments.js, odpowiada za dane. Zwraca stan, flagi loading i error oraz funkcje CRUD - od angielskiego Create, Read, Update, Delete, czyli tworzenie, odczyt, aktualizację i usuwanie. Wartości pochodne, takie jak lista krytycznych eksperymentów i liczba kategorii, wyliczają computed:

// composables/useExperiments.js
import { ref, computed } from 'vue'

export function useExperiments() {
  const experiments = ref([])
  const loading = ref(false)
  const error = ref(null)

  const criticalExperiments = computed(() =>
    experiments.value.filter(exp => exp.critical)
  )

  const categoriesCount = computed(() =>
    new Set(experiments.value.map(exp => exp.category)).size
  )

  async function fetchExperiments() {
    loading.value = true
    error.value = null

    try {
      const response = await fetch('/api/mars/experiments')
      if (!response.ok) throw new Error('Błąd pobierania')

      experiments.value = await response.json()
    } catch (e) {
      error.value = e.message
    } finally {
      loading.value = false
    }
  }

  async function addExperiment(experiment) {
    const response = await fetch('/api/mars/experiments', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(experiment)
    })

    const newExperiment = await response.json()
    experiments.value.push(newExperiment)
  }

  async function deleteExperiment(id) {
    await fetch(`/api/mars/experiments/${id}`, { method: 'DELETE' })
    experiments.value = experiments.value.filter(exp => exp.id !== id)
  }

  return {
    experiments,
    loading,
    error,
    criticalExperiments,
    categoriesCount,
    fetchExperiments,
    addExperiment,
    deleteExperiment
  }
}

Mamy odczyt, tworzenie i usuwanie; aktualizację dopiszesz w ramach rozbudowy. Warto też od razu dodać dwie rzeczy z poprzednich lekcji: sprawdzenie response.ok w addExperiment oraz AbortController, który anuluje pobieranie przy odmontowaniu.

Filtrowanie: useLabFilters

Drugi composable przyjmuje parametr - ref z listą eksperymentów - i buduje z niego przefiltrowaną, posortowaną wersję. Nie wie nic o serwerze, więc zadziała z każdą listą o polach name i category:

// composables/useLabFilters.js
import { ref, computed } from 'vue'

export function useLabFilters(experiments) {
  const searchQuery = ref('')
  const selectedCategory = ref('')
  const sortBy = ref('name')
  const sortOrder = ref('asc')

  const filteredExperiments = computed(() => {
    let result = experiments.value

    // Search
    if (searchQuery.value) {
      const query = searchQuery.value.toLowerCase()
      result = result.filter(exp =>
        exp.name.toLowerCase().includes(query) ||
        exp.category.toLowerCase().includes(query)
      )
    }

    // Filter by category
    if (selectedCategory.value) {
      result = result.filter(exp => exp.category === selectedCategory.value)
    }

    // Sort
    result = [...result].sort((a, b) => {
      const aVal = a[sortBy.value]
      const bVal = b[sortBy.value]
      const order = sortOrder.value === 'asc' ? 1 : -1

      if (typeof aVal === 'string') {
        return aVal.localeCompare(bVal) * order
      }
      return (aVal - bVal) * order
    })

    return result
  })

  const uniqueCategories = computed(() =>
    [...new Set(experiments.value.map(exp => exp.category))].sort()
  )

  function resetFilters() {
    searchQuery.value = ''
    selectedCategory.value = ''
    sortBy.value = 'name'
    sortOrder.value = 'asc'
  }

  return {
    searchQuery,
    selectedCategory,
    sortBy,
    sortOrder,
    filteredExperiments,
    uniqueCategories,
    resetFilters
  }
}

Zwróć uwagę na [...result].sort: metoda sort zmienia tablicę w miejscu, więc bez kopii posortowalibyśmy oryginalną listę z useExperiments. Napisy porównuje localeCompare, a liczby, na przykład rok, zwykłe odejmowanie.

Paginacja: usePagination

Trzeci composable dzieli dowolną listę na strony. Liczbę stron wylicza computed z Math.ceil, a bieżący wycinek - slice:

// composables/usePagination.js
import { ref, computed } from 'vue'

export function usePagination(items, itemsPerPage = 12) {
  const currentPage = ref(1)
  const perPage = ref(itemsPerPage)

  const totalPages = computed(() =>
    Math.ceil(items.value.length / perPage.value)
  )

  const paginatedItems = computed(() => {
    const start = (currentPage.value - 1) * perPage.value
    const end = start + perPage.value
    return items.value.slice(start, end)
  })

  function goToPage(page) {
    if (page >= 1 && page <= totalPages.value) {
      currentPage.value = page
    }
  }

  function nextPage() {
    goToPage(currentPage.value + 1)
  }

  function prevPage() {
    goToPage(currentPage.value - 1)
  }

  return {
    currentPage,
    perPage,
    totalPages,
    paginatedItems,
    goToPage,
    nextPage,
    prevPage
  }
}

goToPage ignoruje numery spoza zakresu. Jedna pułapka: jeśli jesteś na stronie 3 i zawęzisz filtr do jednej strony wyników, currentPage zostanie na 3, a lista pokaże się pusta. Poprawka to jedna linijka w composable, plus import watch: watch(items, () => { currentPage.value = 1 }).

Komponent LabManager

Czas połączyć moduły w panelu. Pierwsza część szablonu to nagłówek z licznikami i panel filtrów, w którym v-model wiąże pola formularza z refami z useLabFilters:

<!-- LabManager.vue -->
<template>
  <div class="lab-manager">
    <!-- Header -->
    <header>
      <h1>NOVA LAB - Zarządzanie Eksperymentami</h1>
      <p>{{ categoriesCount }} kategorii, {{ experiments.length }} eksperymentów</p>
    </header>

    <!-- Filters -->
    <aside class="filters">
      <input v-model="searchQuery" placeholder="Szukaj eksperymentów..." />

      <select v-model="selectedCategory">
        <option value="">Wszystkie kategorie</option>
        <option v-for="category in uniqueCategories" :key="category" :value="category">
          {{ category }}
        </option>
      </select>

      <select v-model="sortBy">
        <option value="name">Nazwa</option>
        <option value="category">Kategoria</option>
        <option value="year">Rok</option>
      </select>

      <button @click="sortOrder = sortOrder === 'asc' ? 'desc' : 'asc'">
        {{ sortOrder === 'asc' ? '↑' : '↓' }}
      </button>

      <button @click="resetFilters">Resetuj</button>
    </aside>

Każda zmiana w polu wyszukiwania od razu przelicza filteredExperiments, a za nią paginatedItems - bez jednej linii kodu obsługi zdarzeń. Druga część pokazuje stan ładowania, siatkę kart i paginację. Komponent ExperimentCard pomijamy - wyświetla kartę eksperymentu i emituje zdarzenie delete:

    <!-- Loading/Error -->
    <div v-if="loading">Ładowanie eksperymentów...</div>
    <div v-else-if="error">Błąd: {{ error }}</div>

    <!-- Lab Dashboard -->
    <main v-else class="lab-grid">
      <ExperimentCard
        v-for="experiment in paginatedItems"
        :key="experiment.id"
        :experiment="experiment"
        @delete="deleteExperiment(experiment.id)"
      />
    </main>

    <!-- Pagination -->
    <footer class="pagination">
      <button @click="prevPage" :disabled="currentPage === 1">
        Poprzednia
      </button>

      <button
        v-for="page in totalPages"
        :key="page"
        @click="goToPage(page)"
        :class="{ active: currentPage === page }"
      >
        {{ page }}
      </button>

      <button @click="nextPage" :disabled="currentPage === totalPages">
        Następna
      </button>
    </footer>
  </div>
</template>

v-for="page in totalPages" iteruje po liczbie, więc daje kolejno 1, 2, 3 aż do totalPages. Na koniec skrypt, w którym importujesz composables, destrukturyzujesz zwrócone API i przekazujesz wynik jednego jako parametr następnego:

<script setup>
import { onMounted } from 'vue'
import { useExperiments } from './composables/useExperiments'
import { useLabFilters } from './composables/useLabFilters'
import { usePagination } from './composables/usePagination'

// Composables
const {
  experiments,
  loading,
  error,
  categoriesCount,
  fetchExperiments,
  deleteExperiment
} = useExperiments()

const {
  searchQuery,
  selectedCategory,
  sortBy,
  sortOrder,
  filteredExperiments,
  uniqueCategories,
  resetFilters
} = useLabFilters(experiments)

const {
  currentPage,
  totalPages,
  paginatedItems,
  goToPage,
  nextPage,
  prevPage
} = usePagination(filteredExperiments, 12)

// Lifecycle
onMounted(() => {
  fetchExperiments()
})
</script>

Kolejność wywołań odzwierciedla przepływ danych: experiments trafia do filtrów, filteredExperiments do paginacji, a dane pobieramy w onMounted. Komponent nie zawiera żadnej logiki biznesowej - tylko ją skleja.

Moja rada: pilnuj zasady jednego zadania na composable. Dzięki niej usePagination użyjesz w dowolnej innej liście stacji, a każdy composable przetestujesz osobno, jak w lekcji o testowaniu. W edytorze poniżej czeka pokrewny przykład integracji modułów: useTimer, useModuleStatus i useNotifications łączą się w jeden panel według tej samej zasady.

Zapamiętaj: Lab Manager to stacja zbudowana z modułów - każdy composable robi jedną rzecz, a komponent tylko je ze sobą łączy.

Kod do tej lekcji: App.vue
<script setup>
import { ref, computed, watch, onMounted } from 'vue'

// Dobra praktyka 1: jedna odpowiedzialność
function useTimer(initialSeconds = 0) {
  const seconds = ref(initialSeconds)
  const isRunning = ref(false)
  let intervalId = null

  const formattedTime = computed(() => {
    const mins = Math.floor(seconds.value / 60)
    const secs = seconds.value % 60
    return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
  })

  function start() {
    if (isRunning.value) return
    isRunning.value = true
    intervalId = setInterval(() => {
      seconds.value++
    }, 1000)
  }

  function pause() {
    isRunning.value = false
    if (intervalId) {
      clearInterval(intervalId)
      intervalId = null
    }
  }

  function reset() {
    pause()
    seconds.value = initialSeconds
  }

  return {
    seconds,
    formattedTime,
    isRunning,
    start,
    pause,
    reset
  }
}

// Dobra praktyka 2: kompozycja composables
function useModuleStatus(moduleName) {
  const isOnline = ref(true)
  const temperature = ref(22)
  const powerConsumption = ref(45)

  const status = computed(() => {
    if (!isOnline.value) return { level: 'offline', color: '#666666' }
    if (temperature.value > 80) return { level: 'krytyczny', color: '#ff0055' }
    if (powerConsumption.value > 80) return { level: 'ostrzeżenie', color: '#ffb400' }
    return { level: 'optymalny', color: '#00ff88' }
  })

  // Używamy composable timera
  const uptime = useTimer()

  // Licznik czasu pracy startuje sam, gdy moduł jest online
  watch(isOnline, (newValue) => {
    if (newValue) {
      uptime.start()
    } else {
      uptime.pause()
    }
  }, { immediate: true })

  function toggleOnline() {
    isOnline.value = !isOnline.value
  }

  function adjustTemperature(delta) {
    temperature.value = Math.max(0, Math.min(100, temperature.value + delta))
  }

  function adjustPower(delta) {
    powerConsumption.value = Math.max(0, Math.min(100, powerConsumption.value + delta))
  }

  return {
    moduleName: ref(moduleName),
    isOnline,
    temperature,
    powerConsumption,
    status,
    uptime,
    toggleOnline,
    adjustTemperature,
    adjustPower
  }
}

// Dobra praktyka 3: opcje z wartościami domyślnymi
function useNotifications(options = {}) {
  const {
    maxNotifications = 10,
    autoRemove = true,
    autoRemoveDelay = 5000
  } = options

  const notifications = ref([])
  let notificationId = 0

  function add(message, type = 'info') {
    notificationId++
    const notification = {
      id: notificationId,
      message,
      type,
      timestamp: new Date()
    }

    notifications.value.unshift(notification)

    if (notifications.value.length > maxNotifications) {
      notifications.value.pop()
    }

    if (autoRemove) {
      setTimeout(() => {
        remove(notification.id)
      }, autoRemoveDelay)
    }

    return notification
  }

  function remove(id) {
    const index = notifications.value.findIndex(n => n.id === id)
    if (index !== -1) {
      notifications.value.splice(index, 1)
    }
  }

  function clear() {
    notifications.value = []
  }

  return {
    notifications,
    add,
    remove,
    clear
  }
}

// Inicjalizacja modułów
const habitatModule = useModuleStatus('Moduł mieszkalny')
const researchModule = useModuleStatus('Moduł badawczy')
const powerModule = useModuleStatus('Moduł energetyczny')

// Inicjalizacja powiadomień
const notify = useNotifications({
  maxNotifications: 5,
  autoRemove: true,
  autoRemoveDelay: 4000
})

// Symulacja zdarzeń w modułach
function simulateHeatWave(module) {
  module.adjustTemperature(30)
  notify.add(`Wykryto falę ciepła: ${module.moduleName.value}`, 'warning')
}

function simulateCooling(module) {
  module.adjustTemperature(-20)
  notify.add(`Włączono chłodzenie: ${module.moduleName.value}`, 'info')
}

function simulatePowerSpike(module) {
  module.adjustPower(40)
  notify.add(`Skok mocy: ${module.moduleName.value}`, 'warning')
}

onMounted(() => {
  notify.add('System integracji modułów NOVA LAB działa', 'success')
})
</script>

<template>
  <div class="integration-lab">
    <div class="header">
      <h1>Integracja Modułów - NOVA LAB</h1>
      <p class="subtitle">Moduł 6: dobre praktyki i wzorce composables</p>
    </div>

    <!-- Panel powiadomień -->
    <div class="notifications-panel">
      <div class="notifications-header">
        <h3>Powiadomienia systemu</h3>
        <button @click="notify.clear()" class="btn btn-sm btn-danger">Wyczyść wszystko</button>
      </div>
      <div class="notifications-list">
        <div
          v-for="notification in notify.notifications.value"
          :key="notification.id"
          class="notification"
          :class="'notification-' + notification.type"
        >
          <span class="notification-type">{{ notification.type.toUpperCase() }}</span>
          <span class="notification-message">{{ notification.message }}</span>
          <button @click="notify.remove(notification.id)" class="btn-close">×</button>
        </div>
      </div>
    </div>

    <!-- Siatka modułów -->
    <div class="modules-grid">
      <!-- Moduł mieszkalny -->
      <div class="module-card" :style="{ borderColor: habitatModule.status.value.color }">
        <div class="module-header">
          <h3>{{ habitatModule.moduleName.value }}</h3>
          <div
            class="status-badge"
            :style="{ background: habitatModule.status.value.color }"
          >
            {{ habitatModule.status.value.level.toUpperCase() }}
          </div>
        </div>

        <div class="module-stats">
          <div class="stat">
            <span class="stat-label">Temperatura:</span>
            <span class="stat-value">{{ habitatModule.temperature.value }}°C</span>
          </div>
          <div class="stat">
            <span class="stat-label">Moc:</span>
            <span class="stat-value">{{ habitatModule.powerConsumption.value }}%</span>
          </div>
          <div class="stat">
            <span class="stat-label">Czas pracy:</span>
            <span class="stat-value">{{ habitatModule.uptime.formattedTime.value }}</span>
          </div>
        </div>

        <div class="module-controls">
          <button
            @click="habitatModule.toggleOnline()"
            class="btn"
            :class="habitatModule.isOnline.value ? 'btn-warning' : 'btn-success'"
          >
            {{ habitatModule.isOnline.value ? 'Wyłącz' : 'Włącz' }}
          </button>
        </div>

        <div class="module-simulations">
          <button @click="simulateHeatWave(habitatModule)" class="btn btn-sm">Fala ciepła</button>
          <button @click="simulateCooling(habitatModule)" class="btn btn-sm">Chłodzenie</button>
          <button @click="simulatePowerSpike(habitatModule)" class="btn btn-sm">Skok mocy</button>
        </div>
      </div>

      <!-- Moduł badawczy -->
      <div class="module-card" :style="{ borderColor: researchModule.status.value.color }">
        <div class="module-header">
          <h3>{{ researchModule.moduleName.value }}</h3>
          <div
            class="status-badge"
            :style="{ background: researchModule.status.value.color }"
          >
            {{ researchModule.status.value.level.toUpperCase() }}
          </div>
        </div>

        <div class="module-stats">
          <div class="stat">
            <span class="stat-label">Temperatura:</span>
            <span class="stat-value">{{ researchModule.temperature.value }}°C</span>
          </div>
          <div class="stat">
            <span class="stat-label">Moc:</span>
            <span class="stat-value">{{ researchModule.powerConsumption.value }}%</span>
          </div>
          <div class="stat">
            <span class="stat-label">Czas pracy:</span>
            <span class="stat-value">{{ researchModule.uptime.formattedTime.value }}</span>
          </div>
        </div>

        <div class="module-controls">
          <button
            @click="researchModule.toggleOnline()"
            class="btn"
            :class="researchModule.isOnline.value ? 'btn-warning' : 'btn-success'"
          >
            {{ researchModule.isOnline.value ? 'Wyłącz' : 'Włącz' }}
          </button>
        </div>

        <div class="module-simulations">
          <button @click="simulateHeatWave(researchModule)" class="btn btn-sm">Fala ciepła</button>
          <button @click="simulateCooling(researchModule)" class="btn btn-sm">Chłodzenie</button>
          <button @click="simulatePowerSpike(researchModule)" class="btn btn-sm">Skok mocy</button>
        </div>
      </div>

      <!-- Moduł energetyczny -->
      <div class="module-card" :style="{ borderColor: powerModule.status.value.color }">
        <div class="module-header">
          <h3>{{ powerModule.moduleName.value }}</h3>
          <div
            class="status-badge"
            :style="{ background: powerModule.status.value.color }"
          >
            {{ powerModule.status.value.level.toUpperCase() }}
          </div>
        </div>

        <div class="module-stats">
          <div class="stat">
            <span class="stat-label">Temperatura:</span>
            <span class="stat-value">{{ powerModule.temperature.value }}°C</span>
          </div>
          <div class="stat">
            <span class="stat-label">Moc:</span>
            <span class="stat-value">{{ powerModule.powerConsumption.value }}%</span>
          </div>
          <div class="stat">
            <span class="stat-label">Czas pracy:</span>
            <span class="stat-value">{{ powerModule.uptime.formattedTime.value }}</span>
          </div>
        </div>

        <div class="module-controls">
          <button
            @click="powerModule.toggleOnline()"
            class="btn"
            :class="powerModule.isOnline.value ? 'btn-warning' : 'btn-success'"
          >
            {{ powerModule.isOnline.value ? 'Wyłącz' : 'Włącz' }}
          </button>
        </div>

        <div class="module-simulations">
          <button @click="simulateHeatWave(powerModule)" class="btn btn-sm">Fala ciepła</button>
          <button @click="simulateCooling(powerModule)" class="btn btn-sm">Chłodzenie</button>
          <button @click="simulatePowerSpike(powerModule)" class="btn btn-sm">Skok mocy</button>
        </div>
      </div>
    </div>

    <div class="info-panel">
      <h3>Dobre praktyki dla composables</h3>
      <div class="info-grid">
        <div class="info-section">
          <h4>1. Jedna odpowiedzialność</h4>
          <ul>
            <li>Każdy composable ma jedną odpowiedzialność</li>
            <li>useTimer - tylko zarządzanie timerem</li>
            <li>Łatwy w testowaniu i utrzymaniu</li>
          </ul>
        </div>

        <div class="info-section">
          <h4>2. Kompozycja composables</h4>
          <ul>
            <li>Łączenie composables dla złożonej logiki</li>
            <li>useModuleStatus używa useTimer</li>
            <li>Reużywalność i modularność</li>
          </ul>
        </div>

        <div class="info-section">
          <h4>3. Wzorzec opcji</h4>
          <ul>
            <li>Przyjmowanie opcji z wartościami domyślnymi</li>
            <li>useNotifications({ maxNotifications: 5 })</li>
            <li>Elastyczność i łatwe dostosowanie</li>
          </ul>
        </div>

        <div class="info-section">
          <h4>4. Konwencja nazewnictwa</h4>
          <ul>
            <li>Zawsze przedrostek "use"</li>
            <li>Opisowa nazwa: useModuleStatus</li>
            <li>Łatwe do zidentyfikowania</li>
          </ul>
        </div>
      </div>

      <div class="code-example">
        <code>
// Dobrze: jedna odpowiedzialność
function useTimer() { ... }

// Dobrze: kompozycja
function useModule() {
  const timer = useTimer()
  return { timer, ... }
}

// Dobrze: opcje z wartościami domyślnymi
function useNotify(options = {}) {
  const { maxItems = 10 } = options
  ...
}
        </code>
      </div>
    </div>
  </div>
</template>

<style scoped>
.integration-lab {
  background: linear-gradient(135deg, #0a0e27 0%, #1a1e3f 100%);
  min-height: 100vh;
  padding: 2rem;
  color: #ffffff;
  font-family: 'Courier New', monospace;
}

.header {
  text-align: center;
  margin-bottom: 2rem;
  padding-bottom: 1rem;
  border-bottom: 2px solid #00ff88;
}

.header h1 {
  font-size: 2.5rem;
  color: #00ff88;
  text-shadow: 0 0 20px rgba(0, 255, 136, 0.5);
  margin: 0;
}

.subtitle {
  color: #00b4d8;
  font-size: 1.2rem;
  margin-top: 0.5rem;
}

.notifications-panel {
  background: rgba(0, 180, 216, 0.05);
  border: 2px solid #00b4d8;
  border-radius: 10px;
  padding: 1.5rem;
  margin-bottom: 2rem;
}

.notifications-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 1rem;
}

.notifications-header h3 {
  color: #00b4d8;
  margin: 0;
}

.notifications-list {
  display: flex;
  flex-direction: column;
  gap: 0.5rem;
  max-height: 300px;
  overflow-y: auto;
}

.notification {
  display: flex;
  align-items: center;
  gap: 1rem;
  padding: 1rem;
  border-radius: 5px;
  border-left: 4px solid;
  animation: slideIn 0.3s ease;
}

@keyframes slideIn {
  from {
    transform: translateX(-20px);
    opacity: 0;
  }
  to {
    transform: translateX(0);
    opacity: 1;
  }
}

.notification-success {
  background: rgba(0, 255, 136, 0.1);
  border-color: #00ff88;
}

.notification-info {
  background: rgba(0, 180, 216, 0.1);
  border-color: #00b4d8;
}

.notification-warning {
  background: rgba(255, 180, 0, 0.1);
  border-color: #ffb400;
}

.notification-type {
  color: #00b4d8;
  font-size: 0.8rem;
  font-weight: bold;
  min-width: 80px;
}

.notification-message {
  flex: 1;
  color: #ffffff;
}

.btn-close {
  background: rgba(255, 0, 85, 0.3);
  color: #ff0055;
  border: none;
  width: 30px;
  height: 30px;
  border-radius: 50%;
  font-size: 1.5rem;
  cursor: pointer;
  display: flex;
  align-items: center;
  justify-content: center;
  transition: all 0.3s ease;
}

.btn-close:hover {
  background: #ff0055;
  color: #ffffff;
}

.modules-grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
  gap: 2rem;
  margin-bottom: 2rem;
}

.module-card {
  background: rgba(0, 255, 136, 0.05);
  border: 3px solid;
  border-radius: 10px;
  padding: 1.5rem;
  transition: all 0.3s ease;
}

.module-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 1.5rem;
}

.module-header h3 {
  color: #00ff88;
  margin: 0;
}

.status-badge {
  padding: 0.5rem 1rem;
  border-radius: 20px;
  font-size: 0.8rem;
  font-weight: bold;
  color: #0a0e27;
}

.module-stats {
  background: rgba(0, 0, 0, 0.3);
  border-radius: 8px;
  padding: 1rem;
  margin-bottom: 1rem;
}

.stat {
  display: flex;
  justify-content: space-between;
  padding: 0.5rem 0;
  border-bottom: 1px solid rgba(255, 255, 255, 0.1);
}

.stat:last-child {
  border-bottom: none;
}

.stat-label {
  color: #00b4d8;
}

.stat-value {
  color: #00ff88;
  font-weight: bold;
}

.module-controls {
  margin: 1rem 0;
}

.module-simulations {
  display: flex;
  gap: 0.5rem;
  flex-wrap: wrap;
}

.btn {
  padding: 0.75rem 1.5rem;
  border: none;
  border-radius: 5px;
  font-weight: bold;
  cursor: pointer;
  font-family: 'Courier New', monospace;
  transition: all 0.3s ease;
  width: 100%;
}

.btn-sm {
  padding: 0.5rem 1rem;
  font-size: 0.85rem;
  width: auto;
  flex: 1;
  background: rgba(0, 180, 216, 0.3);
  color: #00b4d8;
}

.btn-success {
  background: #00ff88;
  color: #0a0e27;
}

.btn-warning {
  background: #ffb400;
  color: #0a0e27;
}

.btn-danger {
  background: #ff0055;
  color: #ffffff;
}

.btn:hover {
  transform: scale(1.05);
  box-shadow: 0 5px 15px rgba(0, 255, 136, 0.3);
}

.info-panel {
  background: rgba(0, 255, 136, 0.05);
  border: 2px solid #00ff88;
  border-radius: 10px;
  padding: 2rem;
}

.info-panel h3 {
  color: #00ff88;
  margin-top: 0;
  margin-bottom: 1.5rem;
  text-align: center;
}

.info-grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
  gap: 1.5rem;
  margin-bottom: 2rem;
}

.info-section {
  background: rgba(0, 180, 216, 0.1);
  border: 2px solid #00b4d8;
  border-radius: 8px;
  padding: 1.5rem;
}

.info-section h4 {
  color: #00b4d8;
  margin-top: 0;
  margin-bottom: 1rem;
}

.info-section ul {
  list-style: none;
  padding: 0;
  margin: 0;
}

.info-section li {
  padding: 0.5rem 0;
  color: #ffffff;
  font-size: 0.9rem;
  line-height: 1.6;
}

.code-example {
  background: rgba(0, 0, 0, 0.5);
  border-left: 4px solid #00ff88;
  border-radius: 5px;
  padding: 1.5rem;
}

.code-example code {
  color: #00ff88;
  font-size: 0.9rem;
  white-space: pre;
  display: block;
}
</style>

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 powinien zwracać composable useExperiments?

  2. 2. Do czego używamy computed() w composables?

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

Zadania praktyczne w grze

  • Edytor kodu

    Zbuduj useExperiments z fetchExperiments, addExperiment, deleteExperiment i computed properties.

  • Układanie w pionie

    Ułóż workflow pracy z composables od stworzenia do użycia:

  • Klikanie w kolejności

    Ułóż pattern composable zarządzającego listą danych:

  • Układanie w poziomie

    Ułóż composable przyjmujący parametr:

  • Edytor kodu

    Zbuduj useLabFilters z search, category, sort i computed filteredItems.

  • Układanie w pionie

    Ułóż kroki integracji wielu composables w jednym komponencie:

  • Układanie w poziomie

    Ułóż computed property w composable:

  • Klikanie w kolejności

    Ułóż pełny cykl życia composable w aplikacji:

  • Układanie w pionie

    Ułóż architekturę Lab Manager od danych do widoku:

  • Klikanie w kolejności

    Ułóż script setup integrujący composables:

  • Układanie w poziomie

    Ułóż ścieżkę importu composable:

  • Układanie w pionie

    Ułóż kroki inicjalizacji composable który pobiera dane z serwera:

  1. PytanieComposable useExperiments
  2. PytanieComputed w composables
  3. Zadanie z kodemPraktyka: useExperiments
  4. Ułóż w kolejnościWorkflow composables
  5. Kliknij w kolejnościPattern composable z CRUD
  6. Ułóż w kolejnościComposable z parametrem
  7. Zadanie z kodemPraktyka: useLabFilters
  8. PytanieKompozycja composables
  9. Ułóż w kolejnościIntegracja composables w komponencie
  10. Ułóż w kolejnościComputed w composable
  11. Kliknij w kolejnościPełny cykl composable
  12. Ułóż w kolejnościKompozycja w Lab Manager
  13. Kliknij w kolejnościscript setup z composables
  14. Ułóż w kolejnościLokalizacja pliku composable
  15. Ułóż w kolejnościPoprawna inicjalizacja composable z API

Przydatne artykuły