Kurs Vue.js · Moduł 15: TypeScript i Nuxt

Typowanie Emits

2 min czytania ·
W tej lekcji5

Tak jak propsy definiują dane wejściowe komponentu, emity definiują zdarzenia wyjściowe. W TypeScript możemy precyzyjnie typować jakie zdarzenia komponent emituje i jakie dane niesie każde zdarzenie.

defineEmits z generycznym typem

<script setup lang="ts">
// Składnia generyczna
const emit = defineEmits<{
  (e: 'update', value: string): void
  (e: 'delete', id: number): void
  (e: 'close'): void
}>()

// Użycie
emit('update', 'new value')  // OK
emit('delete', 42)           // OK
emit('close')                // OK
// emit('update', 123)       // BŁĄD! Oczekiwany string, nie number
// emit('unknown')           // BŁĄD! Nieznane zdarzenie
</script>

Nowa składnia 3.3+

Od Vue 3.3 dostępna jest krótsza składnia:

<script setup lang="ts">
const emit = defineEmits<{
  update: [value: string]
  delete: [id: number]
  close: []
}>()
</script>

Obie składnie są równoważne. Nowa jest bardziej zwięzła - używamy nazwy zdarzenia jako klucza, a argumenty jako krotki (tuple).

Typowane zdarzenia w praktyce

Oto przykład panelu sterowania stacją:

<script setup lang="ts">
interface ModuleEvent {
  moduleId: string
  timestamp: number
}

const emit = defineEmits<{
  activate: [event: ModuleEvent]
  deactivate: [event: ModuleEvent]
  alert: [level: 'low' | 'medium' | 'high', message: string]
}>()

function handleActivation(moduleId: string) {
  emit('activate', {
    moduleId,
    timestamp: Date.now()
  })
}

function triggerAlert() {
  emit('alert', 'high', 'Anomalia kwantowa wykryta!')
}
</script>

Komunikacja rodzic-dziecko

Komponent dziecko emituje zdarzenia, rodzic nasłuchuje:

<!-- ControlPanel.vue (dziecko) -->
<script setup lang="ts">
const emit = defineEmits<{
  command: [action: string, target: string]
}>()
</script>

<template>
  <button @click="emit('command', 'scan', 'sector-7')">
    Skanuj Sektor 7
  </button>
</template>
<!-- App.vue (rodzic) -->
<template>
  <ControlPanel @command="handleCommand" />
</template>

<script setup lang="ts">
function handleCommand(action: string, target: string) {
  console.log(action, target)
  // TypeScript zna typy argumentów!
}
</script>

Łączenie Props i Emits

Wzorzec v-model z typami:

<script setup lang="ts">
const props = defineProps<{
  modelValue: string
}>()

const emit = defineEmits<{
  'update:modelValue': [value: string]
}>()

function onInput(event: Event) {
  const target = event.target as HTMLInputElement
  emit('update:modelValue', target.value)
}
</script>

<template>
  <input :value="modelValue" @input="onInput" />
</template>
Kod do tej lekcji: App.vue
<script setup lang="ts">
import { ref } from 'vue'
import CommandPanel from './CommandPanel.vue'

interface CommandLog {
  action: string
  target: string
  timestamp: string
}

const logs = ref<CommandLog[]>([])

function handleCommand(action: string, target: string) {
  logs.value.unshift({
    action,
    target,
    timestamp: new Date().toLocaleTimeString()
  })
}

function handleAlert(level: 'low' | 'medium' | 'high', message: string) {
  logs.value.unshift({
    action: 'ALERT [' + level + ']',
    target: message,
    timestamp: new Date().toLocaleTimeString()
  })
}
</script>

<template>
  <div class="nova-lab">
    <h1>NOVA LAB - Typowane Emits</h1>

    <CommandPanel
      @command="handleCommand"
      @alert="handleAlert"
    />

    <div class="log-section">
      <h2>Dziennik komend</h2>
      <div v-for="(log, i) in logs" :key="i" class="log-entry">
        <span class="time">{{ log.timestamp }}</span>
        <span class="action">{{ log.action }}</span>
        <span class="target">{{ log.target }}</span>
      </div>
      <p v-if="logs.length === 0" class="empty">Brak komend</p>
    </div>
  </div>
</template>

<style scoped>
.nova-lab {
  background: #0a0e27;
  color: #00ff88;
  min-height: 100vh;
  padding: 20px;
  font-family: monospace;
}
h1 { color: #00ff88; margin-bottom: 15px; }
h2 { color: #00b4d8; margin-top: 20px; }
.log-section { margin-top: 15px; }
.log-entry {
  display: flex;
  gap: 12px;
  padding: 8px 12px;
  margin: 4px 0;
  background: rgba(0,180,216,0.06);
  border-radius: 6px;
  font-size: 13px;
}
.time { color: #666; }
.action { color: #00b4d8; font-weight: bold; }
.target { color: #00ff88; }
.empty { color: #555; 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. Która składnia poprawnie definiuje typowane emity w Vue 3.3+?

  2. 2. Mając const emit = defineEmits<{ alert: [level: string, msg: string] }>(), które wywołanie jest poprawne?

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

Zadania praktyczne w grze

  • Klikanie w kolejności

    Ułóż kroki implementacji typowanego v-model w komponencie:

  • Układanie w pionie

    Uporządkuj przepływ danych w typowanej komunikacji rodzic-dziecko:

  1. PytanieSkładnia defineEmits generyczna
  2. PytanieWywołanie typowanego emit
  3. Kliknij w kolejnościWzorzec v-model z typami
  4. Ułóż w kolejnościKomunikacja komponentów z typami
  5. PytanieStarsza składnia emits

Przydatne artykuły