Skip to content

3. Componentes

3.1. Ejemplo 10: los componentes y sus props

Un componente es una pieza reutilizable de la interfaz de usuario. Este ejemplo crea uno, [DoctorCard], y lo utiliza varias veces.

3.1.1. Tipo de datos

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

El tipo [Doctor] lo comparten el padre y el hijo: se almacena en un módulo aparte.

3.1.2. El hijo

// =========================================================================
// 10-components/src/DoctorCard.tsx - un componente HIJO
// -------------------------------------------------------------------------
// Recibe sus datos de su padre mediante PROPS (propiedades): los
// atributos escritos por el padre en <DoctorCard ... />, reunidos por
// React en UN objeto, primer parámetro de la función. Su tipo es
// verificado 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; para pedir un cambio,
// el hijo llama a una función que el padre le pasó (cf. ejemplo 11).
// =========================================================================

import type { Doctor } from './doctor';
// styles: un objeto { initials: '_initials_x7f3a_1' } - el nombre real de cada clase
import styles from './DoctorCard.module.css';

// el tipo de las props: lo que el padre PUEDE (?) o DEBE proporcionar
interface Props {
  doctor: Doctor;
  rank: number;
  compact?: boolean; // opcional
}

// el objeto props se "desestructura"; compact = false: su valor por defecto
export default function DoctorCard({ doctor, rank, compact = false }: Props) {
  // un valor calculado a partir de las props: se recalcula si el padre las cambia
  const initials = `${doctor.firstName[0]}${doctor.lastName[0]}`;

  return (
    <div className={`card h-100 ${doctor.available ? 'border-success' : ''}`}>
      <div className="card-body d-flex gap-3 align-items-center">
        <div className={styles.initials}>{initials}</div>
        <div>
          <h2 className="h6 mb-1">{rank}. {doctor.title} {doctor.firstName} {doctor.lastName}</h2>
          {!compact && <p className="mb-0 text-muted small">{doctor.specialty}</p>}
        </div>
      </div>
    </div>
  );
}
  • línea 14: una importación solo de tipos;
  • línea 16: una importación del módulo CSS (véase más adelante);
  • líneas 19–23: los tipos de las props del componente: los atributos que el padre escribe en [<DoctorCard ... />]. [compact?] es opcional;
  • línea 26: [React] combina las props en UN solo objeto, que pasa como primer parámetro a la función. Este se "desempaqueta" de inmediato: [{ doctor, rank, compact = false }] produce tres variables, donde [compact] es igual a [false] si el padre no lo proporciona. El tipo de las props se verifica en tiempo de compilación: [<DoctorCard doctor={42} />] sería rechazado, al igual que la omisión de [rank];
  • línea 28: un valor calculado a partir de las props: si el padre cambia las props, se vuelve a llamar al componente y el valor se recalcula;
  • línea 33: la clase CSS, leída del módulo CSS;
  • línea 36: la especialidad se muestra solo en modo normal.

Regla de oro: un componente nunca modifica sus propias props. Los datos fluyen del padre al hijo; para solicitar un cambio, el hijo llama a una función que el padre le pasó (véase el ejemplo 11).

3.1.3. Un módulo CSS

/* un "módulo CSS" (archivo *.module.css): Vite renombra cada clase
   (.initials -> ._initials_x7f3a_1); por lo tanto solo puede aplicarse a los
   elementos del componente que lo importa */
.initials {
  width: 2.5rem;
  height: 2.5rem;
  border-radius: 50%;
  display: flex;
  align-items: center;
  justify-content: center;
  background: #087ea4;
  color: white;
  font-weight: bold;
}

Un archivo cuyo nombre termina en [.module.css] es un módulo CSS: [Vite] cambia el nombre de cada una de sus clases ([.initials] se convierte, por ejemplo, en [._initials_x7f3a_1]) y, al importarlo, proporciona un objeto que asocia el nombre original con el nombre real: [styles.initials]. Por lo tanto, la clase solo puede aplicarse a los elementos del componente que la importa: esto equivale al encapsulamiento de estilos de [Angular]. Las clases de [Bootstrap], que son globales, siguen siendo utilizables en todas partes.

3.1.4. El padre

// =========================================================================
// 10-components/src/App.tsx - el componente PADRE
// -------------------------------------------------------------------------
// Importa el componente DoctorCard y lo usa como una nueva
// etiqueta, <DoctorCard />, tantas veces como sea necesario: un componente es
// una pieza REUTILIZABLE de interfaz, con sus propios datos, su JSX y
// su estilo. Una etiqueta que empieza con una letra MAYÚSCULA es un componente;
// en minúscula (<div>, <p>), es un elemento HTML.
// =========================================================================

import { useState } from 'react';
import DoctorCard from './DoctorCard';
import type { Doctor } from './doctor';

export default function App() {
  const [doctors, setDoctors] = useState<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, setCompact] = useState(false);

  // el padre modifica SUS datos: React vuelve a llamar al padre, luego a los
  // hijos, con sus nuevas props
  function toggleAvailability() {
    setDoctors((list) => list.map((m) => ({ ...m, available: !m.available })));
  }

  return (
    <div className="container py-4">
      <h1 className="h3 mb-3">Example 10 - components and their props</h1>
      <div className="d-flex gap-3 mb-3">
        <label className="form-check-label">
          <input type="checkbox" className="form-check-input" checked={compact}
                 onChange={(e) => setCompact(e.target.checked)} /> compact display
        </label>
        <button className="btn btn-sm btn-outline-primary" onClick={toggleAvailability}>Toggle availabilities</button>
      </div>
      <div className="row g-3">
        {doctors.map((m, i) => (
          <div key={m.id} className="col-md-4">
            {/* doctor={m} pasa el OBJETO m (una expresión);
                doctor="m", sin llaves, pasaría la CADENA "m" */}
            <DoctorCard doctor={m} rank={i + 1} compact={compact} />
          </div>
        ))}
      </div>
      <p className="mt-3 mb-1 small text-muted">The same card, in compact version, by an attribute without a value:</p>
      <div className="w-50">
        {/* compact, sin valor, es true */}
        <DoctorCard doctor={doctors[0]} rank={1} compact />
      </div>
    </div>
  );
}
  • línea 12: el componente hijo se importa como cualquier otro módulo;
  • líneas 25–27: el padre modifica SUS datos. [React] lo vuelve a renderizar y luego vuelve a renderizar a los hijos con sus nuevas props: las tarjetas se actualizan;
  • línea 44: el componente se usa como una nueva etiqueta. [doctor={m}] pasa el OBJETO [m] (una expresión); [doctor="m"], sin llaves, pasaría la CADENA "m";
  • línea 51: un atributo sin valor ([compact]) es igual a [true].

Image

Al marcar "compact display" y luego invertir la disponibilidad:

Image

3.2. Ejemplo 11: el hijo notifica a su padre

Los datos fluyen hacia abajo mediante las props. Para enviar información hacia arriba, el padre pasa funciones al hijo, que este luego llama.

3.2.1. "Eventos" del hijo

// =========================================================================
// 11-lifting-state-up/src/Counter.tsx
// -------------------------------------------------------------------------
// Un hijo que NOTIFICA a su padre: el padre le pasa FUNCIONES
// en sus props (por convención, su nombre empieza con "on"), y el hijo
// las llama cuando ocurre algo:
//     <Counter label="Coffees" max={3} onIncrement={...} onLimit={...} />
// =========================================================================

import { useState } from 'react';

interface Props {
  label: string;
  max: number;
  onIncrement: (value: number) => void; // con el nuevo valor
  onLimit: () => void; // sin datos
}

export default function Counter({ label, max, onIncrement, onLimit }: Props) {
  // el estado PROPIO de este contador: cada <Counter> tiene el suyo
  const [value, setValue] = useState(0);

  function plus() {
    if (value >= max) {
      onLimit();
      return;
    }
    setValue(value + 1);
    // value todavía no se ha modificado (lo hará en la siguiente llamada del
    // componente): se pasa value + 1
    onIncrement(value + 1);
  }

  return (
    <div className="d-flex align-items-center gap-2 mb-2">
      <span className="w-25">{label}</span>
      <button className="btn btn-sm btn-outline-primary" onClick={plus}>+1</button>
      <span className="badge text-bg-secondary">{value} / {max}</span>
    </div>
  );
}
  • Líneas 12–17: dos props son funciones: [onIncrement] recibe el nuevo valor, mientras que [onLimit] no recibe nada. Por convención, sus nombres comienzan con "on", como [onClick];
  • Línea 21: el estado PROPIO de este contador: cada [<Counter>] de la página tiene el suyo. El estado está asociado a la posición del componente en el árbol de la página;
  • líneas 23–32: se notifica al padre. Atención: [setValue(value + 1)] no cambia la variable [value] (una constante fijada para ESTA llamada del componente): valdrá [value + 1] en la SIGUIENTE llamada. Por lo tanto, se pasa [value + 1] al padre.

3.2.2. Un componente controlado

// =========================================================================
// 11-lifting-state-up/src/TextField.tsx - un componente CONTROLADO
// -------------------------------------------------------------------------
// Un campo de formulario "casero" (etiqueta + campo + ayuda + contador de
// caracteres) usado como un <input> controlado (cf. ejemplo 05):
//     <TextField value={lastName} onChange={setLastName} label="Last name" max={20} />
// El componente NO tiene estado: el valor pertenece al padre, que se lo
// pasa (value) y a quien notifica cada pulsación de tecla (onChange). Es el
// padre quien decide el nuevo valor.
// =========================================================================

import { useId } from 'react';

interface Props {
  value: string;
  onChange: (value: string) => void;
  label: string;
  max: number;
  help?: string;
}

export default function TextField({ value, onChange, label, max, help = '' }: Props) {
  // useId: un identificador ÚNICO, distinto para cada <TextField> de la
  // página, para vincular <label htmlFor> e <input id>
  const id = useId();

  return (
    <div className="mb-3">
      <label className="form-label" htmlFor={id}>{label}</label>
      <input id={id} className={`form-control ${value.length === max ? 'is-invalid' : ''}`} value={value}
             maxLength={max} onChange={(e) => onChange(e.target.value)} />
      <div className="form-text">{help} ({value.length} / {max})</div>
    </div>
  );
}

Un campo de formulario "personalizado" (etiqueta, campo, información sobre herramientas, contador de caracteres) que se utiliza como un [<input>] controlado (véase el ejemplo 05): el padre le pasa el valor ([value]) y una función a la que se llama con cada pulsación de tecla ([onChange]).

  • líneas 14–20: las props; [help] es opcional;
  • línea 25: [useId()] proporciona un identificador único, distinto para cada [<TextField>] de la página, para vincular [<label htmlFor>] y [<input id>];
  • línea 31: cada pulsación de tecla llama a la función del padre con el nuevo texto.

El componente no tiene estado: el valor pertenece al padre, que determina el nuevo valor. Esto se llama "elevar el estado": los datos compartidos por varios componentes se almacenan en su ancestro común más cercano.

3.2.3. El padre

// =========================================================================
// 11-lifting-state-up/src/App.tsx - el padre escucha a sus hijos
// -------------------------------------------------------------------------
// Los datos fluyen hacia abajo (props); la información fluye hacia arriba mediante
// funciones pasadas en las props:
//   1. los "eventos" del hijo: onIncrement, onLimit;
//   2. un componente controlado: value + onChange, como un <input>. El estado
//      sigue siendo propiedad del padre, que puede modificarlo él mismo (Clear).
// =========================================================================

import { useState } from 'react';
import Counter from './Counter';
import TextField from './TextField';

export default function App() {
  const [total, setTotal] = useState(0);
  const [message, setMessage] = useState('');
  const [firstName, setFirstName] = useState('Marie');
  const [lastName, setLastName] = useState('PELISSIER');

  // la función llamada por un contador: recibe el valor que este le pasa
  function onIncrement(label: string, value: number) {
    setTotal((t) => t + 1);
    setMessage(`${label} is now ${value}`);
  }

  function clear() {
    setFirstName('');
    setLastName('');
  }

  return (
    <div className="container py-4" style={{ maxWidth: 640 }}>
      <h1 className="h3 mb-3">Example 11 - the child notifies its parent</h1>

      <div className="card p-3 mb-4">
        <h2 className="h6">1. Functions called by the children</h2>
        <Counter label="Coffees" max={3} onIncrement={(v) => onIncrement('Coffees', v)}
                 onLimit={() => setMessage('No more than 3 coffees!')} />
        <Counter label="Glasses of water" max={8} onIncrement={(v) => onIncrement('Glasses of water', v)}
                 onLimit={() => setMessage('Enough drinking.')} />
        <p className="mb-0">Total of the clicks: {total} - <em>{message}</em></p>
      </div>

      <div className="card p-3">
        <h2 className="h6">2. Controlled components</h2>
        {/* onChange={setFirstName}: la función del estado, pasada tal cual */}
        <TextField value={firstName} onChange={setFirstName} label="First name" max={20} help="Required" />
        <TextField value={lastName} onChange={setLastName} label="Last name" max={20} help="Displayed in upper case" />
        <p className="mb-0">Data of the parent: <strong>{firstName} {lastName.toUpperCase()}</strong></p>
        <button className="btn btn-sm btn-outline-secondary mt-2 align-self-start" onClick={clear}>Clear (from the parent)</button>
      </div>
    </div>
  );
}
  • líneas 22–25: la función a la que llama un contador; recibe el valor que el contador le pasa;
  • líneas 38–39: el padre pasa funciones flecha, que agregan la etiqueta del contador;
  • línea 48: [onChange={setFirstName}]: la función de estado se pasa tal cual; el hijo la llama con el nuevo texto;
  • línea 51: el padre modifica los valores por sí mismo; los campos lo siguen.

Haga clic dos veces, luego cuatro veces en el primer "+1", una vez en el segundo y escriba "Dupont" en el campo Last name:

Image

3.3. Ejemplo 12: composición

Las props pasan datos... pero también contenido: "JSX" es un valor como cualquier otro (como "[ReactNode]"), que se puede pasar a un componente, y el componente puede colocarlo donde quiera.

3.3.1. Una tarjeta

// =========================================================================
// 12-composition/src/Card.tsx - una PLANTILLA reutilizable
// -------------------------------------------------------------------------
// Las props pasan DATOS... pero también CONTENIDO: JSX es
// un valor como cualquier otro (de tipo ReactNode), que se puede pasar a un
// componente y que este coloca donde quiera:
//   - children: la prop especial que recibe lo que el padre escribe ENTRE
//                <Card> y </Card> - el contenido "principal";
//   - header, footer: otros marcadores de posición, proporcionados por el padre en
//                forma de props; header tiene un contenido por defecto.
// La tarjeta define el marco (borde, encabezado, pie de página), el padre proporciona lo que
// hay dentro. Es el equivalente en el cliente de la plantilla layout.hbs
// y de su {{{body}}} en el curso de NestJS.
// =========================================================================

import type { ReactNode } from 'react';

interface Props {
  color?: 'primary' | 'success' | 'danger';
  header?: ReactNode;
  footer?: ReactNode;
  children: ReactNode;
}

export default function Card({ color, header = 'Untitled', footer, children }: Props) {
  return (
    <div className={`card mb-3 ${color ? `border-${color}` : ''}`}>
      <div className={`card-header ${color ? `text-bg-${color}` : ''}`}>{header}</div>
      <div className="card-body">{children}</div>
      {/* no se proporcionó pie de página: no hay pie de página alguno */}
      {footer && <div className="card-footer text-muted small">{footer}</div>}
    </div>
  );
}
  • líneas 18–23: [header], [footer] y [children] son [ReactNode]: JSX, texto, un número o nada;
  • línea 25: contenido predeterminado;
  • línea 29: [children] es una propiedad especial: recibe lo que el padre escribe ENTRE [<Card>] y [</Card>], el contenido "principal";
  • línea 31: si no se proporciona pie de página, no hay pie de página.

La plantilla define el marco (borde, encabezado, pie de página); el padre proporciona el contenido que va dentro: esto equivale a la proyección de contenido de [Angular] ([<ng-content>]) y a los "slots" de [Vue.js]y, del lado del servidor, a la plantilla [layout.hbs] y su [{{{body}}}] en el curso [NestJS].

3.3.2. Una tabla genérica

// =========================================================================
// 12-composition/src/DataTable.tsx - una tabla GENÉRICA
// -------------------------------------------------------------------------
// DataTable<T> es un componente genérico: muestra filas de
// cualquier tipo T. Sabe recorrer las filas, pero no cómo
// mostrar UNA fila: es el padre quien se lo indica, pasándole una
// FUNCIÓN, renderRow(row, index), que devuelve el JSX de las celdas.
// Esto es lo que se llama una "render prop": el contenido proporcionado por el
// padre usa datos que pertenecen al hijo (la fila, su
// posición).
// =========================================================================

import type { ReactNode } from 'react';

interface Props<T> {
  rows: T[];
  columns: string[];
  renderRow: (row: T, index: number) => ReactNode;
  empty?: ReactNode; // se muestra cuando no hay ninguna fila
}

// <T extends { id: number }>: cada fila debe tener un id (la clave)
export default function DataTable<T extends { id: number }>({ rows, columns, renderRow, empty = 'No data.' }: Props<T>) {
  return (
    <table className="table table-sm align-middle mb-0">
      <thead>
        <tr>
          {columns.map((c) => <th key={c}>{c}</th>)}
        </tr>
      </thead>
      <tbody>
        {rows.length === 0 ? (
          <tr>
            <td className="text-muted" colSpan={columns.length}>{empty}</td>
          </tr>
        ) : (
          rows.map((l, i) => <tr key={l.id}>{renderRow(l, i)}</tr>)
        )}
      </tbody>
    </table>
  );
}
  • líneas 15–20: un tipo genérico: las props de una tabla de líneas de tipo [T], sean cuales sean;
  • línea 18: una prop que es una función que devuelve JSX: la tabla sabe recorrer las filas, pero no cómo mostrar UNA fila; el padre se lo indica. Este procedimiento se llama "render prop";
  • línea 23: un componente genérico: [T] se infiere en tiempo de ejecución a partir del tipo de las filas. Cada fila debe tener un [id], que sirve como clave;
  • línea 37: para cada línea, la tabla llama a la función del padre, pasándole los datos que le corresponden (la línea, su índice).

3.3.3. El padre

// =========================================================================
// 12-composition/src/App.tsx - uso de las plantillas Card y DataTable
// =========================================================================

import { useState } from 'react';
import Card from './Card';
import DataTable from './DataTable';

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

export default function App() {
  const [slots] = useState<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 },
  ]);
  const free = slots.filter((c) => c.patient === null).length;

  return (
    <div className="container py-4" style={{ maxWidth: 720 }}>
      <h1 className="h3 mb-3">Example 12 - composition</h1>

      {/* header y footer: JSX pasado en las props; entre las etiquetas: children */}
      <Card color="primary" header={<span>Schedule of Mme PELISSIER</span>} footer={`${free} free slot(s)`}>
        {/* DataTable<Slot>: T se deduce del tipo de las filas */}
        <DataTable
          rows={slots}
          columns={['#', 'Slot', 'Status']}
          // la "render prop": cómo mostrar UNA fila; c recibe la fila, i su posición
          renderRow={(c, i) => (
            <>
              <td>{i + 1}</td>
              <td>{c.time}</td>
              <td>
                {c.patient ? (
                  <span className="badge text-bg-secondary">{c.patient}</span>
                ) : (
                  <span className="badge text-bg-success">Free</span>
                )}
              </td>
            </>
          )}
        />
      </Card>

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

      {/* no se proporcionó encabezado: el contenido por defecto, "Untitled" */}
      <Card>
        <DataTable<{ id: number; name: string }>
          rows={[]}
          columns={['Name']}
          renderRow={(p) => <td>{p.name}</td>}
          empty={<span>Nobody for now.</span>}
        />
      </Card>
    </div>
  );
}
  • Línea 28: [header] y [footer] reciben JSX o texto; el [<DataTable>] escrito entre las etiquetas se convierte en los [children] de la tarjeta;
  • Líneas 34–43: la render prop: cómo mostrar UNA fila; [c] recibe la línea (de tipo [Slot], derivado de [rows]), con [i] como su posición;
  • Línea 56: con una lista vacía, [TypeScript] no puede deducir [T]: se proporciona explícitamente;
  • línea 60: el contenido que se muestra cuando no hay filas.

Image

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

3.4.1. Un reloj

// =========================================================================
// 13-lifecycle/src/Clock.tsx - un componente que se inicia y se detiene
// -------------------------------------------------------------------------
// La vida de un componente:
//   1. se MUESTRA (montaje): React llama a la función y coloca su
//      resultado en la página; luego ejecuta sus efectos (useEffect);
//   2. se ACTUALIZA, tantas veces como sea necesario (cambian su estado o sus
//      props);
//   3. se ELIMINA de la página (desmontaje): React ejecuta la LIMPIEZA de
//      sus efectos, la función que devolvió cada efecto.
// Un reloj inicia un temporizador (setInterval) cuando aparece... y
// debe detenerlo sin falta cuando desaparece: de lo contrario, el temporizador
// seguiría ejecutándose inútilmente (fuga de memoria).
// =========================================================================

import { useEffect, useEffectEvent, useState } from 'react';

interface Props {
  onLog: (message: string) => void;
}

export default function Clock({ onLog }: Props) {
  const [time, setTime] = useState(() => new Date().toLocaleTimeString());

  // useEffectEvent: una función llamada POR un efecto, que siempre lee
  // las props más recientes, sin ser una dependencia del efecto. Sin
  // ella, habría que poner onLog en las dependencias [...] de abajo
  // y, como el padre pasa una función NUEVA en cada visualización, el
  // temporizador se detendría y se reiniciaría cada segundo
  const log = useEffectEvent((message: string) => onLog(message));

  // []: sin dependencias. El efecto se ejecuta UNA vez, después de la primera
  // visualización; la función que devuelve, UNA vez, cuando se elimina el componente
  useEffect(() => {
    log('Clock: effect - starting the timer');
    const timer = setInterval(() => setTime(new Date().toLocaleTimeString()), 1000);
    // la LIMPIEZA
    return () => {
      clearInterval(timer);
      log('Clock: cleanup - timer stopped');
    };
  }, []);

  return <div className="display-6 font-monospace">{time}</div>;
}

El ciclo de vida de un componente (líneas 4–10): se monta (se muestra por primera vez), se actualiza tantas veces como sea necesario y luego se desmonta (se retira de la página). [React] no tiene métodos separados para cada etapa: todo pasa por [useEffect].

  • Líneas 34–42: [useEffect(effect, [])]: con un arreglo de dependencias VACÍO, el efecto se ejecuta una sola vez, después de la primera visualización. La función que devuelve (líneas 38–41) se encarga de la limpieza: [React] la ejecuta cuando el componente se retira de la página (y antes de cada nueva ejecución del efecto, cuando cambian sus dependencias). Un reloj inicia un temporizador ([setInterval]) al arrancar... y debe detenerlo ([clearInterval]) cuando desaparece: de lo contrario, el temporizador seguiría ejecutándose sin motivo e intentaría modificar el estado de un componente que ya no existe;
  • Línea 30: el efecto llama a la función [onLog] del padre. En rigor, debería incluirla en sus dependencias: como el efecto usa una prop, debe volver a dispararse si la prop cambia. Sin embargo, el padre crea una función NUEVA cada vez que se muestra: el temporizador se detendría y reiniciaría continuamente. [useEffectEvent] ([React] 19.2) crea una función que siempre llama a la versión más reciente de [onLog], sin ser una dependencia del efecto. Solo se la puede llamar desde dentro de un efecto.

3.4.2. El padre

// =========================================================================
// 13-lifecycle/src/App.tsx
// -------------------------------------------------------------------------
//   - {withClock && <Clock />}: marcar / desmarcar la casilla muestra /
//     elimina el componente (efecto, luego limpieza, cf. Clock.tsx);
//   - useRef: una referencia al elemento <input>, null mientras no se
//     muestre; un efecto le da el foco en cuanto aparece;
//   - un efecto que SINCRONIZA el título de la pestaña con el campo de entrada.
//
// En desarrollo, StrictMode (cf. main.tsx) monta cada componente,
// lo desmonta y luego lo vuelve a montar de inmediato: el registro muestra por lo tanto inicio,
// detención, inicio. Es intencional: un efecto cuya limpieza está mal escrita
// (un temporizador que nunca se detiene) se delata de inmediato. En producción, el
// componente se monta una sola vez.
// =========================================================================

import { useEffect, useRef, useState } from 'react';
import Clock from './Clock';

export default function App() {
  const [withClock, setWithClock] = useState(true);
  const [log, setLog] = useState<string[]>([]);
  const [search, setSearch] = useState('');
  const [showSearch, setShowSearch] = useState(false);
  const field = useRef<HTMLInputElement>(null);

  function trace(message: string) {
    setLog((j) => [...j, `${new Date().toLocaleTimeString()} ${message}`]);
  }

  // después de la primera visualización de App (dos veces en desarrollo: StrictMode)
  useEffect(() => {
    trace('App: effect of the first display');
  }, []);

  // el campo acaba de aparecer: se le da el foco
  useEffect(() => {
    if (showSearch) {
      field.current?.focus();
    }
  }, [showSearch]);

  // el título de la pestaña sigue al campo de entrada, desde el inicio
  useEffect(() => {
    document.title = search ? `Search: ${search}` : 'Example 13';
  }, [search]);

  return (
    <div className="container py-4" style={{ maxWidth: 720 }}>
      <h1 className="h3 mb-3">Example 13 - the lifecycle of a component</h1>

      <div className="card p-3 mb-3">
        <label className="form-check-label mb-2">
          <input type="checkbox" className="form-check-input" checked={withClock}
                 onChange={(e) => setWithClock(e.target.checked)} /> show the clock
        </label>
        {withClock && <Clock onLog={trace} />}
      </div>

      <div className="card p-3 mb-3">
        {!showSearch ? (
          <button className="btn btn-outline-primary align-self-start" onClick={() => setShowSearch(true)}>Search...</button>
        ) : (
          <input ref={field} className="form-control" placeholder="the title of the tab follows the input" value={search}
                 onChange={(e) => setSearch(e.target.value)} />
        )}
      </div>

      <h2 className="h6">Log</h2>
      <ol className="small">
        {log.map((line, i) => <li key={i}>{line}</li>)}
      </ol>
    </div>
  );
}
  • línea 25: una referencia al campo de búsqueda, [null], mientras no se muestre;
  • líneas 32–34: el efecto de la primera visualización de [App];
  • líneas 37–41: cuando aparece el campo, se le da el foco: el efecto se ejecuta DESPUÉS de la visualización, cuando el elemento existe y la referencia apunta a él;
  • líneas 44–46: un efecto que sincroniza el título de la pestaña con el estado;
  • línea 57: marcar o desmarcar la casilla muestra u oculta el reloj.

Al iniciar, el registro sorprende: el reloj arranca, se detiene y vuelve a arrancar, y el efecto [App] se ejecuta dos veces. Esto se debe a [<StrictMode>] (véase [main.tsx]): solo en desarrollo, [React] monta cada componente, lo desmonta y lo vuelve a montar de inmediato para verificar que sus efectos saben limpiar tras de sí. Así se revela de inmediato un efecto mal escrito (como un temporizador que nunca se detiene): el reloj avanzaría de dos en dos segundos. En producción, el componente se monta una sola vez. También observamos que los efectos de los hijos (el reloj) se ejecutan ANTES que los del padre.

Luego desmarque y vuelva a marcar la casilla, y escriba "pediatrician" en el campo de búsqueda:

Image

Los efectos son la parte más delicada de [React]. Una regla guía su uso: un efecto sincroniza el componente con algo ajeno a [React] (el título de la pestaña, un temporizador, un detector de eventos del documento, un servidor). Para calcular un valor a partir de otro, use una variable (ejemplo 02), no un efecto. Para responder a una acción del usuario, use un manejador de eventos, no un efecto.

3.5. Ejemplo 14: contextos

¿Cómo compartir datos y funciones entre componentes distantes sin pasarlos de props en props por todos los intermediarios? Con un contexto. Así es como [React] comparte lo que [Angular] almacena en sus servicios, que se proporcionan mediante inyección de dependencias.

3.5.1. Un contexto para toda la aplicación

// =========================================================================
// 14-contexts/src/contexts/log.tsx - un contexto para TODA la aplicación
// -------------------------------------------------------------------------
// ¿Cómo compartir datos y funciones entre componentes distantes,
// sin pasarlos de props en props por todos los
// intermediarios? Con un CONTEXTO:
//   1. createContext(defaultValue) crea el contexto;
//   2. un componente PROVEEDOR, <LogContext value={...}>, da su
//      valor a TODOS sus descendientes, a cualquier profundidad;
//   3. un descendiente lo LEE con use(LogContext) (o useContext).
// Cuando el valor proporcionado cambia, todos los componentes que lo leen
// son llamados de nuevo.
//
// La costumbre: un archivo por contexto, que exporta el proveedor (un
// componente que contiene el estado) y un HOOK para leerlo (useLog).
// Así es como React comparte lo que Angular almacena en sus servicios.
// =========================================================================

import { createContext, use, useCallback, useMemo, useState, type ReactNode } from 'react';

interface Log {
  lines: string[];
  trace: (message: string) => void;
}

// null: el valor leído si NINGÚN proveedor envuelve al componente
const LogContext = createContext<Log | null>(null);

// el proveedor: contiene el estado y lo proporciona a sus descendientes
export function LogProvider({ children }: { children: ReactNode }) {
  const [lines, setLines] = useState<string[]>([]);

  // useCallback: la MISMA función de una visualización a la siguiente (y no una
  // nueva cada vez), para que los componentes que la reciben
  // no parezcan haber cambiado
  const trace = useCallback((message: string) => {
    setLines((l) => [`${new Date().toLocaleTimeString()} ${message}`, ...l].slice(0, 6));
  }, []);

  // useMemo: un objeto nuevo solo si lines ha cambiado
  const value = useMemo(() => ({ lines, trace }), [lines, trace]);

  // React 19: el propio contexto es el componente proveedor
  return <LogContext value={value}>{children}</LogContext>;
}

// el hook de lectura: un nombre que empieza con "use"
export function useLog(): Log {
  // use(context): el valor proporcionado por el proveedor MÁS CERCANO
  const log = use(LogContext);
  if (log === null) {
    throw new Error('useLog must be used inside a <LogProvider>');
  }
  return log;
}
  • líneas 21–24: lo que proporciona el contexto: datos y una función;
  • línea 27: [createContext(defaultValue)] crea el contexto. [null]: el valor que lee un componente que no está dentro de ningún proveedor;
  • líneas 30–45: el proveedor: un componente que contiene el estado y lo pasa a todos sus descendientes, a cualquier profundidad:
    • línea 36: [useCallback(fn, [dependencies])] pasa la MISMA función de una visualización a la siguiente (mientras las dependencias no cambien), en lugar de crear una nueva. Aquí no hay dependencias: [setLines] nunca cambia;
    • línea 41: el objeto suministrado solo se vuelve a crear si [lines] ha cambiado. Sin estas precauciones, el proveedor suministraría un objeto nuevo en cada visualización, y todos los componentes que leen el contexto serían llamados innecesariamente;
    • línea 44: a partir de [React] 19, el propio contexto es el componente proveedor (antes se escribía [<LogContext.Provider>]);
  • Líneas 48–55: un hook de lectura. [use(context)] ([React] 19; antes [useContext]) devuelve el valor del proveedor más cercano. El hook verifica que exista uno: un error claro es mejor que un [null] inesperado.

3.5.2. Un contexto proporcionado por un componente

// =========================================================================
// 14-contexts/src/contexts/cart.tsx - un contexto proporcionado por UN componente
// -------------------------------------------------------------------------
// El carrito solo se proporciona a una parte del árbol de componentes: los
// envueltos por <CartProvider> (cf. App.tsx). Dos proveedores colocados en
// dos lugares de la página darían dos carritos independientes.
// Un proveedor puede a su vez leer otros contextos: el carrito
// usa el registro.
// =========================================================================

import { createContext, use, useMemo, useState, type ReactNode } from 'react';
import { useLog } from './log';

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

interface Cart {
  items: Item[];
  total: number;
  add: (item: Item) => void;
  remove: (index: number) => void;
}

const CartContext = createContext<Cart | null>(null);

export function CartProvider({ children }: { children: ReactNode }) {
  const { trace } = useLog();
  const [items, setItems] = useState<Item[]>([]);

  const value = useMemo<Cart>(
    () => ({
      items,
      total: items.reduce((sum, a) => sum + a.price, 0),
      add: (item) => {
        setItems((a) => [...a, item]);
        trace(`cart: + ${item.label}`);
      },
      remove: (index) => {
        trace(`cart: - ${items[index].label}`);
        setItems((a) => a.filter((_, i) => i !== index));
      },
    }),
    [items, trace],
  );

  return <CartContext value={value}>{children}</CartContext>;
}

export function useCart(): Cart {
  const cart = use(CartContext);
  if (cart === null) {
    throw new Error('useCart must be used inside a <CartProvider>');
  }
  return cart;
}

El carrito de compras se proporciona solo a una parte del árbol de componentes: los que están dentro de [<CartProvider>]. Dos proveedores colocados en lugares distintos de la página darían como resultado dos carritos independientes.

  • Línea 29: un proveedor es un componente; puede a su vez leer otros contextos; el carrito de compras usa el registro;
  • Líneas 32–46: los datos ([items], [total]) y las acciones ([add], [remove]), que se recalculan cuando cambian los artículos.

3.5.3. Un contexto configurado

// =========================================================================
// 14-contexts/src/contexts/clock.tsx - un contexto PARAMETRIZADO
// -------------------------------------------------------------------------
// Un reloj, cuyo período de actualización es una prop del
// proveedor: <ClockProvider period={5000}>. Dos proveedores
// anidados: un componente lee el que está MÁS CERCA de él.
// El reloj se detiene cuando desaparece su proveedor (limpieza del efecto).
// =========================================================================

import { createContext, use, useEffect, useState, type ReactNode } from 'react';

// el valor por defecto: una fecha congelada, leída por un componente sin proveedor
const ClockContext = createContext<Date>(new Date());

export function ClockProvider({ period = 1000, children }: { period?: number; children: ReactNode }) {
  const [now, setNow] = useState(() => new Date());

  // [period]: si el padre cambia el período, el temporizador se reinicia
  useEffect(() => {
    const timer = setInterval(() => setNow(new Date()), period);
    return () => clearInterval(timer);
  }, [period]);

  return <ClockContext value={now}>{children}</ClockContext>;
}

export function useClock(): Date {
  return use(ClockContext);
}
  • línea 13: aquí, un verdadero valor predeterminado: una fecha fija;
  • línea 15: el período de actualización es una prop del proveedor;
  • líneas 19–22: el temporizador; si el padre cambia el período, el efecto se limpia y luego se reinicia.

3.5.4. Los componentes

// 14-contexts/src/Catalog.tsx - un descendiente que AGREGA al carrito
import { useCart, type Item } from './contexts/cart';

const CATALOG: Item[] = [
  { label: 'Consultation', price: 30 },
  { label: 'Vaccine', price: 12.5 },
  { label: 'Certificate', price: 5 },
];

export default function Catalog() {
  // el carrito proporcionado por App (error si nadie lo proporciona)
  const cart = useCart();

  return (
    <ul className="list-group">
      {CATALOG.map((a) => (
        <li key={a.label} className="list-group-item d-flex justify-content-between align-items-center">
          {a.label} (€{a.price})
          <button className="btn btn-sm btn-outline-primary" onClick={() => cart.add(a)}>Add</button>
        </li>
      ))}
    </ul>
  );
}

[useCart()]: el carrito de compras proporcionado por un padre (error si ningún padre lo proporciona).

// =========================================================================
// 14-contexts/src/CartSummary.tsx
// -------------------------------------------------------------------------
// Otro descendiente: el MISMO carrito que Catalog (proporcionado por App), pero
// SU PROPIO reloj, actualizado cada 5 segundos. Un componente solo lee
// los proveedores colocados POR ENCIMA de él: CartSummary coloca por lo tanto
// un segundo <ClockProvider> alrededor de su contenido, que confía a un
// pequeño componente, Content.
// =========================================================================

import { ClockProvider, useClock } from './contexts/clock';
import { useCart } from './contexts/cart';

function Content() {
  const cart = useCart();
  const now = useClock(); // el reloj más cercano: el de 5 s

  return (
    <div className="card p-3">
      <h2 className="h6">
        Cart ({cart.items.length} item(s)) - {now.toLocaleTimeString()}
      </h2>
      <ul className="mb-2">
        {cart.items.map((a, i) => (
          <li key={i}>
            {a.label}{' '}
            <button className="btn btn-link btn-sm p-0 align-baseline" onClick={() => cart.remove(i)}>remove</button>
          </li>
        ))}
      </ul>
      <strong>Total: €{cart.total}</strong>
    </div>
  );
}

export default function CartSummary() {
  return (
    <ClockProvider period={5000}>
      <Content />
    </ClockProvider>
  );
}
  • líneas 14–34: el contenido del resumen lee el carrito de compras Y el reloj. El reloj más cercano es el de 5 segundos;
  • líneas 36–42: un componente solo lee los proveedores colocados POR ENCIMA de él: [CartSummary] coloca por lo tanto su propio [<ClockProvider period={5000}>] alrededor de un subcomponente, [Content].
// =========================================================================
// 14-contexts/src/App.tsx - tres niveles de contextos
// -------------------------------------------------------------------------
//   - el registro: proporcionado en lo más alto (main.tsx), a toda la aplicación;
//   - el carrito, proporcionado por App: compartido por Catalog y CartSummary,
//     que ven el MISMO carrito;
//   - el reloj, proporcionado por App (período por defecto, 1 s) Y por
//     CartSummary (5 s): cada uno el suyo.
// =========================================================================

import Catalog from './Catalog';
import CartSummary from './CartSummary';
import { useLog } from './contexts/log';
import { ClockProvider, useClock } from './contexts/clock';
import { CartProvider } from './contexts/cart';

// la hora del reloj de App: un pequeño componente, colocado DEBAJO del proveedor
function AppTime() {
  return <p className="text-muted">Clock of App: {useClock().toLocaleTimeString()}</p>;
}

export default function App() {
  const log = useLog();

  return (
    <ClockProvider>
      <CartProvider>
        <div className="container py-4" style={{ maxWidth: 720 }}>
          <h1 className="h3 mb-3">Example 14 - contexts</h1>
          <AppTime />
          <div className="row g-3">
            <div className="col-md-6"><Catalog /></div>
            <div className="col-md-6"><CartSummary /></div>
          </div>
          <h2 className="h6 mt-3">Log (root context)</h2>
          <ul className="small">
            {log.lines.map((line, i) => <li key={i}>{line}</li>)}
          </ul>
        </div>
      </CartProvider>
    </ClockProvider>
  );
}
  • líneas 18–20: [App] proporciona el reloj; para leerlo, se necesita un componente colocado DEBAJO de él: [AppTime];
  • línea 23: [App] lee el registro, proporcionado más arriba;
  • Líneas 26–27: [App] proporciona el reloj (1 s) y el carrito a sus descendientes.

Y el proveedor del registro, colocado en la parte más alta:

// =========================================================================
// 14-contexts/src/main.tsx - el proveedor del registro envuelve a App: por lo
// tanto, está disponible en TODA la aplicación
// =========================================================================

import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App';
import { LogProvider } from './contexts/log';

createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <LogProvider>
      <App />
    </LogProvider>
  </StrictMode>,
);

Image

El reloj de [App] avanza cada segundo, mientras que el reloj del carrito de compras avanza cada cinco segundos. Ambos componentes ven el mismo carrito de compras, y el registro anota cada adición.

Un contexto basta para datos que rara vez cambian (el usuario conectado, el idioma, un tema) o que se aplican solo a una parte de la página. Cuando un estado se comparte en toda la aplicación y cambia con frecuencia, se prefiere un "store" (ejemplo 20).

3.6. Ejemplo 15: escribir sus propios hooks

Un componente reutiliza la vista; un hook personalizado reutiliza un comportamiento, junto con su estado. Es una función cuyo nombre comienza con [use] y que, a su vez, llama a hooks. Este ejemplo escribe dos de ellos, para los dos comportamientos que el ejemplo 15 del curso [Angular] asignaba a las directivas.

3.6.1. Resaltar un elemento al pasar el cursor

// =========================================================================
// 15-custom-hooks/src/hooks/useHover.ts
// -------------------------------------------------------------------------
// Un HOOK PERSONALIZADO es una función cuyo nombre empieza con "use" y
// que a su vez llama a hooks (useState, useEffect, useRef...). Permite
// reutilizar un COMPORTAMIENTO (con su estado) en varios
// componentes, como un componente reutiliza la visualización.
//
// Este resalta un elemento al pasar el cursor sobre él. Devuelve los atributos que se deben poner
// en el elemento: <li {...useHover('#d1e7dd')}>. Cada llamada tiene su
// propio estado: dos elementos resaltados no interfieren entre sí.
// =========================================================================

import { useState } from 'react';

export function useHover(color = '#fff3cd') {
  const [hovered, setHovered] = useState(false);
  return {
    style: { backgroundColor: hovered ? color : undefined, transition: 'background-color 0.2s' },
    onMouseEnter: () => setHovered(true),
    onMouseLeave: () => setHovered(false),
  };
}

El hook tiene su propio estado ([hovered]) y devuelve los atributos que se deben aplicar al elemento: un estilo y dos manejadores de eventos. Cada componente que lo llama tiene su propio estado: dos elementos resaltados no interfieren entre sí.

3.6.2. Clic largo

// =========================================================================
// 15-custom-hooks/src/hooks/useLongPress.ts
// -------------------------------------------------------------------------
//     const longPress = useLongPress(() => remove(m), 1000);
//     <button {...longPress.handlers} className={longPress.pressing ? 'press' : ''}>
// La acción solo se ejecuta si el botón se mantiene presionado durante un
// segundo: una protección contra clics accidentales. pressing indica si hay una
// pulsación en curso (para mostrarla).
// El temporizador se detiene si el componente desaparece durante una pulsación.
// =========================================================================

import { useEffect, useRef, useState } from 'react';

export function useLongPress(action: () => void, duration = 1000) {
  const [pressing, setPressing] = useState(false);
  // un valor que sobrevive a las visualizaciones SIN provocarlas: useRef
  const timer = useRef<number | undefined>(undefined);

  // cuando se elimina el componente: ningún temporizador huérfano
  useEffect(() => () => clearTimeout(timer.current), []);

  function start() {
    setPressing(true);
    timer.current = window.setTimeout(() => {
      setPressing(false);
      action();
    }, duration);
  }

  function stop() {
    clearTimeout(timer.current);
    setPressing(false);
  }

  return {
    pressing,
    handlers: { onPointerDown: start, onPointerUp: stop, onPointerLeave: stop },
  };
}
  • línea 17: el identificador del temporizador, un valor que debe persistir entre visualizaciones pero que no se muestra: una referencia;
  • línea 20: un efecto sin acción, que solo se encarga de la limpieza: si el componente desaparece mientras se mantiene presionado el botón, el temporizador se detiene;
  • líneas 22–28: la acción se ejecuta solo si el botón se mantiene presionado durante un segundo: una protección contra clics accidentales;
  • líneas 35–38: el hook devuelve el estado ([pressing], para mostrarlo) y los manejadores de eventos del puntero (mouse, dedo o lápiz).

3.6.3. Dar el foco

// =========================================================================
// 15-custom-hooks/src/hooks/autofocus.ts - un "ref callback"
// -------------------------------------------------------------------------
// ref={función}: React llama a la función con el elemento HTML en cuanto
// se coloca en la página (y, en React 19, llama a la función que
// esta pueda devolver cuando se elimina de ella). No es un hook:
// es una simple función, reutilizable en todas partes:
//     <input ref={autofocus} />
// (React también maneja el atributo autoFocus, que hace lo mismo.)
// =========================================================================

export function autofocus(element: HTMLElement | null): void {
  element?.focus();
}

Una ref callback: se puede asignar una función al atributo [ref], a la que [React] llama con el elemento HTML en cuanto se coloca en la página. No es un hook, sino una simple función.

3.6.4. Uso

// =========================================================================
// 15-custom-hooks/src/App.tsx - reutilizar comportamientos
// -------------------------------------------------------------------------
// Los hooks solo se llaman en el NIVEL SUPERIOR de un componente (nunca en
// un bucle, una condición o una función anidada): React
// los reconoce por su ORDEN de llamada. Para un comportamiento por cada fila de una
// lista, escribimos por lo tanto un pequeño componente por fila, que llama a sus hooks.
// =========================================================================

import { useState } from 'react';
import { useHover } from './hooks/useHover';
import { useLongPress } from './hooks/useLongPress';
import { autofocus } from './hooks/autofocus';

// el estilo del botón durante una pulsación larga
const pressStyle = { outline: '4px solid #dc3545' };

// una fila de la lista: llama a SUS hooks
function DoctorRow({ name, even, onRemove }: { name: string; even: boolean; onRemove: () => void }) {
  // una fila de cada dos: el color por defecto; las demás, verdes
  const hover = useHover(even ? undefined : '#d1e7dd');
  const longPress = useLongPress(onRemove, 1000);

  return (
    <li className="list-group-item d-flex justify-content-between align-items-center" {...hover}>
      {name}
      <button className="btn btn-sm btn-outline-danger" style={longPress.pressing ? pressStyle : undefined}
              {...longPress.handlers}>
        Delete (long press)
      </button>
    </li>
  );
}

export default function App() {
  const [doctors, setDoctors] = useState(['Mme Marie PELISSIER', 'Mr Paul TATOU', 'Melle Sophie DUPONT']);
  const [message, setMessage] = useState('');

  function remove(name: string) {
    setDoctors((m) => m.filter((x) => x !== name));
    setMessage(`${name} has been deleted.`);
  }

  return (
    <div className="container py-4" style={{ maxWidth: 640 }}>
      <h1 className="h3 mb-3">Example 15 - writing your own hooks</h1>
      <input ref={autofocus} className="form-control mb-3" placeholder="this field received the focus on its own" />

      <p className="small text-muted">Hover over the rows; hold a button down for one second to delete.</p>
      <ul className="list-group mb-3">
        {doctors.map((m, i) => (
          <DoctorRow key={m} name={m} even={i % 2 === 0} onRemove={() => remove(m)} />
        ))}
      </ul>
      {message && <p className="alert alert-info">{message}</p>}
    </div>
  );
}

Los hooks siguen una regla estricta: solo se llaman en el nivel superior de un componente o de otro hook, nunca dentro de un bucle, una condición o una función anidada. [React] identifica cada [useState] por su orden de llamada: si el orden cambiara de una visualización a otra, los estados se mezclarían.

  • Líneas 19–33: para un comportamiento línea por línea en una lista, no se pueden llamar los hooks directamente en [map]; en su lugar, se escribe un pequeño componente para cada línea que llame a SUS hooks;
  • Línea 25: los atributos de la información sobre herramientas, esparcidos sobre la línea;
  • línea 28: los manejadores de clic largo del botón y su estilo mientras está presionado;
  • línea 47: la referencia callback;
  • Línea 52: una línea por médico.

Al iniciar, el campo tiene el foco. Mantenga presionado el segundo botón:

Image

Luego, una vez transcurrido un segundo:

Image

Los hooks personalizados son la principal forma de reutilizar código en [React]. Las bibliotecas proporcionan muchos: [useForm] (ejemplo 08), [useNavigate] (ejemplo 17), [useTranslation] (ejemplo 21), [useQuery] (ejemplo 24)...

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

“¿Está seguro?”: [window.confirm()] existe, pero sus botones no se pueden formatear ni traducir. Se reemplaza por una ventana [Bootstrap] controlada por un contexto.

3.7.1. El contexto

// =========================================================================
// 16-confirmation/src/confirmation/confirmation.tsx
// -------------------------------------------------------------------------
// "¿Está seguro?": window.confirm() existe, pero no se le puede
// dar estilo ni se pueden traducir sus botones. Se reemplaza por un cuadro de diálogo
// de Bootstrap, controlado por un contexto (cf. ejemplo 14).
//
// El truco: confirm(mensaje) devuelve una PROMESA, resuelta a true (Sí)
// o false (No) cuando el usuario responde. El código que llama se escribe entonces
// tan simplemente como con window.confirm:
//
//     const confirm = useConfirmation();
//     if (await confirm('Delete this doctor?')) { ... }
//
// El proveedor muestra el cuadro de diálogo él mismo: solo hay que colocarlo
// una vez, alrededor de toda la aplicación (cf. main.tsx).
// =========================================================================

import { createContext, use, useCallback, useRef, useState, type ReactNode } from 'react';
import ConfirmDialog from './ConfirmDialog';

type Confirm = (message: string) => Promise<boolean>;

const ConfirmationContext = createContext<Confirm | null>(null);

export function ConfirmationProvider({ children }: { children: ReactNode }) {
  const [message, setMessage] = useState<string | null>(null); // null: cuadro de diálogo cerrado
  // la función que resolverá la promesa actual: no se muestra,
  // por lo tanto es una referencia y no un estado
  const answer = useRef<((yes: boolean) => void) | null>(null);

  const confirm = useCallback<Confirm>((text) => {
    answer.current?.(false); // ¿una pregunta aún abierta? significa "no"
    setMessage(text);
    return new Promise<boolean>((resolve) => {
      answer.current = resolve;
    });
  }, []);

  function respond(yes: boolean) {
    setMessage(null);
    const r = answer.current;
    answer.current = null;
    r?.(yes);
  }

  return (
    <ConfirmationContext value={confirm}>
      {children}
      {message !== null && <ConfirmDialog message={message} onAnswer={respond} />}
    </ConfirmationContext>
  );
}

export function useConfirmation(): Confirm {
  const confirm = use(ConfirmationContext);
  if (confirm === null) {
    throw new Error('useConfirmation must be used inside a <ConfirmationProvider>');
  }
  return confirm;
}

Consejo: [confirm(message)] devuelve una promesa, que se resuelve con [true] (Sí) o [false] (No) cuando el usuario responde. El código que la llama es entonces tan simple como con [window.confirm]: [if (await confirm('Delete this doctor?')) {...}].

  • Línea 22: lo que el contexto proporciona: una función;
  • línea 27: el mensaje mostrado; [null]: la ventana está cerrada;
  • línea 30: la función que resolverá la promesa en curso. No se muestra: es una referencia, no un estado;
  • Líneas 32–38: abren la ventana y devuelven una promesa cuya función se conserva en [resolve]. Una pregunta sin respuesta se trata como “no”;
  • líneas 40–45: la respuesta: cierra la ventana y resuelve la promesa;
  • línea 50: el proveedor muestra la ventana por sí mismo cuando hay una pregunta.

3.7.2. La ventana

// =========================================================================
// 16-confirmation/src/confirmation/ConfirmDialog.tsx
// -------------------------------------------------------------------------
// El cuadro de diálogo modal:
//   - mismas clases de Bootstrap que un modal real (.modal, .modal-backdrop),
//     mostrado "a la fuerza" (show d-block): no se necesita el JavaScript
//     de Bootstrap;
//   - createPortal: el cuadro se coloca al final de <body>, y no donde
//     está escrito el componente. Así escapa a los estilos de sus
//     ancestros (overflow, z-index...), a la vez que sigue siendo un componente
//     React ordinario (props, eventos);
//   - teclado: Escape = No; el foco se coloca en el botón "No" (la
//     opción menos peligrosa) al abrirse.
// =========================================================================

import { useEffect } from 'react';
import { createPortal } from 'react-dom';

interface Props {
  message: string;
  onAnswer: (yes: boolean) => void;
}

export default function ConfirmDialog({ message, onAnswer }: Props) {
  // Escape, en cualquier parte de la página: un oyente colocado en el DOCUMENT
  // al abrirse y eliminado al cerrarse (limpieza del efecto)
  useEffect(() => {
    const onKeydown = (e: KeyboardEvent) => {
      if (e.key === 'Escape') onAnswer(false);
    };
    document.addEventListener('keydown', onKeydown);
    return () => document.removeEventListener('keydown', onKeydown);
  }, [onAnswer]);

  return createPortal(
    <>
      <div className="modal-backdrop fade show"></div>
      {/* un clic en el fondo (y no en el cuadro de diálogo) significa "no" */}
      <div className="modal fade show d-block" tabIndex={-1} role="alertdialog" aria-modal="true"
           onClick={(e) => e.target === e.currentTarget && onAnswer(false)}>
        <div className="modal-dialog modal-dialog-centered">
          <div className="modal-content">
            <div className="modal-header">
              <h5 className="modal-title">Confirmation</h5>
              <button type="button" className="btn-close" aria-label="Close" onClick={() => onAnswer(false)}></button>
            </div>
            <div className="modal-body">
              <p className="mb-0">{message}</p>
            </div>
            <div className="modal-footer">
              {/* autoFocus: React da el foco a este botón cuando aparece */}
              <button type="button" className="btn btn-secondary" autoFocus onClick={() => onAnswer(false)}>No, go back</button>
              <button type="button" className="btn btn-danger" onClick={() => onAnswer(true)}>Yes, confirm</button>
            </div>
          </div>
        </div>
      </div>
    </>,
    document.body,
  );
}
  • líneas 27–33: la tecla Esc, en cualquier parte de la página: un listener asociado a DOCUMENT cuando se abre la ventana y eliminado cuando se cierra (limpieza). Esta es típicamente la tarea de un efecto: conectarse a algo externo a [React];
  • línea 35: [createPortal(jsx, element)] muestra JSX en un lugar distinto de donde está escrito el componente: aquí, al final de [<body>]. Así, la ventana evita los estilos de sus ancestros ([overflow], [z-index]...), a la vez que sigue siendo un componente [React] normal (props, eventos);
  • líneas 37–39: las clases de [Bootstrap] de una verdadera ventana modal, escritas directamente en el código ([show d-block]): no se necesita el [JavaScript] de [Bootstrap];
  • línea 40: un clic en el fondo (fuera de la ventana) cuenta como “No”;
  • línea 52: [React] da el foco al botón “No” (la opción más segura) cuando aparece la ventana.

3.7.3. Uso

// =========================================================================
// 16-confirmation/src/App.tsx - uso del cuadro de diálogo de confirmación
// -------------------------------------------------------------------------
// 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 { useState } from 'react';
import { useConfirmation } from './confirmation/confirmation';

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

export default function App() {
  const confirm = useConfirmation();
  const [contacts, setContacts] = useState<Contact[]>([
    { id: 1, name: 'Jean MARTIN' },
    { id: 2, name: 'Alice DURAND' },
    { id: 3, name: 'Luc GERMAN' },
  ]);
  const [message, setMessage] = useState('');

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

  async function removeAll() {
    if (await confirm(`Delete the ${contacts.length} contacts?`)) {
      setContacts([]);
      setMessage('All the contacts have been deleted.');
    }
  }

  return (
    <div className="container py-4" style={{ maxWidth: 640 }}>
      <h1 className="h3 mb-3">Example 16 - a confirmation dialog</h1>
      <ul className="list-group mb-3">
        {contacts.map((c) => (
          <li key={c.id} className="list-group-item d-flex justify-content-between align-items-center">
            {c.name}
            <button className="btn btn-sm btn-outline-danger" onClick={() => remove(c)}>Delete</button>
          </li>
        ))}
        {contacts.length === 0 && <li className="list-group-item text-muted">No contacts.</li>}
      </ul>
      <button className="btn btn-danger" disabled={contacts.length === 0} onClick={removeAll}>Delete all</button>
      {message && <p className="alert alert-info mt-3">{message}</p>}
    </div>
  );
}
  • línea 17: la función de confirmación;
  • líneas 26–33: una función [async]: “espera” ([await]) la respuesta del usuario sin bloquear la página.
import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App';
import { ConfirmationProvider } from './confirmation/confirmation';

// el cuadro de diálogo de confirmación, UNA vez para toda la aplicación
createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <ConfirmationProvider>
      <App />
    </ConfirmationProvider>
  </StrictMode>,
);

Se usa UNA SOLA ventana para toda la aplicación: su proveedor envuelve a [App].

Image

Confirme y luego solicite otra eliminación y presione Esc:

Image