Skip to content

3. Los componentes

3.1. Ejemplo 10: componentes y sus entradas

Un componente es una pieza reutilizable de la interfaz. Este ejemplo muestra perfiles de médicos: un componente llamado [DoctorCard] (el hijo), usado varias veces por el componente [App] (el padre).

Los archivos de un componente suelen almacenarse en una carpeta con el nombre del componente:

1
2
3
4
5
6
7
8
10-components/src/app/
├── doctor-card/
│   ├── doctor-card.ts     the class of the component
│   ├── doctor-card.html   its template
│   └── doctor-card.css    its style
├── doctor.ts             the Doctor type
├── app.ts
└── app.html

El tipo de datos compartido por el padre y el hijo:

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

3.1.1. El hijo

// =========================================================================
// 10-components/src/app/doctor-card/doctor-card.ts - un componente HIJO
// -------------------------------------------------------------------------
// Recibe sus datos de su padre mediante INPUTS, declarados
// con input(): cada input es un SIGNAL de solo lectura, que sigue el
// valor pasado por el padre. Su tipo se verifica en tiempo de compilación:
// <app-doctor-card [doctor]="42"> sería rechazado.
//
// Regla de oro: un componente NUNCA MODIFICA sus inputs. Los datos
// bajan del padre al hijo; para solicitar un cambio,
// el hijo emite un evento (ver ejemplo 11).
// =========================================================================

import { booleanAttribute, Component, computed, input } from '@angular/core';
import { Doctor } from '../doctor';

@Component({
  // el selector: la etiqueta que representa este componente en su padre
  selector: 'app-doctor-card',
  templateUrl: './doctor-card.html',
  styleUrl: './doctor-card.css',
})
export class DoctorCard {
  // input.required: el padre DEBE proporcionar este input
  readonly doctor = input.required<Doctor>();
  readonly rank = input.required<number>();
  // input(valor por defecto): un input opcional. booleanAttribute
  // permite escribir simplemente <app-doctor-card compact> para true
  readonly compact = input(false, { transform: booleanAttribute });

  // un computed basado en un input: se recalcula si el padre lo cambia
  protected readonly initials = computed(() => `${this.doctor().firstName[0]}${this.doctor().lastName[0]}`);
}
  • línea 19: el selector: el padre escribirá [<app-doctor-card>];
  • líneas 25–29: las entradas del componente ([inputs]), los datos que le pasa su padre. [input()] crea una señal de solo lectura que sigue el valor pasado por el padre:
    • líneas 25–26: [input.required<T>()]: una entrada obligatoria. Omitir [[doctor]] en la plantilla del padre produce un error de compilación;
    • Línea 29: [input(default value)]: una entrada opcional. La opción [transform] convierte el valor recibido: [booleanAttribute] convierte la presencia del atributo ([<app-doctor-card compact>], sin valor) en [true], como con el atributo HTML [disabled];
  • línea 32: un [computed] basado en una entrada: se recalcula si el padre cambia la entrada.

Las entradas no son [protected]: forman parte de la interfaz pública del componente, la que utiliza su padre.

Regla de oro: un componente nunca modifica sus entradas (que, de todos modos, son de solo lectura). Los datos fluyen del padre al hijo; para solicitar un cambio, el hijo emite un evento (ejemplo 11).

<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>
      <!-- los inputs son signals: se leen llamándolos -->
      <h2 class="h6 mb-1">{{ rank() }}. {{ doctor().title }} {{ doctor().firstName }} {{ doctor().lastName }}</h2>
      @if (!compact()) {
        <p class="mb-0 text-muted small">{{ doctor().specialty }}</p>
      }
    </div>
  </div>
</div>
  • líneas 1, 6, 8: las entradas son señales: se leen llamándolas;
  • líneas 7–9: la especialidad solo se muestra en la versión normal de la tarjeta.
/* el estilo del componente: solo se aplica a SUS elementos */
.initials {
  width: 2.5rem;
  height: 2.5rem;
  border-radius: 50%;
  display: flex;
  align-items: center;
  justify-content: center;
  background: #dd0031;
  color: white;
  font-weight: bold;
}

La clase [initials] se aplica solo a este componente: otro componente podría tener su propia clase [initials], sin ningún conflicto.

3.1.2. El padre

// =========================================================================
// 10-components/src/app/app.ts - el componente PADRE
// -------------------------------------------------------------------------
// Importa el componente DoctorCard (arreglo imports) y lo usa como
// una nueva etiqueta HTML, <app-doctor-card>, tantas veces como
// sea necesario: un componente es una pieza de interfaz REUTILIZABLE, con
// sus propios datos, su plantilla y su estilo.
// =========================================================================

import { Component, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { DoctorCard } from './doctor-card/doctor-card';
import { Doctor } from './doctor';

@Component({
  selector: 'app-root',
  imports: [FormsModule, DoctorCard],
  templateUrl: './app.html',
})
export class App {
  protected readonly doctors = signal<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 },
  ]);
  protected readonly compact = signal(false);

  // el padre modifica SUS datos: los hijos afectados se actualizan
  protected toggleAvailability(): void {
    this.doctors.update((list) => list.map((m) => ({ ...m, available: !m.available })));
  }
}
  • línea 17: el padre importa el componente hijo; sin esto, [<app-doctor-card>] sería una etiqueta desconocida y la compilación fallaría;
  • líneas 29–31: el padre modifica SUS datos. Reemplaza cada médico por una copia modificada: el objeto [m] pasado a cada tarjeta cambia y las tarjetas se actualizan.
<div class="container py-4">
  <h1 class="h3 mb-3">Example 10 - components and their inputs</h1>
  <div class="d-flex gap-3 mb-3">
    <label class="form-check-label">
      <input type="checkbox" class="form-check-input" [(ngModel)]="compact"> compact display
    </label>
    <button class="btn btn-sm btn-outline-primary" (click)="toggleAvailability()">Toggle availability</button>
  </div>
  <div class="row g-3">
    @for (m of doctors(); track m.id; let i = $index) {
      <div class="col-md-4">
        <!-- [doctor]="m" pasa el OBJETO m (una expresión);
             doctor="m", sin corchetes, pasaría la CADENA "m" -->
        <app-doctor-card [doctor]="m" [rank]="i + 1" [compact]="compact()" />
      </div>
    }
  </div>
  <p class="mt-3 mb-1 small text-muted">The same card, in compact version, through an attribute without a value:</p>
  <div class="w-50">
    <app-doctor-card [doctor]="doctors()[0]" [rank]="1" compact />
  </div>
</div>
  • línea 14: el hijo se usa como una etiqueta HTML. [[doctor]="m"] es un enlace de propiedad a la entrada [doctor]: transmite el OBJETO [m]. Sin corchetes, [doctor="m"] pasaría la CADENA ["m"], que el compilador rechazaría. Un componente sin contenido puede escribirse con una etiqueta autocerrada ([/>]);
  • línea 20: [compact], sin valor: gracias a [booleanAttribute], la entrada recibe [true].

[npm start 10-components]; haga clic en “Toggle availability”:

Image

3.2. Ejemplo 11: salidas de un componente y model()

Un hijo tiene dos maneras de enviar información de vuelta a su padre:

  1. emitir un evento (una salida, [output]), que el padre escucha como un evento HTML; 2. una conexión bidireccional, [[( )]], sobre un [model()].

3.2.1. Emisión de un evento

Un contador que notifica a su padre con cada clic y cuando alcanza su límite:

// =========================================================================
// 11-outputs-model/src/app/counter/counter.ts
// -------------------------------------------------------------------------
// Un hijo que NOTIFICA a su padre: output() declara un evento que el
// componente puede emitir, con el tipo de sus datos. El padre lo escucha
// como un evento HTML: <app-counter (incremented)="..." (limit)="...">.
// =========================================================================

import { Component, input, output, signal } from '@angular/core';

@Component({
  selector: 'app-counter',
  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>
  `,
})
export class Counter {
  readonly label = input.required<string>();
  readonly max = input.required<number>();

  // dos eventos: incremented (con el nuevo valor) y limit (sin datos)
  readonly incremented = output<number>();
  readonly limit = output<void>();

  protected readonly value = signal(0);

  protected plus(): void {
    if (this.value() >= this.max()) {
      this.limit.emit();
      return;
    }
    this.value.update((v) => v + 1);
    this.incremented.emit(this.value());
  }
}
  • líneas 13–19: la plantilla del componente, escrita en el decorador (propiedad [template], entre acentos graves);
  • líneas 26–27: [output<T>()] declara una salida: un evento que el componente puede emitir, junto con el tipo de sus datos. [limit] no tiene datos ([void]);
  • líneas 33 y 37: [emit(data)] emite el evento; el padre recibe los datos.

Evite nombrar una salida con el nombre de un evento del navegador ([change], [click]...): los eventos del navegador emitidos por los elementos del componente se propagan hasta su elemento anfitrión, y el padre también los recibiría.

3.2.2. Un enlace bidireccional

Un campo de formulario "personalizado" (etiqueta, campo, información sobre herramientas, contador de caracteres) que se vincula con datos del padre como [ngModel]:

// =========================================================================
// 11-outputs-model/src/app/text-field/text-field.ts
// -------------------------------------------------------------------------
// Un campo de formulario "casero" (etiqueta + campo + ayuda + contador de
// caracteres) que acepta un enlace BIDIRECCIONAL, como ngModel:
//     <app-text-field [(value)]="lastName" label="Last name" [max]="20" />
//
// model() crea un signal MODIFICABLE enlazado con el padre: LEERLO da el
// valor del padre, ESCRIBIRLO (set) emite el evento valueChange, que la
// sintaxis [( )] convierte en una actualización del signal del padre. Los datos
// siguen siendo así realmente propiedad del padre.
// =========================================================================

import { Component, input, model } from '@angular/core';

// un contador compartido por todas las instancias: un identificador único por
// campo, para enlazar <label for> y <input id>
let nextNumber = 0;

@Component({
  selector: 'app-text-field',
  template: `
    <div class="mb-3">
      <label class="form-label" [for]="id">{{ label() }}</label>
      <!-- [value]: el valor del padre; (input): cada pulsación de tecla lo reemplaza -->
      <input class="form-control" [id]="id" [value]="value()" [attr.maxlength]="max()"
             [class.is-invalid]="value().length === max()" (input)="onInput($event)">
      <div class="form-text">{{ help() }} ({{ value().length }} / {{ max() }})</div>
    </div>
  `,
})
export class TextField {
  readonly value = model.required<string>();
  readonly label = input.required<string>();
  readonly max = input.required<number>();
  readonly help = input('');

  protected readonly id = `text-field-${++nextNumber}`;

  protected onInput(event: Event): void {
    this.value.set((event.target as HTMLInputElement).value);
  }
}
  • Línea 33: [model()] crea una señal modificable vinculada al padre. LEERLA devuelve el valor del padre; ESCRIBIR en ella ([set], línea 41) cambia el valor Y emite el evento [valueChange] (el nombre del modelo seguido de [Change]). Así, el padre que escribe [[(value)]="signal"] ve actualizada su señal;
  • línea 18: una variable de módulo (fuera de la clase) es compartida por todas las instancias del componente: un contador que asigna un identificador único a cada campo (línea 38), para vincular [<label for>] y [<input id>];
  • líneas 26–27: [[value]] muestra el valor del padre; [(input)] lo reemplaza con cada pulsación de tecla (línea 41). [[attr.maxlength]] es un enlace de atributo a HTML (el atributo [maxlength]), no un enlace de propiedad.

3.2.3. El padre

// =========================================================================
// 11-outputs-model/src/app/app.ts - el padre escucha a sus hijos
// -------------------------------------------------------------------------
// Dos maneras de que un hijo pase información hacia arriba:
//   1. emitir un evento (output), que el padre escucha con ( );
//   2. un enlace bidireccional [( )] sobre un model(): un atajo
//      para el input [value] + el evento (valueChange).
// =========================================================================

import { Component, computed, signal } from '@angular/core';
import { Counter } from './counter/counter';
import { TextField } from './text-field/text-field';

@Component({
  selector: 'app-root',
  imports: [Counter, TextField],
  templateUrl: './app.html',
})
export class App {
  protected readonly total = signal(0);
  protected readonly message = signal('');
  protected readonly firstName = signal('Marie');
  protected readonly lastName = signal('PELISSIER');
  protected readonly fullName = computed(() => `${this.firstName()} ${this.lastName().toUpperCase()}`);

  // el manejador del evento incremented: recibe los datos emitidos ($event)
  protected onChange(label: string, value: number): void {
    this.total.update((t) => t + 1);
    this.message.set(`${label} is now ${value}`);
  }

  protected clear(): void {
    this.firstName.set('');
    this.lastName.set('');
  }
}
<div class="container py-4" style="max-width: 640px">
  <h1 class="h3 mb-3">Example 11 - the outputs of a component and model()</h1>

  <div class="card p-3 mb-4">
    <h2 class="h6">1. Events emitted by the children</h2>
    <!-- $event: los datos emitidos por el hijo (aquí, el nuevo valor) -->
    <app-counter label="Coffees" [max]="3" (incremented)="onChange('Coffees', $event)"
                  (limit)="message.set('No more than 3 coffees!')" />
    <app-counter label="Glasses of water" [max]="8" (incremented)="onChange('Glasses of water', $event)"
                  (limit)="message.set('Enough drinking.')" />
    <p class="mb-0">Total clicks: {{ total() }} - <em>{{ message() }}</em></p>
  </div>

  <div class="card p-3">
    <h2 class="h6">2. A two-way binding with model()</h2>
    <!-- [(value)]="firstName": el signal firstName del padre, leído Y modificado por el hijo -->
    <app-text-field [(value)]="firstName" label="First name" [max]="20" help="Required" />
    <app-text-field [(value)]="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)="clear()">Clear (from the parent)</button>
  </div>
</div>
  • Línea 7: [(incremented)="..."] escucha la salida [incremented] del contador; [$event] son los datos de la salida (el nuevo valor). [label="Coffees"], sin corchetes: una entrada de tipo cadena puede recibir un valor constante;
  • línea 8: [(limit)]: un método de una señal ([set]) se puede llamar directamente dentro de la plantilla;
  • línea 9: un segundo contador, con su propia etiqueta, límite y mensajes;
  • línea 17: [[(value)]="firstName"]: la señal [firstName] del padre (sin paréntesis: se indica la señal misma), leída Y modificada por el hijo. Es la abreviatura de [[value]="firstName()" (valueChange)="firstName.set($event)"];
  • línea 20: el padre modifica sus datos: los dos campos lo siguen.

[npm start 11-outputs-model]; cuatro clics en los cafés, uno en el agua y luego escriba un nombre:

Image

3.3. Ejemplo 12: proyección de contenido

Las entradas transmiten datos; la proyección de contenido transmite contenido (HTML y otros componentes), escrito por el padre ENTRE las etiquetas del componente. Es el equivalente en el cliente de la plantilla [layout.hbs] del curso [NestJS] y de su [{{{body}}}].

3.3.1. Una tarjeta

Un marco reutilizable (borde, encabezado, pie), cuyo contenido proporciona el padre:

// =========================================================================
// 12-projection/src/app/card/card.ts - una PLANTILLA reutilizable
// -------------------------------------------------------------------------
// Los inputs pasan DATOS; la PROYECCIÓN de contenido pasa
// CONTENIDO (HTML, otros componentes), escrito por el padre ENTRE las
// etiquetas <app-card> y </app-card>. La tarjeta define el marco (borde,
// encabezado, pie), el padre proporciona lo que va dentro:
//   - <ng-content />                   : el contenido "principal";
//   - <ng-content select="[header]" /> : solo los elementos que tienen
//                                        el atributo header;
//   - el contenido colocado ENTRE <ng-content> y </ng-content> se muestra si
//     el padre no proporciona nada (contenido por defecto).
// Es el equivalente del lado cliente de la plantilla layout.hbs y su {{{body}}}
// en el curso de NestJS.
// =========================================================================

import { Component, input } from '@angular/core';

@Component({
  selector: 'app-card',
  template: `
    <div class="card mb-3" [class]="color() ? 'border-' + color() : ''">
      <div class="card-header" [class]="color() ? 'text-bg-' + color() : ''">
        <ng-content select="[header]">Untitled</ng-content>
      </div>
      <div class="card-body">
        <ng-content />
      </div>
      <!-- un pie vacío (el padre no proporcionó nada) se oculta mediante el CSS :empty -->
      <div class="card-footer text-muted small"><ng-content select="[footer]" /></div>
    </div>
  `,
  styles: `
    .card-footer:empty {
      display: none;
    }
  `,
})
export class Card {
  readonly color = input<'primary' | 'success' | 'danger'>();
}
  • línea 27: [<ng-content />]: el lugar donde [Angular] coloca el contenido escrito por el padre entre [<app-card>] y [</app-card>];
  • línea 24: [<ng-content select="[header]">]: solo los elementos de contenido que tienen el atributo [header]. [select] acepta un selector CSS (una etiqueta, una clase o un atributo). El texto entre [<ng-content>] y [</ng-content>] se muestra si el elemento padre no proporciona ningún contenido: este es el contenido predeterminado;
  • línea 30: el pie: los elementos que tienen el atributo [footer];
  • líneas 33–37: un pie vacío (el elemento padre no proporcionó nada) se oculta: la pseudoclase CSS [:empty] designa un elemento sin contenido;
  • Línea 40: una entrada opcional que solo puede tomar tres valores; si no se especifica un valor predeterminado, es [undefined] de forma predeterminada.

3.3.2. Una tabla genérica

Una tabla que sabe recorrer las filas pero no sabe cómo mostrar UNA fila: su padre se lo indica pasándole una plantilla de fila.

// =========================================================================
// 12-projection/src/app/data-table/data-table.ts - una tabla GENÉRICA
// -------------------------------------------------------------------------
// DataTable<T> es una clase genérica: muestra filas de cualquier
// tipo T. Sabe recorrer las filas, pero no cómo mostrar UNA
// fila: se lo indica el padre, pasándole una PLANTILLA de fila
// (un <ng-template #row>, un fragmento de HTML que no se muestra
// tal cual, pero que puede mostrarse a demanda, tantas veces como sea necesario).
//
// contentChild('row'): el <ng-template #row> colocado por el padre entre
// <app-data-table> y </app-data-table>. La tabla lo muestra para cada fila
// con ngTemplateOutlet, pasándole un CONTEXTO: la fila ($implicit)
// y su posición (index). El contenido proporcionado por el padre usa así
// datos que pertenecen al hijo.
// =========================================================================

import { Component, contentChild, input, TemplateRef } from '@angular/core';
import { NgTemplateOutlet } from '@angular/common';

// lo que la tabla pasa a la plantilla de cada fila
export interface RowContext<T> {
  $implicit: T; // el valor recuperado por let-row
  index: number; // recuperado por let-i="index"
}

@Component({
  selector: 'app-data-table',
  imports: [NgTemplateOutlet],
  template: `
    <table class="table table-sm align-middle mb-0">
      <thead>
        <tr>
          @for (c of columns(); track c) {
            <th>{{ c }}</th>
          }
        </tr>
      </thead>
      <tbody>
        @for (l of rows(); track l.id; let i = $index) {
          <tr>
            <ng-container [ngTemplateOutlet]="rowTemplate() ?? null" [ngTemplateOutletContext]="{ $implicit: l, index: i }" />
          </tr>
        } @empty {
          <tr>
            <td class="text-muted" [attr.colspan]="columns().length">
              <ng-content select="[empty]">No data.</ng-content>
            </td>
          </tr>
        }
      </tbody>
    </table>
  `,
})
export class DataTable<T extends { id: number }> {
  readonly rows = input.required<T[]>();
  readonly columns = input.required<string[]>();
  protected readonly rowTemplate = contentChild<TemplateRef<RowContext<T>>>('row');
}
  • línea 54: [DataTable<T>] es una clase genérica: muestra filas de cualquier tipo [T], siempre que tengan un [id] (para [track], línea 39);
  • Línea 57: [contentChild('row')]: una señal que hace referencia al elemento del contenido proyectado marcado con [#row]. Será un [<ng-template>]: una porción de HTML que no se muestra tal cual, pero que puede mostrarse a demanda, tantas veces como sea necesario (un [TemplateRef]);
  • línea 41: la directiva [ngTemplateOutlet] muestra una plantilla pasándole un contexto: un objeto cuyas propiedades se convierten en variables de la plantilla. [$implicit] es el valor predeterminado (líneas 21–24);
  • líneas 43–49: si la lista está vacía, el bloque [@empty], con contenido proyectado ([[empty]]) y contenido predeterminado;
  • línea 45: [[attr.colspan]]: un enlace de atributo, ya que [colspan] no es una propiedad del elemento [<td>].

3.3.3. El padre

// =========================================================================
// 12-projection/src/app/app.ts - uso de las plantillas Card y DataTable
// =========================================================================

import { Component, computed, signal } from '@angular/core';
import { Card } from './card/card';
import { DataTable } from './data-table/data-table';

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

@Component({
  selector: 'app-root',
  imports: [Card, DataTable],
  templateUrl: './app.html',
})
export class App {
  protected readonly slots = signal<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 },
  ]);
  protected readonly free = computed(() => this.slots().filter((c) => c.patient === null).length);
  protected readonly nobody: { id: number; name: string }[] = [];
}
<div class="container py-4" style="max-width: 720px">
  <h1 class="h3 mb-3">Example 12 - content projection</h1>

  <app-card color="primary">
    <!-- el atributo header: este <span> irá al <ng-content select="[header]"> -->
    <span header>Schedule of Mme PELISSIER</span>
    <!-- todo lo que no tiene ni header ni footer va al <ng-content /> principal -->
    <app-data-table [rows]="slots()" [columns]="['#', 'Slot', 'Status']">
      <!-- la plantilla de una fila: let-c recibe la fila, let-i su posición -->
      <ng-template #row let-c let-i="index">
        <td>{{ i + 1 }}</td>
        <td>{{ c.time }}</td>
        <td>
          @if (c.patient) {
            <span class="badge text-bg-secondary">{{ c.patient }}</span>
          } @else {
            <span class="badge text-bg-success">Free</span>
          }
        </td>
      </ng-template>
    </app-data-table>
    <span footer>{{ free() }} free slot(s)</span>
  </app-card>

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

  <app-card>
    <!-- sin header: el contenido por defecto, "Untitled" -->
    <app-data-table [rows]="nobody" [columns]="['Name']">
      <span empty>Nobody for now.</span>
    </app-data-table>
  </app-card>
</div>
  • líneas 4–23: una tarjeta azul. Su contenido lo distribuye la tarjeta: [<span header>] (línea 6) va en el encabezado, [<span footer>] (línea 22) en el pie, y el resto (la tabla) en el cuerpo;
  • líneas 10–20: la plantilla de una línea. [let-c] recupera el valor [$implicit] del contexto (la línea), y [let-i="index"] recupera su propiedad [index]. El contenido proporcionado por el padre utiliza así datos que pertenecen al hijo;
  • líneas 25–28: una tarjeta sin pie de página;
  • líneas 30–35: una tarjeta sin encabezado (el contenido predeterminado, “Untitled”), y una tabla vacía.

[npm start 12-projection]:

Image

El compilador no reconoce el tipo de [c] en la plantilla (líneas 10–20): lo trata como [any]. Esto se puede remediar (con una directiva que declare el tipo del contexto), a costa de un poco más de código; esta es la limitación de esta técnica.

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

Un componente se crea, se muestra, existe y luego desaparece. [Angular] permite actuar en cada etapa: este es el ciclo de vida del componente.

3.4.1. Un reloj

Un reloj inicia un temporizador cuando se crea... y debe detenerlo cuando desaparece: de lo contrario, el temporizador seguiría ejecutándose sin motivo (fuga de memoria).

// =========================================================================
// 13-lifecycle/src/app/clock/clock.ts
// -------------------------------------------------------------------------
// El ciclo de vida de un componente:
//   1. constructor      : se crea la clase; los inputs aún no
//                         están disponibles;
//   2. ngOnInit         : los inputs han recibido su primer valor;
//   3. afterNextRender  : el componente se MUESTRA, sus elementos HTML
//                         existen en la página;
//   4. ngOnDestroy      : el componente está a punto de ser ELIMINADO de la página.
// Un reloj inicia un temporizador (setInterval) al arrancar... y debe
// detenerlo absolutamente cuando desaparece: de lo contrario, el temporizador
// seguiría ejecutándose en vano (fuga de memoria).
// =========================================================================

import { afterNextRender, Component, OnDestroy, OnInit, output, signal } from '@angular/core';

@Component({
  selector: 'app-clock',
  template: `<div class="display-6 font-monospace">{{ time() }}</div>`,
})
// implements OnInit, OnDestroy: TypeScript verifica que los métodos existan
export class Clock implements OnInit, OnDestroy {
  readonly log = output<string>();
  protected readonly time = signal(new Date().toLocaleTimeString());
  private timer: number | undefined;

  constructor() {
    console.log('Clock: constructor'); // el padre aún no escucha log
    // afterNextRender se registra en el constructor; la función se
    // llama una vez, justo después de la primera visualización del componente
    afterNextRender(() => this.log.emit('Clock: afterNextRender - displayed'));
  }

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

  ngOnDestroy(): void {
    window.clearInterval(this.timer);
    this.log.emit('Clock: ngOnDestroy - timer stopped');
  }
}

Las etapas:

  • líneas 28–33: el constructor: se crea la clase. A las entradas aún no se les han asignado valores, y el padre todavía no escucha las salidas (de ahí el [console.log] de la línea 29, en lugar de un [emit]);
  • líneas 35–38: [ngOnInit()]: las entradas han recibido sus primeros valores. Este es el lugar habitual para iniciar acciones que dependen de ellas: una carga, un temporizador;
  • línea 32: [afterNextRender(function)], llamada en el constructor, registra una función que se ejecuta una sola vez, inmediatamente después de que el componente se muestre por primera vez: sus elementos HTML ya existen en la página;
  • Líneas 40–43: [ngOnDestroy()]: el componente está a punto de ser eliminado de la página. Se detiene el temporizador.

[implements OnInit, OnDestroy] (línea 23) no es obligatorio: [Angular] llama a [ngOnInit] si existe. Pero [TypeScript] verifica entonces que los métodos estén escritos correctamente.

[Angular] ofrece etapas adicionales, que son menos útiles desde la introducción de los signals: [ngOnChanges] (una entrada ha cambiado; para eso preferimos un [computed] o un [effect] sobre esa entrada), [ngAfterViewInit]... Y una alternativa a [ngOnDestroy]: [inject(DestroyRef).onDestroy(function)], que utilizará el ejemplo 14.

3.4.2. El padre

// =========================================================================
// 13-lifecycle/src/app/app.ts
// -------------------------------------------------------------------------
//   - @if alrededor de <app-clock>: marcar / desmarcar la casilla crea / destruye
//     el componente (ngOnInit / ngOnDestroy, ver clock.ts);
//   - viewChild('field'): un signal que da el elemento HTML marcado con #field
//     en la plantilla (undefined mientras no se muestre);
//   - effect: se ejecuta una primera vez y luego en cada cambio de los
//     signals que lee. Aquí, para dar el foco al campo apenas
//     aparece, y para que el título de la pestaña siga lo que se escribe.
// =========================================================================

import { Component, effect, ElementRef, OnInit, signal, viewChild } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { Clock } from './clock/clock';

@Component({
  selector: 'app-root',
  imports: [FormsModule, Clock],
  templateUrl: './app.html',
})
export class App implements OnInit {
  protected readonly withClock = signal(true);
  protected readonly log = signal<string[]>([]);
  protected readonly search = signal('');
  protected readonly showSearch = signal(false);

  // el elemento <input #field> de la plantilla; ElementRef.nativeElement: el elemento HTML
  private readonly field = viewChild<ElementRef<HTMLInputElement>>('field');

  constructor() {
    // el campo aparece (cambia viewChild): le damos el foco
    effect(() => this.field()?.nativeElement.focus());
    // el título de la pestaña sigue lo que se escribe, desde el inicio
    effect(() => {
      const text = this.search();
      document.title = text ? `Search: ${text}` : 'Example 13';
    });
  }

  ngOnInit(): void {
    this.trace('App: ngOnInit');
  }

  protected trace(message: string): void {
    this.log.update((j) => [...j, `${new Date().toLocaleTimeString()} ${message}`]);
  }
}
  • línea 29: [viewChild('field')]: un signal que hace referencia al elemento de la plantilla marcado con [#field]. Vale [undefined] mientras el elemento no exista (el campo aparece solo después de un clic). [ElementRef] envuelve el elemento HTML, al que se accede mediante su propiedad [nativeElement];
  • línea 33: un [effect] que lee este signal: cuando el campo aparece, el efecto se activa de nuevo y le da el foco. No hace falta “esperar” a que la página se actualice: el signal solo cambia una vez que se ha creado el elemento;
  • líneas 35–38: un segundo efecto: el título de la pestaña se actualiza a medida que se introduce el texto, desde el principio (un efecto siempre se ejecuta una vez al inicio);
  • líneas 41–43: el elemento padre también tiene su propio [ngOnInit].
<div class="container py-4" style="max-width: 720px">
  <h1 class="h3 mb-3">Example 13 - the lifecycle of a component</h1>

  <div class="card p-3 mb-3">
    <label class="form-check-label mb-2">
      <input type="checkbox" class="form-check-input" [(ngModel)]="withClock"> show the clock
    </label>
    @if (withClock()) {
      <app-clock (log)="trace($event)" />
    }
  </div>

  <div class="card p-3 mb-3">
    @if (!showSearch()) {
      <button class="btn btn-outline-primary align-self-start" (click)="showSearch.set(true)">Search...</button>
    } @else {
      <!-- #field: el elemento designado por viewChild('field') -->
      <input #field class="form-control" placeholder="the tab title follows what you type" [(ngModel)]="search">
    }
  </div>

  <h2 class="h6">Log</h2>
  <ol class="small">
    @for (line of log(); track $index) {
      <li>{{ line }}</li>
    }
  </ol>
</div>
  • líneas 8–10: marcar o desmarcar la casilla crea o destruye el reloj: [@if] agrega o quita realmente el componente de la página;
  • línea 18: [#field], el elemento al que hace referencia [viewChild('field')].

[npm start 13-lifecycle]; desmarque y luego vuelva a marcar la casilla, y haga clic en “Search...”:

Image

El registro muestra el orden de las etapas: primero el padre ([App: ngOnInit]), luego el reloj ([ngOnInit], [afterNextRender]), su destrucción ([ngOnDestroy]) y un nuevo reloj. El campo de búsqueda tiene el foco.

3.5. Ejemplo 14: servicios e inyección de dependencias

Un servicio es una clase que agrupa datos y código compartidos por varios componentes: el acceso al servidor, el usuario conectado, un carrito de compras, etc. Los componentes no crean servicios (nunca [new CartService()]): los solicitan a [Angular], mediante la función [inject()]. Esto es la inyección de dependencias, el mecanismo que el curso de [NestJS] presentó del lado del servidor.

Cuando un componente solicita un servicio, [Angular] busca quién lo proporciona: el propio componente, luego su padre, el padre de su padre... hasta llegar a la aplicación. Según dónde se proporcione, un servicio se comparte en mayor o menor medida. Este ejemplo muestra tres niveles.

3.5.1. Un servicio raíz

import { Injectable, signal } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class LogService {
  private readonly _lines = signal<string[]>([]);
  // asReadonly(): los componentes LEEN las líneas; solo el servicio las modifica
  readonly lines = this._lines.asReadonly();

  trace(message: string): void {
    this._lines.update((l) => [`${new Date().toLocaleTimeString()} ${message}`, ...l].slice(0, 6));
  }
}
  • línea 14: [@Injectable({ providedIn: 'root' })]: el servicio se proporciona en la raíz de la aplicación. [Angular] crea una única instancia la primera vez que se solicita, y todos los que la solicitan reciben esa instancia;
  • Líneas 16–18: los datos de las líneas son privados; [asReadonly()] proporciona una versión pública de solo lectura. Los componentes leen las líneas; solo el servicio las modifica (línea 21). Esta es la organización habitual de un servicio que mantiene un estado.

3.5.2. Un servicio proporcionado por un componente

import { computed, inject, Injectable, signal } from '@angular/core';
import { LogService } from './log.service';

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

@Injectable()
export class CartService {
  // un servicio puede solicitar a su vez otros servicios
  private readonly log = inject(LogService);

  private readonly _items = signal<Item[]>([]);
  readonly items = this._items.asReadonly();
  readonly total = computed(() => this._items().reduce((sum, a) => sum + a.price, 0));

  add(item: Item): void {
    this._items.update((a) => [...a, item]);
    this.log.trace(`cart: + ${item.label}`);
  }

  remove(index: number): void {
    this.log.trace(`cart: - ${this._items()[index].label}`);
    this._items.update((a) => a.filter((_, i) => i !== index));
  }
}
  • línea 19: [@Injectable()] SIN [providedIn]: el servicio no se proporciona por defecto en ningún lugar. Un componente lo proporcionará en su arreglo [providers];
  • línea 22: un servicio puede solicitar a su vez otros servicios: se registra el carrito de compras en el log;
  • líneas 24–26: el estado del carrito de compras (privado), su versión de solo lectura y su total;
  • líneas 28–36: las dos acciones que modifican el estado.

3.5.3. Un servicio configurado

import { DestroyRef, inject, Injectable, InjectionToken, signal } from '@angular/core';

// factory: el valor usado si nadie proporciona este token
export const CLOCK_PERIOD = new InjectionToken<number>('period of the clock', { factory: () => 1000 });

@Injectable()
export class ClockService {
  private readonly period = inject(CLOCK_PERIOD);
  readonly now = signal(new Date());

  constructor() {
    const timer = window.setInterval(() => this.now.set(new Date()), this.period);
    inject(DestroyRef).onDestroy(() => window.clearInterval(timer));
  }
}
  • línea 15: un token de inyección ([InjectionToken]) designa un valor que no es una clase: en este caso, un número, el período del reloj. [factory] proporciona el valor que se usa si nadie suministra este token;
  • línea 19: el valor del token se solicita del mismo modo que se solicita un servicio;
  • línea 24: [DestroyRef] representa la “vida útil” del componente que proporcionó el servicio; [onDestroy] registra una función que se ejecutará cuando este se destruya: el temporizador se detiene junto con el componente que proporcionó el reloj.

[inject()] solo se llama en un contexto de inyección: al inicializar las propiedades de una clase creada por [Angular] (componente, servicio, directiva, pipe), o en su constructor. No se puede llamar más tarde, dentro de un método ordinario.

3.5.4. Componentes

Un catálogo que agrega artículos al carrito de compras:

// 14-services/src/app/catalog/catalog.ts - un descendiente que INYECTA el carrito
import { Component, inject } from '@angular/core';
import { Item, CartService } from '../services/cart.service';

@Component({
  selector: 'app-catalog',
  template: `
    <ul class="list-group">
      @for (a of catalog; track a.label) {
        <li 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>
  `,
})
export class Catalog {
  // el carrito proporcionado por App (error en tiempo de ejecución si nadie lo proporciona)
  protected readonly cart = inject(CartService);

  protected readonly catalog: Item[] = [
    { label: 'Consultation', price: 30 },
    { label: 'Vaccine', price: 12.5 },
    { label: 'Certificate', price: 5 },
  ];
}
  • línea 20: [inject(CartService)]: el carrito de compras proporcionado por un padre ([App]). Si nadie lo hubiera proporcionado, [Angular] informaría de un error en tiempo de ejecución;
  • Línea 12: la plantilla llama directamente a un método del servicio.

Un resumen del carrito de compras:

import { Component, inject } from '@angular/core';
import { DatePipe } from '@angular/common';
import { CartService } from '../services/cart.service';
import { ClockService, CLOCK_PERIOD } from '../services/clock.service';

@Component({
  selector: 'app-cart-summary',
  imports: [DatePipe],
  // una nueva instancia de ClockService para ESTE componente, con otro
  // período: { provide: token, useValue: value }
  providers: [ClockService, { provide: CLOCK_PERIOD, useValue: 5000 }],
  template: `
    <div class="card p-3">
      <h2 class="h6">Cart ({{ cart.items().length }} item(s)) - {{ clock.now() | date: 'HH:mm:ss' }}</h2>
      <ul class="mb-2">
        @for (a of cart.items(); track $index) {
          <li>{{ a.label }} <a href="#" (click)="$event.preventDefault(); cart.remove($index)">remove</a></li>
        }
      </ul>
      <strong>Total: €{{ cart.total() }}</strong>
    </div>
  `,
})
export class CartSummary {
  protected readonly cart = inject(CartService);
  protected readonly clock = inject(ClockService);
}
  • línea 18: el componente proporciona su propio reloj (una nueva instancia de [ClockService]) y otro período de tiempo: [{ provide: token, useValue: value }];
  • Líneas 32–33: el carrito de compras es el de [App] (el mismo que el del catálogo); el reloj es propio.

Y el componente raíz:

import { Component, inject } from '@angular/core';
import { DatePipe } from '@angular/common';
import { Catalog } from './catalog/catalog';
import { CartSummary } from './cart-summary/cart-summary';
import { ClockService } from './services/clock.service';
import { LogService } from './services/log.service';
import { CartService } from './services/cart.service';

@Component({
  selector: 'app-root',
  imports: [DatePipe, Catalog, CartSummary],
  providers: [CartService, ClockService],
  templateUrl: './app.html',
})
export class App {
  protected readonly clock = inject(ClockService);
  protected readonly log = inject(LogService);
}
  • línea 23: [App] proporciona un carrito (compartido por él y todos sus descendientes) y un reloj (período predeterminado: un segundo);
  • línea 28: el log, servicio raíz.
<div class="container py-4" style="max-width: 720px">
  <h1 class="h3 mb-3">Example 14 - services and dependency injection</h1>
  <p class="text-muted">Clock of App: {{ clock.now() | date: 'HH:mm:ss' }}</p>
  <div class="row g-3">
    <div class="col-md-6"><app-catalog /></div>
    <div class="col-md-6"><app-cart-summary /></div>
  </div>
  <h2 class="h6 mt-3">Log (LogService)</h2>
  <ul class="small">
    @for (line of log.lines(); track $index) {
      <li>{{ line }}</li>
    }
  </ul>
</div>

[npm start 14-services]; se agregan tres artículos y se elimina uno:

Image

Los dos temporizadores no avanzan al mismo ritmo: cada componente ha recibido la instancia más cercana a él. El carrito de compras, en cambio, es compartido tanto por el catálogo como por el resumen.

Los servicios son el medio, en [Angular], de compartir lógica y datos entre componentes (el papel que desempeñan los “composables” y [provide] / [inject] en [Vue.js]). El ejemplo 20 convertirá esto en un estado compartido por toda la aplicación.

3.6. Ejemplo 15: escribir sus propias directivas

Un componente es una directiva que tiene una plantilla. Una directiva “por sí sola” no la tiene: se adjunta a un elemento existente (su host) para modificar su apariencia o su comportamiento. [Angular] proporciona algunas ([ngModel], [routerLink], [ngTemplateOutlet]...); usted puede escribir las suyas. Aquí hay tres ejemplos.

3.6.1. Resaltar un elemento al pasar el mouse

// =========================================================================
// 15-directives/src/app/directives/highlight.directive.ts
// -------------------------------------------------------------------------
// Una DIRECTIVA DE ATRIBUTO agrega un comportamiento a un elemento existente,
// sin plantilla propia: <li appHighlight="gold">. Su selector es un
// selector de atributo CSS ([appHighlight]).
// host: los enlaces que la directiva establece en el elemento que la lleva
// (su "host"):
//   - '[style.background-color]' : una propiedad del elemento;
//   - '(mouseenter)'             : un evento del elemento.
// =========================================================================

import { Directive, input, signal } from '@angular/core';

@Directive({
  selector: '[appHighlight]',
  host: {
    '[style.background-color]': 'hovered() ? color() : null',
    '[style.transition]': '"background-color 0.2s"',
    '(mouseenter)': 'hovered.set(true)',
    '(mouseleave)': 'hovered.set(false)',
  },
})
export class HighlightDirective {
  // el input tiene el nombre del selector: <li appHighlight="gold"> lo establece
  readonly color = input('#fff3cd', { alias: 'appHighlight', transform: (c: string) => c || '#fff3cd' });
  protected readonly hovered = signal(false);
}
  • línea 15: [@Directive] en lugar de [@Component]: sin plantilla;
  • línea 16: el selector es un selector CSS de atributo: la directiva se aplica a cualquier elemento que tenga el atributo [appHighlight];
  • líneas 17–22: [host]: los enlaces que la directiva aplica a su host, escritos como en una plantilla:
    • línea 18: un enlace de propiedad: el color de fondo del host cuando el mouse pasa sobre él ([null]: sin color);
    • líneas 20–21: enlaces de eventos: entrada y salida del mouse;
  • Línea 26: una entrada con el nombre del selector (opción [alias]): [<li appHighlight="gold">] rellena a la vez el selector y la entrada. La función [transform] reemplaza una cadena vacía por el color predeterminado.

3.6.2. Dar el foco

// =========================================================================
// 15-directives/src/app/directives/autofocus.directive.ts
// -------------------------------------------------------------------------
// <input appAutofocus>: el campo recibe el foco apenas se muestra.
// inject(ElementRef) da el elemento HTML host (nativeElement).
// (El atributo HTML autofocus solo funciona cuando se carga la página;
// en una aplicación de página única, los campos aparecen después.)
// =========================================================================

import { afterNextRender, Directive, ElementRef, inject } from '@angular/core';

@Directive({ selector: '[appAutofocus]' })
export class AutofocusDirective {
  constructor() {
    const element = inject<ElementRef<HTMLElement>>(ElementRef).nativeElement;
    afterNextRender(() => element.focus());
  }
}
  • línea 15: [inject(ElementRef)] designa el elemento host;
  • línea 16: se le da el foco en cuanto se muestra. El atributo HTML [autofocus] solo funciona cuando se carga la página; en una aplicación de página única, los campos aparecen más tarde.

3.6.3. Un clic largo

Una directiva también puede emitir eventos. Esta emite su evento solo si el host se mantiene presionado durante un segundo: una protección contra clics accidentales.

// =========================================================================
// 15-directives/src/app/directives/long-press.directive.ts
// -------------------------------------------------------------------------
// Una directiva también puede EMITIR eventos (output):
//     <button (appLongPress)="remove()">
// El evento solo se emite si el botón se mantiene presionado durante un segundo:
// una protección contra clics desafortunados. Durante la pulsación, la clase
// CSS "pressed" se establece en el botón.
// =========================================================================

import { DestroyRef, Directive, inject, input, output, signal } from '@angular/core';

@Directive({
  selector: '[appLongPress]',
  host: {
    '[class.pressed]': 'pressing()',
    '(pointerdown)': 'start()',
    '(pointerup)': 'stop()',
    '(pointerleave)': 'stop()',
  },
})
export class LongPressDirective {
  readonly duration = input(1000); // en milisegundos
  readonly appLongPress = output<void>();
  protected readonly pressing = signal(false);
  private timer: number | undefined;

  constructor() {
    inject(DestroyRef).onDestroy(() => window.clearTimeout(this.timer));
  }

  protected start(): void {
    this.pressing.set(true);
    this.timer = window.setTimeout(() => {
      this.pressing.set(false);
      this.appLongPress.emit();
    }, this.duration());
  }

  protected stop(): void {
    window.clearTimeout(this.timer);
    this.pressing.set(false);
  }
}
  • línea 16: mientras el host está presionado, se le aplica la clase [pressed] ;
  • líneas 17–19: eventos de puntero (mouse, dedo, lápiz): presionar, soltar, salir del elemento;
  • línea 24: una salida que lleva el nombre del selector: escribimos [(appLongPress)="..."], y aplicamos la directiva al mismo tiempo que escuchamos su evento;
  • línea 29: el temporizador se detiene si el host desaparece.

3.6.4. Uso

// =========================================================================
// 15-directives/src/app/app.ts - escribir directivas propias
// -------------------------------------------------------------------------
// Un componente es una directiva CON plantilla. Una directiva "simple"
// no tiene plantilla: se adjunta a un elemento existente para
// modificar su apariencia o su comportamiento. Como un componente, debe
// ser importada por el componente que la usa.
// =========================================================================

import { Component, signal } from '@angular/core';
import { AutofocusDirective } from './directives/autofocus.directive';
import { LongPressDirective } from './directives/long-press.directive';
import { HighlightDirective } from './directives/highlight.directive';

@Component({
  selector: 'app-root',
  imports: [AutofocusDirective, LongPressDirective, HighlightDirective],
  templateUrl: './app.html',
  styles: `
    .pressed {
      outline: 4px solid #dc3545;
    }
  `,
})
export class App {
  protected readonly doctors = signal(['Mme Marie PELISSIER', 'Mr Paul TATOU', 'Melle Sophie DUPONT']);
  protected readonly message = signal('');

  protected remove(name: string): void {
    this.doctors.update((m) => m.filter((x) => x !== name));
    this.message.set(`${name} has been deleted.`);
  }
}
  • línea 17: como un componente, una directiva debe ser importada por el componente que la utiliza;
  • líneas 19–23: el estilo de la clase [pressed], establecido por la directiva de clic largo.
<div class="container py-4" style="max-width: 640px">
  <h1 class="h3 mb-3">Example 15 - writing your own directives</h1>
  <!-- appAutofocus: el campo tiene el foco apenas se muestra la página -->
  <input appAutofocus class="form-control mb-3" placeholder="this field received the focus by itself">

  <p class="small text-muted">Hover over the rows; hold a button down for one second to delete.</p>
  <ul class="list-group mb-3">
    @for (m of doctors(); track m; let even = $even) {
      <!-- appHighlight: sin valor, el color por defecto; con uno, el color indicado -->
      <li class="list-group-item d-flex justify-content-between align-items-center"
          [appHighlight]="even ? '' : '#d1e7dd'">
        {{ m }}
        <button class="btn btn-sm btn-outline-danger" (appLongPress)="remove(m)">Delete (long press)</button>
      </li>
    }
  </ul>
  @if (message()) {
    <p class="alert alert-info">{{ message() }}</p>
  }
</div>
  • Línea 4: el campo tendrá el foco en cuanto se muestre;
  • línea 8: [let even = $even]: ¿el número de fila es par?
  • línea 11: una de cada dos filas se resalta con el color predeterminado, la otra en verde;
  • Línea 13: una pulsación larga elimina al médico.

[npm start 15-directives]; mantenga presionado el segundo botón y luego pase el mouse sobre la primera fila:

Image

3.7. Ejemplo 16: una ventana de confirmación reutilizable

Antes de eliminar un elemento, se pide al usuario que confirme. El navegador proporciona [window.confirm()], pero su ventana no se puede formatear ni traducir. Este ejemplo la reemplaza por una ventana [Bootstrap], combinando lo que han mostrado los ejemplos anteriores: un servicio (ejemplo 14) que lleva el estado de la ventana en un signal, y un componente que la muestra. El caso de estudio usará exactamente este mecanismo.

1
2
3
4
5
6
16-confirmation/src/app/
├── confirmation/
│   ├── confirmation.service.ts   the service: the question asked, the answer
│   └── confirm-dialog.ts         the modal dialog
├── app.ts
└── app.html

3.7.1. El servicio

// =========================================================================
// 16-confirmation/src/app/confirmation/confirmation.service.ts
// -------------------------------------------------------------------------
// "¿Está seguro?": window.confirm() existe, pero no se le puede dar
// estilo ni traducir sus botones. Lo reemplazamos por un diálogo de
// Bootstrap (confirm-dialog.ts), controlado por este servicio.
//
// 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 this.confirmation.confirm('Delete this doctor?')) { ... }
//
// providedIn: 'root': un solo servicio para toda la aplicación, por lo tanto un solo
// diálogo, colocado una vez en el componente raíz.
// =========================================================================

import { Injectable, signal } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class ConfirmationService {
  private readonly _message = signal<string | null>(null); // null: diálogo cerrado
  readonly message = this._message.asReadonly();
  private answer: ((yes: boolean) => void) | null = null;

  confirm(text: string): Promise<boolean> {
    this.answer?.(false); // ¿una pregunta aún abierta? cuenta como "no"
    this._message.set(text);
    return new Promise<boolean>((resolve) => {
      this.answer = resolve;
    });
  }

  respond(yes: boolean): void {
    this._message.set(null);
    const r = this.answer;
    this.answer = null;
    r?.(yes);
  }
}
  • línea 20: un único servicio para toda la aplicación; por lo tanto, habrá una sola ventana, colocada de una vez por todas en el componente raíz;
  • línea 22: el mensaje mostrado; [null] significa que la ventana está cerrada;
  • línea 23: [asReadonly()]: los componentes pueden leer el mensaje, pero solo el servicio puede modificarlo;
  • línea 24: la función que resolverá la promesa actual, que está a la espera de una respuesta;
  • líneas 26–32: [confirm] abre la ventana (línea 28) y devuelve una promesa. Su función [resolve] se guarda aparte (línea 30): la promesa no se resolverá hasta más tarde, cuando el usuario haga clic en un botón;
  • línea 27: si todavía hubiera una pregunta abierta, se respondería “no”: su promesa no permanecerá pendiente para siempre;
  • líneas 34–39: [respond] es llamada por la ventana: cierra la ventana (línea 35) y luego resuelve la promesa con la respuesta del usuario (línea 38).

Esta es la ventaja de la promesa: el código que hace la pregunta la escribe como una llamada a [window.confirm()], esperando la respuesta con [await], sin función de callback.

3.7.2. La ventana

// =========================================================================
// 16-confirmation/src/app/confirmation/confirm-dialog.ts
// -------------------------------------------------------------------------
// El diálogo modal, colocado UNA VEZ en el componente raíz:
//   - mismas clases de Bootstrap que un modal real (.modal, .modal-backdrop),
//     mostrado "estáticamente" (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.
// '(document:keydown.escape)' en host: un evento escuchado en todo el
// DOCUMENT, y no en el elemento del componente.
// =========================================================================

import { Component, effect, ElementRef, inject, viewChild } from '@angular/core';
import { ConfirmationService } from './confirmation.service';

@Component({
  selector: 'app-confirm-dialog',
  host: { '(document:keydown.escape)': 'confirmation.message() !== null && confirmation.respond(false)' },
  template: `
    @if (confirmation.message(); as message) {
      <div class="modal-backdrop fade show"></div>
      <div class="modal fade show d-block" tabindex="-1" role="alertdialog" aria-modal="true"
           (click)="$event.target === $event.currentTarget && confirmation.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)="confirmation.respond(false)"></button>
            </div>
            <div class="modal-body">
              <p class="mb-0">{{ message }}</p>
            </div>
            <div class="modal-footer">
              <button #noButton type="button" class="btn btn-secondary" (click)="confirmation.respond(false)">No, go back</button>
              <button type="button" class="btn btn-danger" (click)="confirmation.respond(true)">Yes, confirm</button>
            </div>
          </div>
        </div>
      </div>
    }
  `,
})
export class ConfirmDialog {
  protected readonly confirmation = inject(ConfirmationService);
  private readonly noButton = viewChild<ElementRef<HTMLButtonElement>>('noButton');

  constructor() {
    // al abrir, aparece el botón "No": recibe el foco
    effect(() => this.noButton()?.nativeElement.focus());
  }
}
  • línea 19: [document:keydown.escape]: el evento se escucha en todo el documento, no en el elemento del componente. La tecla Esc responde “no” si hay una pregunta abierta;
  • línea 21: la ventana solo aparece si hay un mensaje que mostrar; [as message] asigna un nombre al valor del signal;
  • Líneas 22–23: las clases de un verdadero modal de [Bootstrap], mostrado directamente ([show d-block]): el [JavaScript] derivado de [Bootstrap] es innecesario, ya que [Angular] determina la visualización;
  • línea 24: un clic al lado del cuadro de diálogo (sobre el fondo gris) responde “no”. [$event.target === $event.currentTarget]: el clic se produjo en el propio elemento [.modal], no en uno de sus hijos;
  • líneas 35–36: las dos respuestas. El botón “No” lleva la variable de plantilla [#noButton];
  • línea 46: [viewChild] (ejemplo 13) devuelve el elemento marcado con [#noButton] como un signal: es igual a [undefined] mientras la ventana está cerrada;
  • línea 50: un efecto que depende de este signal: cada vez que se abre la ventana, aparece el botón “No”, el signal cambia y el botón recibe el foco. Elegimos “No”, la respuesta menos peligrosa: presionar la tecla Enter por error no elimina nada.

3.7.3. Uso

// =========================================================================
// 16-confirmation/src/app/app.ts - uso del diálogo de confirmación
// -------------------------------------------------------------------------
// La misma página que el ejemplo 21 del curso de NestJS (enlaces, botones, confirmación),
// pero sin ninguna ida y vuelta a un servidor.
// =========================================================================

import { Component, inject, signal } from '@angular/core';
import { ConfirmationService } from './confirmation/confirmation.service';
import { ConfirmDialog } from './confirmation/confirm-dialog';

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

@Component({
  selector: 'app-root',
  imports: [ConfirmDialog],
  templateUrl: './app.html',
})
export class App {
  private readonly confirmation = inject(ConfirmationService);
  protected readonly contacts = signal<Contact[]>([
    { id: 1, name: 'Jean MARTIN' },
    { id: 2, name: 'Alice DURAND' },
    { id: 3, name: 'Luc GERMAN' },
  ]);
  protected readonly message = signal('');

  // un método async: "espera" la respuesta del usuario
  protected async remove(c: Contact): Promise<void> {
    if (!(await this.confirmation.confirm(`Delete the contact ${c.name}?`))) {
      this.message.set('Deletion cancelled.');
      return;
    }
    this.contacts.update((list) => list.filter((x) => x.id !== c.id));
    this.message.set(`${c.name} has been deleted.`);
  }

  protected async removeAll(): Promise<void> {
    if (await this.confirmation.confirm(`Delete the ${this.contacts().length} contacts?`)) {
      this.contacts.set([]);
      this.message.set('All the contacts have been deleted.');
    }
  }
}
  • línea 19: el componente raíz importa la ventana, que colocará en su plantilla;
  • línea 23: solicita el servicio;
  • líneas 32–39: un método declarado [async]. En la línea 33, [await] suspende la ejecución hasta que el usuario responde; durante ese tiempo, la aplicación sigue activa. El resto del método se ejecuta solo si la respuesta es “Yes”;
  • líneas 41–46: el mismo principio se aplica a la eliminación de todos los contactos.
<div class="container py-4" style="max-width: 640px">
  <h1 class="h3 mb-3">Example 16 - a confirmation dialog</h1>
  <ul class="list-group mb-3">
    @for (c of contacts(); track c.id) {
      <li 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>
    } @empty {
      <li class="list-group-item text-muted">No contact.</li>
    }
  </ul>
  <button class="btn btn-danger" [disabled]="contacts().length === 0" (click)="removeAll()">Delete all</button>
  @if (message()) {
    <p class="alert alert-info mt-3">{{ message() }}</p>
  }
</div>
<!-- el diálogo, UNA VEZ para toda la aplicación -->
<app-confirm-dialog />
  • líneas 4–11: [@for] puede ir seguido de un bloque [@empty], que se muestra cuando la lista está vacía;
  • línea 13: el botón se deshabilita cuando ya no queda nada por eliminar;
  • línea 19: la ventana, colocada una sola vez para toda la aplicación. Cualquier componente puede entonces abrirla simplemente llamando al servicio.

[npm start 16-confirmation]; haga clic en el botón [Delete] de Alice DURAND:

Image

Con [Vue.js], la ventana y su estado los proporcionaba un “composable”; con [Angular], es un servicio. El principio es el mismo: un estado compartido, en un signal, que varios componentes leen y modifican.