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

Reaktywne wzorce projektowe

7 min czytania ·
W tej lekcji4

W centrum kontroli NOVA LAB każdy system musi być niezawodny i przewidywalny. Problem pojawia się, gdy moduły muszą ze sobą współpracować: panel motywu i panel powiadomień powinny widzieć te same dane, czujnik ma zaalarmować kilka systemów naraz, a eksperyment nie może przeskoczyć z "przerwany" prosto do "zakończony". Wzorce projektowe z reaktywnością Vue 3 pozwalają budować takie systemy - jak sprawdzone protokoły inżynieryjne stacji kosmicznej.

Reactive Singleton

Czasem potrzebujemy jednej wspólnej instancji stanu - jak centralny komputer stacji, z którego korzystają wszystkie moduły. Sztuczka polega na tym, gdzie powstaje stan: obiekt reactive tworzymy poza funkcją composable, na poziomie modułu JavaScript, więc istnieje dokładnie raz. Funkcja readonly zwraca jego wersję tylko do odczytu:

import { reactive, readonly } from 'vue'

// Stan tworzony RAZ, poza funkcją
const globalState = reactive({
  currentUser: null,
  theme: 'dark',
  locale: 'pl',
  notifications: []
})

// Composable zwraca ten sam stan za każdym razem
export function useGlobalStore() {
  function setUser(user) {
    globalState.currentUser = user
  }

  function setTheme(theme) {
    globalState.theme = theme
  }

  function addNotification(msg) {
    globalState.notifications.push({
      id: Date.now(),
      message: msg,
      read: false
    })
  }

  // readonly zapobiega bezpośredniej modyfikacji
  return {
    state: readonly(globalState),
    setUser,
    setTheme,
    addNotification
  }
}

Zmiany przechodzą wyłącznie przez metody, a próba zapisu state.theme = 'light' w komponencie skończy się ostrzeżeniem w konsoli i wartość się nie zmieni. Użycie w dowolnym komponencie wygląda tak:

<!-- Dowolny komponent - ten sam stan -->
<script setup>
import { useGlobalStore } from './composables/useGlobalStore'

// Oba komponenty widzą te same dane
const { state, addNotification } = useGlobalStore()
</script>

<template>
  <p>Motyw: {{ state.theme }}</p>
  <p>Powiadomienia: {{ state.notifications.length }}</p>
</template>

Kluczowa różnica: stan jest zdefiniowany poza funkcją composable, więc każde wywołanie useGlobalStore() zwraca referencję do tego samego obiektu. Jedno zastrzeżenie: przy renderowaniu na serwerze (SSR) taki stan byłby wspólny dla wszystkich użytkowników. Dlatego w dużych aplikacjach tę rolę przejmuje Pinia, którą poznasz w Bazie Danych Misji.

Event Bus z reaktywnością

Vue 3 usunął metody $on i $off z instancji komponentu, na których w Vue 2 budowano globalny event bus. Możemy jednak stworzyć reaktywny system zdarzeń - jak sieć komunikacyjna stacji NOVA LAB. Mapa listeners przypisuje nazwie zdarzenia listę funkcji obsługi, a ref lastEvent pamięta ostatni sygnał. Oba powstają poza funkcją, jak w singletonie, dzięki czemu wszystkie komponenty nadają w tej samej sieci:

import { ref } from 'vue'

// Jedna sieć dla całej aplikacji - poza funkcją
const lastEvent = ref(null)
const listeners = new Map()

function useEventBus() {
  function emit(eventName, payload) {
    lastEvent.value = { name: eventName, payload, timestamp: Date.now() }

    const handlers = listeners.get(eventName) || []
    handlers.forEach(handler => handler(payload))
  }

  function on(eventName, handler) {
    if (!listeners.has(eventName)) {
      listeners.set(eventName, [])
    }
    listeners.get(eventName).push(handler)

    // Zwróć funkcję unsubscribe
    return () => {
      const handlers = listeners.get(eventName)
      const index = handlers.indexOf(handler)
      if (index > -1) handlers.splice(index, 1)
    }
  }

  return { lastEvent, emit, on }
}

Gdyby mapa powstawała w środku funkcji, każdy komponent miałby własną, prywatną sieć i sygnały z jednego modułu nie docierałyby do drugiego. Metoda on zwraca funkcję wypisującą obsługę z listy, a komponent musi ją wywołać przy odmontowaniu:

<script setup>
import { onUnmounted } from 'vue'

const { emit, on } = useEventBus()

// Subskrypcja z automatycznym cleanup
const unsubscribe = on('sensor-alert', (data) => {
  console.log('Alert z sensora:', data)
})

onUnmounted(() => {
  unsubscribe() // Ważne! Zapobiegamy wyciekom pamięci
})

// Emitowanie zdarzenia
emit('sensor-alert', { sensorId: 'T-01', value: 45 })
</script>

Bez unsubscribe odmontowany komponent zostałby w mapie na zawsze i dalej reagował na alarmy - to klasyczny wyciek pamięci.

State Machine z ref i computed

Automaty stanowe to idealny wzorzec do zarządzania złożonym stanem - jak protokoły bezpieczeństwa stacji, gdzie każdy stan ma dokładnie określone przejścia. Automat trzyma bieżący stan w refie, a listę dozwolonych zdarzeń wylicza przez computed:

import { ref, computed } from 'vue'

function useStateMachine(config) {
  const currentState = ref(config.initial)

  const availableTransitions = computed(() => {
    const stateConfig = config.states[currentState.value]
    return stateConfig ? Object.keys(stateConfig.on || {}) : []
  })

  function transition(event) {
    const stateConfig = config.states[currentState.value]
    if (!stateConfig || !stateConfig.on || !stateConfig.on[event]) {
      console.warn(
        `Niedozwolone przejście: ${currentState.value} -> ${event}`
      )
      return false
    }

    const nextState = stateConfig.on[event]
    currentState.value = nextState
    return true
  }

  function canTransition(event) {
    return availableTransitions.value.includes(event)
  }

  return { currentState, availableTransitions, transition, canTransition }
}

Metoda transition odrzuca zdarzenie, którego bieżący stan nie przewiduje, i zwraca false zamiast psuć dane. Całą wiedzę o przejściach opisujemy w obiekcie konfiguracji, gdzie pole on każdego stanu mapuje zdarzenie na stan docelowy:

<script setup>
const experimentMachine = useStateMachine({
  initial: 'idle',
  states: {
    idle: {
      on: { START: 'running', CONFIGURE: 'configuring' }
    },
    configuring: {
      on: { SAVE: 'idle', CANCEL: 'idle' }
    },
    running: {
      on: { PAUSE: 'paused', COMPLETE: 'completed', FAIL: 'failed' }
    },
    paused: {
      on: { RESUME: 'running', ABORT: 'failed' }
    },
    completed: {
      on: { RESET: 'idle' }
    },
    failed: {
      on: { RESET: 'idle', RETRY: 'running' }
    }
  }
})

// Używamy w template
// experimentMachine.currentState.value => 'idle'
// experimentMachine.transition('START') => stan zmienia się na 'running'
// experimentMachine.canTransition('PAUSE') => true (teraz jesteśmy w 'running')
</script>

Ze stanu idle nie da się wywołać PAUSE, więc przycisk pauzy możesz wyłączyć zwykłym :disabled="!experimentMachine.canTransition('PAUSE')".

Reactive Observer Pattern

Wzorzec obserwatora z reaktywnością Vue - jak system monitorowania, gdzie każdy sensor może mieć wielu obserwatorów. Każdy subskrybent to osobny watch, a funkcja zwrócona przez watch zatrzymuje go na żądanie:

import { ref, watch, readonly } from 'vue'

function useObservable(initialValue) {
  const value = ref(initialValue)
  const history = ref([])
  const observers = ref(0)

  // Każdy watch to nowy obserwator
  function subscribe(callback) {
    observers.value++
    const unwatch = watch(value, (newVal, oldVal) => {
      callback({ newVal, oldVal, timestamp: Date.now() })
    })

    return () => {
      unwatch()
      observers.value--
    }
  }

  function setValue(newValue) {
    history.value.push({
      from: value.value,
      to: newValue,
      timestamp: Date.now()
    })
    if (history.value.length > 100) history.value.shift()
    value.value = newValue
  }

  return {
    value: readonly(value),
    history: readonly(history),
    observers,
    subscribe,
    setValue
  }
}

Historia trzyma najwyżej 100 ostatnich zmian, a wartość i historię udostępniamy tylko do odczytu. W komponencie jest jedna pułapka: template automatycznie rozpakowuje tylko refy z najwyższego poziomu, a nie refy schowane w zwykłym obiekcie. Dlatego wyciągamy je destrukturyzacją:

<script setup>
import { onUnmounted } from 'vue'

const temperature = useObservable(22)
// Refy wyciągamy na najwyższy poziom, żeby template je rozpakował
const { value: currentTemp, history, observers } = temperature

// Obserwator 1 - alarm
const unsub1 = temperature.subscribe(({ newVal }) => {
  if (newVal > 40) console.warn('Temperatura krytyczna!')
})

// Obserwator 2 - logowanie
const unsub2 = temperature.subscribe(({ newVal, oldVal }) => {
  console.log(`Temp: ${oldVal} -> ${newVal}`)
})

onUnmounted(() => {
  unsub1()
  unsub2()
})

// Zmiana wartości powiadamia wszystkich obserwatorów
temperature.setValue(25)
</script>

<template>
  <p>Temperatura: {{ currentTemp }}°C</p>
  <p>Aktywni obserwatorzy: {{ observers }}</p>
  <p>Historia zmian: {{ history.length }}</p>
</template>

Panel pokaże 25°C, dwóch obserwatorów i jedną zmianę w historii, a konsola wypisze "Temp: 22 -> 25". Gdybyś napisał w szablonie temperature.history.length, zobaczyłbyś puste miejsce, bo zagnieżdżony ref nie zostałby rozpakowany.

Moja rada: zanim sięgniesz po event bus, sprawdź, czy wystarczą props i emity, provide/inject albo wspólny store. Dokumentacja Vue odradza globalny bus w większości sytuacji, bo przepływ danych staje się niewidoczny. VueUse, które poznasz w następnej lekcji, ma zresztą gotowe useEventBus. W edytorze poniżej singleton przełącza motyw, automat prowadzi eksperyment przez kolejne stany, a obserwowana temperatura powiadamia subskrybentów.

Zapamiętaj: dobry wzorzec to protokół stacji - mówi, kto może zmienić stan, kiedy i kogo trzeba o tym zawiadomić.

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

// ===== REAKTYWNY SINGLETON =====
const globalState = {
  theme: ref('dark'),
  locale: ref('pl'),
  notifications: ref([])
}

function useGlobalStore() {
  function setTheme(t) { globalState.theme.value = t }
  function addNotification(msg) {
    globalState.notifications.value.push({ id: Date.now(), message: msg })
  }
  return {
    theme: globalState.theme,
    locale: globalState.locale,
    notifications: globalState.notifications,
    setTheme,
    addNotification
  }
}

// ===== STATE MACHINE (maszyna stanów) =====
function useStateMachine(config) {
  const currentState = ref(config.initial)

  const availableTransitions = computed(() => {
    const sc = config.states[currentState.value]
    return sc ? Object.keys(sc.on || {}) : []
  })

  function transition(event) {
    const sc = config.states[currentState.value]
    if (!sc || !sc.on || !sc.on[event]) return false
    currentState.value = sc.on[event]
    return true
  }

  function canTransition(event) {
    return availableTransitions.value.includes(event)
  }

  return { currentState, availableTransitions, transition, canTransition }
}

// ===== REAKTYWNY OBSERWATOR =====
function useObservable(initialValue) {
  const value = ref(initialValue)
  const history = ref([])
  const observerCount = ref(0)

  function subscribe(callback) {
    observerCount.value++
    const unwatch = watch(value, (newVal, oldVal) => {
      callback({ newVal, oldVal })
    })
    return () => { unwatch(); observerCount.value-- }
  }

  function setValue(newValue) {
    history.value.push({ from: value.value, to: newValue, time: new Date().toLocaleTimeString() })
    if (history.value.length > 15) history.value.shift()
    value.value = newValue
  }

  return { value, history, observerCount, subscribe, setValue }
}

// === Instancje ===
const store = useGlobalStore()

const experiment = useStateMachine({
  initial: 'idle',
  states: {
    idle: { on: { START: 'running', CONFIGURE: 'configuring' } },
    configuring: { on: { SAVE: 'idle', CANCEL: 'idle' } },
    running: { on: { PAUSE: 'paused', COMPLETE: 'completed', FAIL: 'failed' } },
    paused: { on: { RESUME: 'running', ABORT: 'failed' } },
    completed: { on: { RESET: 'idle' } },
    failed: { on: { RESET: 'idle', RETRY: 'running' } }
  }
})

const temperature = useObservable(22)

// Subskrypcja obserwatorów
const alerts = ref([])
temperature.subscribe(({ newVal }) => {
  if (newVal > 35) alerts.value.unshift('ALARM: temperatura ' + newVal + '°C!')
  if (alerts.value.length > 5) alerts.value.pop()
})
temperature.subscribe(({ newVal, oldVal }) => {
  store.addNotification('Temperatura: ' + oldVal + ' -> ' + newVal)
})
</script>

<template>
  <div class="lab" :class="store.theme.value">
    <h1>Wzorce reaktywne - NOVA LAB</h1>

    <section>
      <h2>Store jako singleton</h2>
      <p>Motyw: {{ store.theme.value }} | Język: {{ store.locale.value }}</p>
      <button @click="store.setTheme(store.theme.value === 'dark' ? 'light' : 'dark')">Przełącz motyw</button>
      <div class="notifs">
        <div v-for="n in store.notifications.value.slice(-5)" :key="n.id" class="notif">{{ n.message }}</div>
      </div>
    </section>

    <section>
      <h2>State Machine - eksperyment</h2>
      <div class="state-display">{{ experiment.currentState.value.toUpperCase() }}</div>
      <div class="transitions">
        <button v-for="t in experiment.availableTransitions.value" :key="t"
          @click="experiment.transition(t)" class="trans-btn">
          {{ t }}
        </button>
      </div>
      <p v-if="!experiment.availableTransitions.value.length" class="info">Brak przejść (stan końcowy)</p>
    </section>

    <section>
      <h2>Observable - temperatura</h2>
      <p>Wartość: {{ temperature.value.value }}°C | Obserwatorzy: {{ temperature.observerCount.value }}</p>
      <div class="temp-controls">
        <button @click="temperature.setValue(temperature.value.value - 5)">-5°C</button>
        <button @click="temperature.setValue(temperature.value.value + 5)">+5°C</button>
        <button @click="temperature.setValue(Math.round(Math.random() * 50))">Losowo</button>
      </div>
      <div class="history">
        <div v-for="(h, i) in temperature.history.value.slice(-8)" :key="i" class="hist-item">
          {{ h.time }}: {{ h.from }}°C -> {{ h.to }}°C
        </div>
      </div>
      <div v-if="alerts.length" class="alerts">
        <div v-for="(a, i) in alerts" :key="i" class="alert">{{ a }}</div>
      </div>
    </section>
  </div>
</template>

<style scoped>
.lab { background: #0a0e27; color: #e0e0ff; padding: 1.5rem; min-height: 100vh; font-family: 'Courier New', monospace; transition: all 0.3s; }
.lab.light { background: #f0f0f5; color: #1a1a3f; }
h1 { color: #00ff88; text-align: center; }
h2 { color: #00b4d8; border-bottom: 1px solid #00b4d8; padding-bottom: 0.5rem; }
section { margin: 1.5rem 0; }
button { background: #00b4d8; color: #fff; border: none; padding: 0.5rem 1rem; border-radius: 4px; cursor: pointer; margin: 0.2rem; font-family: inherit; }
button:hover { background: #00ff88; color: #0a0e27; }
.state-display { font-size: 2rem; font-weight: bold; color: #00ff88; text-align: center; padding: 1rem; background: rgba(0,255,136,0.1); border: 2px solid #00ff88; border-radius: 8px; margin: 1rem 0; }
.transitions { display: flex; flex-wrap: wrap; gap: 0.5rem; justify-content: center; }
.trans-btn { background: #333; }
.trans-btn:hover { background: #00b4d8; }
.temp-controls { display: flex; gap: 0.5rem; margin: 0.5rem 0; }
.history { background: rgba(0,0,0,0.3); padding: 0.5rem; border-radius: 4px; margin: 0.5rem 0; }
.hist-item { font-size: 0.8rem; color: #aaa; padding: 0.2rem 0; }
.notifs { margin-top: 0.5rem; }
.notif { font-size: 0.8rem; color: #00b4d8; padding: 0.2rem 0; }
.alerts { margin-top: 0.5rem; }
.alert { background: rgba(255,0,85,0.15); border-left: 3px solid #ff0055; padding: 0.3rem 0.6rem; margin: 0.2rem 0; font-size: 0.85rem; color: #ff4444; }
.info { color: #666; font-style: italic; }
</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 oznacza wzorzec Reactive Singleton w composables?

  2. 2. Jaka jest główna zaleta wzorca State Machine z ref i computed?

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

Zadania praktyczne w grze

  • Edytor kodu

    Zbuduj useStateMachine z currentState (ref), availableTransitions (computed), transition() i canTransition(). Konfiguracja jako parametr.

  • Układanie w pionie

    Ułóż kroki tworzenia Reactive Singleton composable:

  • Klikanie w kolejności

    Ułóż kroki subskrypcji i emitowania zdarzenia:

  • Edytor kodu

    Zbuduj useObservable z value (ref), history (ref), subscribe() zwracający unsubscribe, setValue() i observers count.

  • Układanie w poziomie

    Ułóż wywołanie przejścia stanu w State Machine:

  1. PytanieReactive Singleton
  2. PytanieState Machine w Vue
  3. Zadanie z kodemPraktyka: State Machine composable
  4. Ułóż w kolejnościCykl życia Reactive Singleton
  5. Pytaniereadonly w Singleton
  6. Kliknij w kolejnościUżycie Event Bus composable
  7. Zadanie z kodemPraktyka: Reactive Observer pattern
  8. Ułóż w kolejnościTransition w State Machine

Przydatne artykuły