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:
| // 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.

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.

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”.

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.

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:

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.

Después de “Sí, confirmar”:
