Skip to content

3. Los componentes

Hasta ahora, cada ejemplo cabía en un solo componente, [App.vue]. Una aplicación real contiene decenas de ellos: una barra de navegación, formularios, ventanas... Cada componente es una pieza autónoma de la interfaz (su HTML, su código, su estilo) y es reutilizable. Este capítulo muestra cómo encajan y se comunican los componentes.

3.1. Ejemplo 07: los componentes y sus props

El ejemplo muestra una tarjeta por médico. La tarjeta es un componente, [DoctorCard.vue], que su componente padre, [App.vue], usa tres veces.

El tipo médico, compartido por ambos componentes, se encuentra en un archivo [TypeScript] normal:

1
2
3
4
5
6
7
8
9
// el tipo de datos compartido por el padre (App.vue) y el hijo (DoctorCard.vue)
export interface Doctor {
  id: number;
  title: string;
  firstName: string;
  lastName: string;
  specialty: string;
  available: boolean;
}

El componente hijo:

<!--
  =========================================================================
  07-components/src/components/DoctorCard.vue - un componente HIJO
  -------------------------------------------------------------------------
  Recibe sus datos de su padre mediante PROPS (propiedades), declaradas
  con defineProps. El tipo TypeScript de las props se verifica en tiempo de
  compilación: <DoctorCard :doctor="42"> sería rechazado.

  Regla de oro: un componente NUNCA MODIFICA sus props. Los datos
  fluyen hacia abajo, del padre al hijo ("one-way data flow"); para
  solicitar un cambio, el hijo emite un evento (vea el ejemplo 08).
  =========================================================================
-->
<script setup lang="ts">
import { computed } from 'vue';
import type { Doctor } from '../doctor';

// withDefaults: un valor predeterminado para las props opcionales (?)
const props = withDefaults(
  defineProps<{
    doctor: Doctor;
    rank: number;
    compact?: boolean;
  }>(),
  { compact: false },
);

// un computed basado en una prop: se recalcula si el padre cambia la prop
const initials = computed(() => `${props.doctor.firstName[0]}${props.doctor.lastName[0]}`);
</script>

<template>
  <div class="card h-100" :class="{ 'border-success': doctor.available }">
    <div class="card-body d-flex gap-3 align-items-center">
      <div class="initials">{{ initials }}</div>
      <div>
        <!-- en la plantilla, las props se usan directamente por su nombre -->
        <h2 class="h6 mb-1">{{ rank }}. {{ doctor.title }} {{ doctor.firstName }} {{ doctor.lastName }}</h2>
        <p v-if="!compact" class="mb-0 text-muted small">{{ doctor.specialty }}</p>
      </div>
    </div>
  </div>
</template>

<style scoped>
.initials {
  width: 2.5rem;
  height: 2.5rem;
  border-radius: 50%;
  display: flex;
  align-items: center;
  justify-content: center;
  background: #0d6efd;
  color: white;
  font-weight: bold;
}
</style>
  • Línea 16: [import type] importa solamente un tipo: nada de esta importación permanece en el [JavaScript] resultante;
  • Líneas 19–26: [defineProps<{...}>()] declara las props del componente —es decir, los datos que recibe de su padre— junto con sus tipos. Una prop seguida de [?] es opcional; [withDefaults] le da un valor predeterminado. [defineProps] no necesita importarse: es una “macro” reconocida por el compilador de archivos [.vue];
  • Línea 29: en el script, las props se leen mediante el objeto [props]. [computed] hace seguimiento de las props: si el padre cambia el médico asignado, las iniciales se recalculan;
  • línea 38: en la plantilla, las props se usan directamente por su nombre;
  • línea 39: una prop puede modificar la visualización.

El padre:

<!--
  =========================================================================
  07-components/src/App.vue - el componente PADRE
  -------------------------------------------------------------------------
  Importa el componente DoctorCard y lo usa como una nueva
  etiqueta HTML, <DoctorCard>, tantas veces como sea necesario: un componente
  es una pieza REUTILIZABLE de interfaz, con sus propios datos, su
  plantilla y su estilo.
  =========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';
// en <script setup>, un componente importado se puede usar de inmediato en la plantilla
import DoctorCard from './components/DoctorCard.vue';
import type { Doctor } from './doctor';

const doctors = ref<Doctor[]>([
  { id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner', available: true },
  { id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician', available: false },
  { id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner', available: true },
]);
const compact = ref(false);

// el padre modifica SUS datos: los hijos afectados se actualizan solos
function toggleAvailability(): void {
  for (const m of doctors.value) {
    m.available = !m.available;
  }
}
</script>

<template>
  <div class="container py-4">
    <h1 class="h3 mb-3">Example 07 - components and their props</h1>
    <div class="d-flex gap-3 mb-3">
      <label class="form-check-label"><input v-model="compact" type="checkbox" class="form-check-input"> compact display</label>
      <button class="btn btn-sm btn-outline-primary" @click="toggleAvailability">Toggle availabilities</button>
    </div>
    <div class="row g-3">
      <div v-for="(m, i) in doctors" :key="m.id" class="col-md-4">
        <!-- :doctor="m" pasa el OBJETO m (una expresión);
             compact, sin dos puntos, pasaría la CADENA "compact" -->
        <DoctorCard :doctor="m" :rank="i + 1" :compact="compact" />
      </div>
    </div>
  </div>
</template>
  • línea 14: en [<script setup>], un componente importado se puede usar de inmediato en la plantilla, como una nueva etiqueta;
  • línea 43: cada tarjeta recibe SU médico. [:doctor="m"] (con dos puntos) pasa el valor de la expresión [m]; sin los dos puntos, se pasaría la cadena de caracteres ["m"], que [TypeScript] rechazaría aquí. Los nombres de las etiquetas de componentes se escriben en [PascalCase] para distinguirlos de las etiquetas HTML;
  • líneas 25–29: el padre modifica SUS datos; las tarjetas afectadas se actualizan.

La regla de oro: un componente nunca modifica sus propias props. Los datos fluyen del padre al hijo ([one-way data flow]): el padre es su propietario. Para solicitar un cambio, el hijo emite un evento, que el padre procesa: este es el tema del siguiente ejemplo.

Image

3.2. Ejemplo 08: eventos de componentes y v-model

3.2.1. Emitir un evento

El componente [Counter] notifica a su padre cada vez que se hace clic en su botón:

<!--
  =========================================================================
  08-component-events/src/components/Counter.vue
  -------------------------------------------------------------------------
  Un hijo que NOTIFICA a su padre: defineEmits declara los eventos
  que puede emitir, con el tipo de sus datos. El padre los escucha
  como eventos HTML: <Counter @change="..." @limit="...">.
  =========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';

const props = defineProps<{ label: string; max: number }>();

// dos eventos: 'change' (con el nuevo valor) y 'limit' (sin datos)
const emit = defineEmits<{
  change: [value: number];
  limit: [];
}>();

const value = ref(0);

function plus(): void {
  if (value.value >= props.max) {
    emit('limit');
    return;
  }
  value.value++;
  emit('change', value.value);
}
</script>

<template>
  <div class="d-flex align-items-center gap-2 mb-2">
    <span class="w-25">{{ label }}</span>
    <button class="btn btn-sm btn-outline-primary" @click="plus">+1</button>
    <span class="badge text-bg-secondary">{{ value }} / {{ max }}</span>
  </div>
</template>
  • Líneas 16–19: [defineEmits] declara los eventos que el componente puede emitir, junto con los tipos de sus datos: [change] lleva un número, [limit] no lleva nada;
  • Líneas 25 y 29: emisión de un evento. [TypeScript] verifica el nombre del evento y el tipo de sus datos;
  • Línea 21: el hijo puede tener su propio estado: [value] le pertenece a él, no al padre.

3.2.2. v-model en un componente

El componente [TextField] es un campo de formulario “personalizado”: una etiqueta, el campo en sí, un texto de ayuda y un contador de caracteres. Queremos usarlo con [v-model], igual que un [<input>] normal:

<!--
  =========================================================================
  08-component-events/src/components/TextField.vue
  -------------------------------------------------------------------------
  Un campo de formulario "casero" (etiqueta + campo + ayuda + contador de
  caracteres) que acepta v-model, como un <input> normal:
      <TextField v-model="lastName" label="Last name" :max="20" />

  defineModel() crea un ref enlazado al v-model del padre: LEERLO da el valor
  del padre, ESCRIBIRLO emite el evento 'update:modelValue', que el
  padre gestiona actualizando sus datos. Así, el dato sigue siendo
  propiedad del padre.
  =========================================================================
-->
<script setup lang="ts">
import { useId } from 'vue';

const model = defineModel<string>({ required: true });
defineProps<{ label: string; max: number; help?: string }>();

// un identificador único por instancia, para enlazar <label for> y <input id>
const id = useId();
</script>

<template>
  <div class="mb-3">
    <label class="form-label" :for="id">{{ label }}</label>
    <!-- v-model="model": el campo nativo queda enlazado al ref de defineModel -->
    <input :id="id" v-model="model" class="form-control" :maxlength="max" :class="{ 'is-invalid': model.length === max }">
    <div class="form-text">{{ help }} ({{ model.length }} / {{ max }})</div>
  </div>
</template>
  • Línea 18: [defineModel] crea un [ref] vinculado al [v-model] del padre. Al leerlo se obtiene el valor del padre; al escribir en él se emite el evento [update:modelValue], que el padre maneja modificando SUS datos. [v-model="lastName"] en un componente es simplemente un atajo para la propiedad [modelValue] y este evento: el dato sigue siendo propiedad del padre;
  • línea 22: [useId()] proporciona un identificador único por instancia de componente: las dos instancias de [TextField] en la página no tendrán el mismo [id], y cada [<label for>] hace referencia correctamente a SU campo;
  • Línea 29: el campo nativo está vinculado al [ref] de [defineModel].

3.2.3. El padre

<!--
  =========================================================================
  08-component-events/src/App.vue - el padre escucha a sus hijos
  -------------------------------------------------------------------------
  Dos maneras de que un hijo pase información hacia arriba:
    1. emitir un evento, que el padre escucha con @ (Counter);
    2. v-model en un componente (TextField): un atajo para la prop
       modelValue + el evento update:modelValue.
  =========================================================================
-->
<script setup lang="ts">
import { computed, ref } from 'vue';
import Counter from './components/Counter.vue';
import TextField from './components/TextField.vue';

const total = ref(0);
const message = ref('');
const firstName = ref('Marie');
const lastName = ref('PELISSIER');
const fullName = computed(() => `${firstName.value} ${lastName.value.toUpperCase()}`);

// el manejador del evento 'change': recibe los datos emitidos
function onChange(label: string, value: number): void {
  total.value++;
  message.value = `${label} is now ${value}`;
}
</script>

<template>
  <div class="container py-4" style="max-width: 640px">
    <h1 class="h3 mb-3">Example 08 - events and v-model on a component</h1>

    <div class="card p-3 mb-4">
      <h2 class="h6">1. Events emitted by the children</h2>
      <Counter label="Coffees" :max="3" @change="(v) => onChange('Coffees', v)" @limit="message = 'No more than 3 coffees!'" />
      <Counter label="Glasses of water" :max="8" @change="(v) => onChange(`Glasses of water`, v)" @limit="message = 'Enough drinking.'" />
      <p class="mb-0">Total clicks: {{ total }} - <em>{{ message }}</em></p>
    </div>

    <div class="card p-3">
      <h2 class="h6">2. v-model on a component</h2>
      <TextField v-model="firstName" label="First name" :max="20" help="Required" />
      <TextField v-model="lastName" label="Last name" :max="20" help="Displayed in upper case" />
      <p class="mb-0">Data of the parent: <strong>{{ fullName }}</strong></p>
      <button class="btn btn-sm btn-outline-secondary mt-2 align-self-start" @click="firstName = ''; lastName = ''">Clear (from the parent)</button>
    </div>
  </div>
</template>
  • Línea 35: el padre escucha los eventos de sus hijos mediante [@], igual que los eventos HTML. La función flecha [(v) => onChange('Coffees', v)] recibe los datos del evento; [@limit] ejecuta una sola instrucción;
  • línea 42: [v-model] en un componente;
  • línea 45: cuando el PADRE vacía sus datos, los campos lo siguen: el vínculo funciona en ambos sentidos.

Image

3.3. Ejemplo 09: plantillas y slots

Las props pasan datos; los slots pasan contenido: HTML u otros componentes. El componente [Card] define el marco (borde, encabezado, pie de página), y su padre determina lo que va dentro:

<!--
  =========================================================================
  09-slots/src/components/Card.vue - una PLANTILLA reutilizable
  -------------------------------------------------------------------------
  Las props pasan DATOS; los slots pasan CONTENIDO
  (HTML, otros componentes). Card define el marco (borde, encabezado,
  pie de página), el padre proporciona lo que va dentro:
    - <slot />              el slot por defecto: el contenido "principal";
    - <slot name="header">  un slot con nombre, llenado por <template #header>;
    - el texto colocado ENTRE <slot> y </slot> se muestra si el padre
      no proporciona nada (contenido por defecto).
  Es el equivalente del lado del cliente de la plantilla layout.hbs y su {{{body}}}
  en el curso de NestJS.
  =========================================================================
-->
<script setup lang="ts">
defineProps<{ color?: 'primary' | 'success' | 'danger' }>();
</script>

<template>
  <div class="card mb-3" :class="color ? `border-${color}` : ''">
    <div class="card-header" :class="color ? `text-bg-${color}` : ''">
      <slot name="header">Untitled</slot>
    </div>
    <div class="card-body">
      <slot />
    </div>
    <!-- $slots.footer: ¿el padre proporcionó un pie? Si no, ningún <div> vacío -->
    <div v-if="$slots.footer" class="card-footer text-muted small">
      <slot name="footer" />
    </div>
  </div>
</template>
  • línea 23: un slot con nombre; el texto entre [<slot>] y [</slot>] se muestra si el padre no proporciona nada;
  • línea 26: el slot predeterminado: el contenido “principal”;
  • línea 29: [$slots] indica qué slots ha llenado el padre: sin pie de página, no hay un [<div>] vacío.

Este es el equivalente en el cliente de la plantilla [layout.hbs] y su [{{{body}}}] en el curso [NestJS].

Un segundo componente, [DataTable], muestra filas de cualquier tipo:

<!--
  =========================================================================
  09-slots/src/components/DataTable.vue - una tabla GENÉRICA, con un slot "con alcance"
  -------------------------------------------------------------------------
  generic="T": un componente genérico, como una clase
  genérica de TypeScript - muestra filas de cualquier tipo T.

  La tabla sabe recorrer las filas, pero no cómo mostrar una
  fila: PASA cada fila a su slot (<slot name="row" :row="l">),
  y es el padre quien dice qué hacer con ella (<template #row="{ row }">).
  Esto se llama un slot "con alcance" (scoped): el contenido proporcionado por el padre usa
  datos que pertenecen al hijo.
  =========================================================================
-->
<script setup lang="ts" generic="T extends { id: number }">
defineProps<{ rows: T[]; columns: string[] }>();
</script>

<template>
  <table class="table table-sm align-middle mb-0">
    <thead>
      <tr><th v-for="c in columns" :key="c">{{ c }}</th></tr>
    </thead>
    <tbody>
      <tr v-for="(l, i) in rows" :key="l.id">
        <slot name="row" :row="l" :index="i" />
      </tr>
      <tr v-if="rows.length === 0">
        <td :colspan="columns.length" class="text-muted"><slot name="empty">No data.</slot></td>
      </tr>
    </tbody>
  </table>
</template>
  • línea 15: un componente genérico, como una clase genérica de [TypeScript]: [T] es el tipo de las filas, de las cuales solo se exige una propiedad: [id] (para la clave de [v-for]);
  • Línea 26: el arreglo sabe recorrer las filas, pero no cómo mostrar una fila. Pasa cada fila a su slot, y el padre la muestra. Esto se denomina slot “con alcance” (scoped): el contenido proporcionado por el padre usa datos que pertenecen al hijo.

El padre:

<!--
  =========================================================================
  09-slots/src/App.vue - using the Card and DataTable templates
  =========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';
import Card from './components/Card.vue';
import DataTable from './components/DataTable.vue';

interface Slot {
  id: number;
  time: string;
  patient: string | null;
}

const slots = ref<Slot[]>([
  { id: 1, time: '8:00 - 8:20', patient: null },
  { id: 2, time: '8:20 - 8:40', patient: 'Mme Alice DURAND' },
  { id: 3, time: '8:40 - 9:00', patient: null },
]);
</script>

<template>
  <div class="container py-4" style="max-width: 720px">
    <h1 class="h3 mb-3">Example 09 - templates and slots</h1>

    <!-- #header es la forma corta de v-slot:header -->
    <Card color="primary">
      <template #header>Schedule of Mme PELISSIER</template>
      <!-- el slot predeterminado: todo lo que no está en un <template #...> -->
      <DataTable :rows="slots" :columns="['#', 'Slot', 'Status']">
        <!-- recibimos los datos pasados por el DataTable: { row, index } -->
        <template #row="{ row, index }">
          <td>{{ index + 1 }}</td>
          <td>{{ row.time }}</td>
          <td>
            <span v-if="row.patient" class="badge text-bg-secondary">{{ row.patient }}</span>
            <span v-else class="badge text-bg-success">Free</span>
          </td>
        </template>
      </DataTable>
      <template #footer>{{ slots.filter((c) => c.patient === null).length }} free slot(s)</template>
    </Card>

    <Card color="success">
      <template #header>A card without a footer</template>
      <p class="mb-0">The footer is not provided: the card does not display it.</p>
    </Card>

    <Card>
      <!-- sin encabezado proporcionado: el contenido predeterminado del slot, "Untitled" -->
      <DataTable :rows="[]" :columns="['Name']">
        <template #empty>Nobody for now.</template>
      </DataTable>
    </Card>
  </div>
</template>
  • línea 30: [<template #header>] (abreviatura de [v-slot:header]) llena el slot llamado [header];
  • línea 32: todo lo que no esté dentro de un [<template #...>] va al slot predeterminado;
  • línea 34: se recuperan los datos pasados a través del arreglo. Gracias al componente genérico, [TypeScript] sabe que [row] es un [Slot];
  • línea 51: una tarjeta sin encabezado: se muestra el contenido predeterminado, “Sin título”.

Image

3.4. Ejemplo 10: el ciclo de vida de un componente

Un componente se crea, se muestra, se actualiza y luego se elimina. [Vue.js] permite ejecutar código en cada una de estas etapas. El componente [Clock]:

<!--
  =========================================================================
  10-lifecycle/src/components/Clock.vue
  -------------------------------------------------------------------------
  El ciclo de vida de un componente:
    1. setup      : se ejecuta el código de <script setup> (creación);
    2. onMounted  : el componente se MUESTRA, sus elementos HTML existen;
    3. onUpdated  : su visualización acaba de actualizarse;
    4. onUnmounted: el componente ha sido QUITADO de la página.
  Un reloj inicia un temporizador (setInterval) cuando se muestra... y debe
  detenerlo sin falta cuando desaparece: de lo contrario, el temporizador
  seguiría ejecutándose en vano (fuga de memoria).
  =========================================================================
-->
<script setup lang="ts">
import { onMounted, onUnmounted, ref } from 'vue';

const emit = defineEmits<{ log: [message: string] }>();

const time = ref(new Date().toLocaleTimeString());
let timer: number | undefined;

emit('log', 'Clock: setup (creation)');

onMounted(() => {
  emit('log', 'Clock: onMounted - starting the timer');
  timer = window.setInterval(() => {
    time.value = new Date().toLocaleTimeString();
  }, 1000);
});

onUnmounted(() => {
  window.clearInterval(timer);
  emit('log', 'Clock: onUnmounted - timer stopped');
});
</script>

<template>
  <div class="display-6 font-monospace">{{ time }}</div>
</template>
  • línea 23: el código de [<script setup>] se ejecuta una vez cuando el componente se crea;
  • líneas 25–30: [onMounted]: el componente se ha mostrado y sus elementos HTML existen. Se inicia el temporizador;
  • líneas 32–35: [onUnmounted]: el componente se ha eliminado de la página. Hay que detener el temporizador; de lo contrario, seguiría ejecutándose para un componente que ya no existe (una “fuga de memoria”).

El padre:

<!--
  =========================================================================
  10-lifecycle/src/App.vue
  -------------------------------------------------------------------------
    - v-if sobre <Clock>: marcar / desmarcar la casilla crea / destruye el
      componente (onMounted / onUnmounted, vea Clock.vue);
    - un "template ref": ref="field" da acceso al propio elemento HTML <input>
      una vez que el componente se muestra (para darle el foco);
    - watch con { immediate: true }: se ejecuta de inmediato, luego en cada
      cambio;
    - nextTick: espera a que Vue haya actualizado la página.
  =========================================================================
-->
<script setup lang="ts">
import { nextTick, onMounted, ref, useTemplateRef, watch } from 'vue';
import Clock from './components/Clock.vue';

const withClock = ref(true);
const log = ref<string[]>([]);
const search = ref('');
const showSearch = ref(false);

// el elemento <input ref="field"> de la plantilla (null mientras no se muestre)
const field = useTemplateRef<HTMLInputElement>('field');

function trace(message: string): void {
  log.value.push(`${new Date().toLocaleTimeString()} ${message}`);
}

onMounted(() => trace('App: onMounted'));

watch(
  search,
  (value) => {
    document.title = value ? `Search: ${value}` : 'Example 10';
  },
  { immediate: true },
);

async function openSearch(): Promise<void> {
  showSearch.value = true;
  // en este momento, el <input> todavía no existe: Vue actualizará la página
  // un poco más tarde. nextTick() espera esta actualización.
  await nextTick();
  field.value?.focus();
}
</script>

<template>
  <div class="container py-4" style="max-width: 720px">
    <h1 class="h3 mb-3">Example 10 - the lifecycle of a component</h1>

    <div class="card p-3 mb-3">
      <label class="form-check-label mb-2">
        <input v-model="withClock" type="checkbox" class="form-check-input"> show the clock
      </label>
      <Clock v-if="withClock" @log="trace" />
    </div>

    <div class="card p-3 mb-3">
      <button v-if="!showSearch" class="btn btn-outline-primary align-self-start" @click="openSearch">
        Search...
      </button>
      <input v-else ref="field" v-model="search" class="form-control" placeholder="the tab title follows what you type">
    </div>

    <h2 class="h6">Log</h2>
    <ol class="small">
      <li v-for="(line, i) in log" :key="i">{{ line }}</li>
    </ol>
  </div>
</template>
  • Línea 57: marcar y desmarcar la casilla crea y destruye el reloj: el registro muestra [setup], [onMounted], [onUnmounted];
  • Línea 24: una referencia de plantilla: el atributo [ref="field"] del elemento [<input>] da acceso al propio elemento HTML. Es igual a [null] mientras el elemento no se muestre;
  • líneas 32–37: [watch] con [{ immediate: true }] se ejecuta de inmediato y luego en cada cambio: el título de la pestaña se actualiza a medida que se ingresa texto;
  • líneas 40–45: después de [showSearch.value = true], el campo aún no existe: [Vue.js] agrupa las actualizaciones de la página y las realiza un poco más tarde. [await nextTick()] espera esta actualización; solo entonces se puede dar el foco al campo.

Image

3.5. Ejemplo 11: composables, provide e inject

¿Cómo se puede compartir la lógica entre componentes? En el lado del servidor, [NestJS] inyectaba sus servicios en los controladores. [Vue.js] tiene sus composables: funciones simples, cuyos nombres comienzan con [use], que combinan estado reactivo y el código que lo acompaña.

// =========================================================================
// 11-composables/src/composables/useClock.ts - un COMPOSABLE
// -------------------------------------------------------------------------
// Un composable es una función simple, cuyo nombre comienza con "use"
// por convención, que agrupa un estado reactivo Y la lógica que lo acompaña
// (aquí: el temporizador, su inicio y su detención). Cada componente que
// lo llama obtiene SU propio reloj, sin copiar el código.
//
// Es la forma de Vue.js de compartir lógica entre componentes - el
// papel que, del lado del servidor, desempeñan los servicios de NestJS.
// =========================================================================

import { onMounted, onUnmounted, ref, type Ref } from 'vue';

export function useClock(periodMs = 1000): { now: Ref<Date> } {
  const now = ref(new Date());
  let timer: number | undefined;

  // los hooks de ciclo de vida se enlazan al componente que LLAMA al composable
  onMounted(() => {
    timer = window.setInterval(() => (now.value = new Date()), periodMs);
  });
  onUnmounted(() => window.clearInterval(timer));

  return { now };
}
  • línea 15: la función devuelve un objeto que contiene [ref] [now];
  • líneas 20–22: las funciones de ciclo de vida llamadas dentro de un composable quedan asociadas al componente que llama al composable: cada componente tiene su propio temporizador, que se detiene cuando el componente se destruye.

Un segundo composable, sin ciclo de vida:

// =========================================================================
// 11-composables/src/composables/useCart.ts
// -------------------------------------------------------------------------
// Un segundo composable, SIN ciclo de vida: un carrito (lista de artículos,
// total, agregar, quitar). Cada llamada a useCart() crea un carrito NUEVO:
// dos componentes que lo llaman tienen cada uno el suyo.
// (Para un carrito COMPARTIDO por toda la aplicación, vea provide / inject
// más abajo, y Pinia en el ejemplo 15.)
// =========================================================================

import { computed, ref } from 'vue';

export interface Item {
  label: string;
  price: number;
}

export function useCart() {
  const items = ref<Item[]>([]);
  const total = computed(() => items.value.reduce((sum, a) => sum + a.price, 0));

  function add(item: Item): void {
    items.value.push(item);
  }
  function remove(index: number): void {
    items.value.splice(index, 1);
  }

  return { items, total, add, remove };
}

// el tipo de lo que devuelve useCart: útil para provide / inject
export type Cart = ReturnType<typeof useCart>;
  • línea 19: cada llamada a [useCart()] crea un carrito de compras NUEVO;
  • línea 33: el tipo de lo que [useCart] devuelve, inferido por [TypeScript].

Para que varios componentes compartan el MISMO carrito de compras, usamos [provide] e [inject], una forma de inyección de dependencias:

// =========================================================================
// 11-composables/src/keys.ts - las claves de provide / inject
// -------------------------------------------------------------------------
// provide(key, value): un componente PONE A DISPOSICIÓN un valor para
// todos sus descendientes, sin importar su profundidad;
// inject(key): un descendiente lo recupera, sin que los componentes
// intermedios tengan que pasarlo de prop en prop.
// Es una forma de inyección de dependencias, como en NestJS.
//
// Un InjectionKey<T> (un Symbol tipado) garantiza que inject() devuelva un
// valor del tipo correcto.
// =========================================================================

import type { InjectionKey } from 'vue';
import type { Cart } from './composables/useCart';

export const CART_KEY: InjectionKey<Cart> = Symbol('cart');
  • Línea 17: la clave bajo la cual se proporciona el carrito de compras: un [Symbol] (valor único) tipado mediante [InjectionKey<Cart>], de modo que [inject] devuelva un objeto del tipo correcto.

El componente raíz crea el carrito de compras y lo proporciona:

<!--
  =========================================================================
  11-composables/src/App.vue
  -------------------------------------------------------------------------
    - useClock(): App tiene su reloj (1 s), CartSummary el suyo (5 s);
    - useCart() + provide: App crea UN solo carrito y lo proporciona a todos sus
      descendientes; Catalog y CartSummary lo inyectan y, por lo tanto,
      comparten el mismo.
  =========================================================================
-->
<script setup lang="ts">
import { provide } from 'vue';
import { useClock } from './composables/useClock';
import { useCart } from './composables/useCart';
import { CART_KEY } from './keys';
import Catalog from './components/Catalog.vue';
import CartSummary from './components/CartSummary.vue';

const { now } = useClock();
provide(CART_KEY, useCart());
</script>

<template>
  <div class="container py-4" style="max-width: 720px">
    <h1 class="h3 mb-3">Example 11 - composables and provide / inject</h1>
    <p class="text-muted">Clock of App: {{ now.toLocaleTimeString() }}</p>
    <div class="row g-3">
      <div class="col-md-6"><Catalog /></div>
      <div class="col-md-6"><CartSummary /></div>
    </div>
  </div>
</template>
  • línea 19: App tiene su propio reloj, que se actualiza cada segundo;
  • línea 20: la aplicación pone un carrito de compras a disposición de TODOS sus descendientes, sin importar su profundidad, sin tener que pasarlo de props en props.

Dos descendientes lo inyectan:

<!--
  11-composables/src/components/Catalog.vue - un descendiente que INYECTA el carrito
-->
<script setup lang="ts">
import { inject } from 'vue';
import { CART_KEY } from '../keys';
import type { Item } from '../composables/useCart';

// el carrito proporcionado por App.vue (provide); error explícito si falta
const cart = inject(CART_KEY);
if (!cart) {
  throw new Error('Catalog must be placed under a component that provides the cart');
}

const catalog: Item[] = [
  { label: 'Consultation', price: 30 },
  { label: 'Vaccine', price: 12.5 },
  { label: 'Certificate', price: 5 },
];
</script>

<template>
  <ul class="list-group">
    <li v-for="a in catalog" :key="a.label" class="list-group-item d-flex justify-content-between align-items-center">
      {{ a.label }} (€{{ a.price }})
      <button class="btn btn-sm btn-outline-primary" @click="cart.add(a)">Add</button>
    </li>
  </ul>
</template>
  • línea 10: se recupera el carrito proporcionado por un ancestro; [inject] devuelve [undefined] si ningún ancestro lo ha proporcionado: esto se señala con un error explícito.
<!--
  11-composables/src/components/CartSummary.vue - another descendant, the SAME cart
-->
<script setup lang="ts">
import { inject } from 'vue';
import { CART_KEY } from '../keys';
import { useClock } from '../composables/useClock';

const cart = inject(CART_KEY)!;
// este componente tiene SU propio reloj, actualizado cada 5 segundos
const { now } = useClock(5000);
</script>

<!-- cart.items.value: en una plantilla, Vue solo "desenvuelve" (.value
     implícito) los refs de NIVEL SUPERIOR del script, como ahora.
     Los refs almacenados DENTRO de un objeto (cart.items) se escriben con .value -->
<template>
  <div class="card p-3">
    <h2 class="h6">Cart ({{ cart.items.value.length }} item(s)) - {{ now.toLocaleTimeString() }}</h2>
    <ul class="mb-2">
      <li v-for="(a, i) in cart.items.value" :key="i">
        {{ a.label }} <a href="#" @click.prevent="cart.remove(i)">remove</a>
      </li>
    </ul>
    <strong>Total: €{{ cart.total.value }}</strong>
  </div>
</template>
  • Línea 9: la misma inyección; [!] confirma a [TypeScript] que el valor existe;
  • línea 11: este componente tiene su PROPIO reloj, que se actualiza cada 5 segundos;
  • línea 19: en una plantilla, [Vue.js] “desempaqueta” automáticamente solo los elementos [ref] del nivel superior del script. Un [ref] almacenado DENTRO de un objeto ([cart.items]) se escribe con [.value].

Ambos componentes muestran el mismo carrito de compras; los dos relojes funcionan a su propio ritmo:

Image

3.6. Ejemplo 12: una ventana de confirmación reutilizable

Antes de eliminar un elemento, el sistema pregunta: “¿Está seguro?”. Existe la función del navegador [window.confirm()] , pero su cuadro de diálogo no se puede formatear, ni se pueden traducir sus botones. La reemplazamos por una ventana de [Bootstrap], controlada por un composable. Esta es la versión en [Vue.js] del Ejemplo 21 del curso [NestJS].

// =========================================================================
// 12-confirmation/src/composables/useConfirmation.ts
// -------------------------------------------------------------------------
// "Are you sure?": window.confirm() existe, pero no se puede
// darle estilo ni traducir sus botones. Lo reemplazamos por un cuadro de
// diálogo de Bootstrap (ConfirmDialog.vue), controlado por este composable.
//
// El truco: confirm(message) devuelve una PROMESA, resuelta a true (Sí)
// o false (No) cuando el usuario responde. El código que llama se escribe entonces
// tan simple como con window.confirm:
//
//     if (await confirm('Delete this doctor?')) { ... }
//
// El estado (mensaje mostrado, función a llamar con la respuesta) se declara
// FUERA de la función: por lo tanto es ÚNICO para toda la aplicación. Un
// solo cuadro de diálogo, colocado una vez en App.vue, sirve a todos los componentes.
// =========================================================================

import { readonly, ref } from 'vue';

const message = ref<string | null>(null); // null: cuadro de diálogo cerrado
let answer: ((yes: boolean) => void) | null = null;

export function useConfirmation() {
  function confirm(text: string): Promise<boolean> {
    message.value = text;
    return new Promise<boolean>((resolve) => {
      answer = resolve;
    });
  }

  function respond(yes: boolean): void {
    message.value = null;
    answer?.(yes);
    answer = null;
  }

  // readonly: los componentes leen el mensaje, solo el composable lo modifica
  return { message: readonly(message), confirm, respond };
}
  • Líneas 21 y 22: el estado se declara FUERA de la función [useConfirmation] , en el nivel del módulo. Por lo tanto, es único en toda la aplicación: una sola ventana sirve a todos los componentes;
  • Líneas 25–30: [confirm] abre la ventana (asignando un valor al mensaje) y devuelve una promesa. Almacena la función [resolve] de esta promesa en [answer]: la promesa no se resolverá hasta que el usuario haya respondido;
  • líneas 32–35: la respuesta del usuario cierra la ventana y resuelve la promesa con [true] o [false];
  • línea 39: los componentes pueden leer el mensaje, pero no modificarlo.

La ventana:

<!--
  =========================================================================
  12-confirmation/src/components/ConfirmDialog.vue
  -------------------------------------------------------------------------
  El diálogo modal, colocado UNA sola vez en App.vue.
    - <Teleport to="body">: su HTML se inserta al final de <body>, fuera del
      árbol de componentes - un diálogo modal debe ir
      por encima de todo, sin importar dónde se declare;
    - mismas clases de Bootstrap que un modal real (.modal, .modal-backdrop),
      mostradas "a la fuerza" (show d-block): no se necesita el JavaScript de Bootstrap;
    - teclado: Escape = No; el foco se coloca en el botón "No" (la
      opción menos peligrosa) al abrir.
  =========================================================================
-->
<script setup lang="ts">
import { nextTick, onUnmounted, useTemplateRef, watch } from 'vue';
import { useConfirmation } from '../composables/useConfirmation';

const { message, respond } = useConfirmation();
const noButton = useTemplateRef<HTMLButtonElement>('noButton');

function onKeydown(e: KeyboardEvent): void {
  if (e.key === 'Escape') {
    respond(false);
  }
}

// al abrir: foco en "No", escucha de la tecla Escape; al cerrar: dejamos de escuchar
watch(message, async (value) => {
  if (value !== null) {
    document.addEventListener('keydown', onKeydown);
    await nextTick();
    noButton.value?.focus();
  } else {
    document.removeEventListener('keydown', onKeydown);
  }
});
onUnmounted(() => document.removeEventListener('keydown', onKeydown));
</script>

<template>
  <Teleport to="body">
    <template v-if="message !== null">
      <div class="modal-backdrop fade show"></div>
      <div class="modal fade show d-block" tabindex="-1" role="alertdialog" aria-modal="true" @click.self="respond(false)">
        <div class="modal-dialog modal-dialog-centered">
          <div class="modal-content">
            <div class="modal-header">
              <h5 class="modal-title">Confirmation</h5>
              <button type="button" class="btn-close" aria-label="Close" @click="respond(false)"></button>
            </div>
            <div class="modal-body">
              <p class="mb-0">{{ message }}</p>
            </div>
            <div class="modal-footer">
              <button ref="noButton" type="button" class="btn btn-secondary" @click="respond(false)">No, go back</button>
              <button type="button" class="btn btn-danger" @click="respond(true)">Yes, confirm</button>
            </div>
          </div>
        </div>
      </div>
    </template>
  </Teleport>
</template>
  • línea 42: el HTML de la ventana se inserta al final de [<body>], fuera del árbol de componentes: una ventana modal debe tener prioridad sobre todo lo demás, sin importar dónde se declare;
  • línea 45: las clases de [Bootstrap] de una ventana modal, mostrada “de forma fija” ([show d-block]): no se necesita el [JavaScript] de [Bootstrap];
  • línea 45: el modificador [.self]: solo un clic en el propio elemento (el área sombreada), y no en la ventana que lo contiene, activa la respuesta “No”;
  • Líneas 29–37: al abrirse, el programa escucha la tecla Esc y da el foco al botón “No” (la opción más segura: una pulsación accidental de Enter no eliminará nada); al cerrarse, el programa deja de escuchar el teclado.

El componente que la usa:

<!--
  =========================================================================
  12-confirmation/src/App.vue - uso del diálogo de confirmación
  -------------------------------------------------------------------------
  Misma página que el ejemplo 21 del curso de NestJS (enlaces, botones, confirmación),
  pero sin ningún viaje de ida y vuelta a un servidor.
  =========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';
import ConfirmDialog from './components/ConfirmDialog.vue';
import { useConfirmation } from './composables/useConfirmation';

interface Contact {
  id: number;
  name: string;
}

const contacts = ref<Contact[]>([
  { id: 1, name: 'Jean MARTIN' },
  { id: 2, name: 'Alice DURAND' },
  { id: 3, name: 'Luc GERMAN' },
]);
const message = ref('');
const { confirm } = useConfirmation();

// una función async: "espera" la respuesta del usuario
async function remove(c: Contact): Promise<void> {
  if (!(await confirm(`Delete the contact ${c.name}?`))) {
    message.value = 'Deletion cancelled.';
    return;
  }
  contacts.value = contacts.value.filter((x) => x.id !== c.id);
  message.value = `${c.name} has been deleted.`;
}

async function removeAll(): Promise<void> {
  if (await confirm(`Delete the ${contacts.value.length} contacts?`)) {
    contacts.value = [];
    message.value = 'All the contacts have been deleted.';
  }
}
</script>

<template>
  <div class="container py-4" style="max-width: 640px">
    <h1 class="h3 mb-3">Example 12 - a confirmation dialog</h1>
    <ul class="list-group mb-3">
      <li v-for="c in contacts" :key="c.id" class="list-group-item d-flex justify-content-between align-items-center">
        {{ c.name }}
        <button class="btn btn-sm btn-outline-danger" @click="remove(c)">Delete</button>
      </li>
      <li v-if="contacts.length === 0" class="list-group-item text-muted">No contacts.</li>
    </ul>
    <button class="btn btn-danger" :disabled="contacts.length === 0" @click="removeAll">Delete all</button>
    <p v-if="message" class="alert alert-info mt-3">{{ message }}</p>
  </div>
  <!-- el cuadro de diálogo, UNA SOLA VEZ para toda la aplicación -->
  <ConfirmDialog />
</template>
  • línea 29: gracias a la promesa, el código es tan simple de escribir como con [window.confirm]: la función [async] “espera” la respuesta del usuario;
  • línea 59: la ventana, creada UNA SOLA VEZ para toda la aplicación.

Image

Después de “Sí, confirmar”:

Image