Skip to content

3. Componentes

3.1. Exemplo 10: Componentes e suas props

Um componente é um pedaço reutilizável da interface do usuário. Este exemplo cria um, [DoctorCard], e o utiliza várias vezes.

3.1.1. Tipo de dados

1
2
3
4
5
6
7
8
9
// o tipo dos dados compartilhados pelo pai (App) e pelo filho (DoctorCard)
export interface Doctor {
  id: number;
  title: string;
  firstName: string;
  lastName: string;
  specialty: string;
  available: boolean;
}

O tipo [Doctor] é compartilhado pelo pai e pelo filho: ele fica em um módulo separado.

3.1.2. O filho

// =========================================================================
// 10-components/src/DoctorCard.tsx - um componente FILHO
// -------------------------------------------------------------------------
// Ele recebe seus dados do pai por meio de PROPS (propriedades): os
// atributos escritos pelo pai em <DoctorCard ... />, reunidos pelo
// React em UM objeto, primeiro parâmetro da função. Seu tipo é
// verificado em tempo de compilação: <DoctorCard doctor={42} /> seria rejeitado.
//
// Regra de ouro: um componente NUNCA MODIFICA suas props. Os dados
// fluem do pai para o filho; para pedir uma mudança,
// o filho chama uma função que o pai lhe passou (cf. exemplo 11).
// =========================================================================

import type { Doctor } from './doctor';
// styles: um objeto { initials: '_initials_x7f3a_1' } - o nome real de cada classe
import styles from './DoctorCard.module.css';

// o tipo das props: o que o pai PODE (?) ou DEVE fornecer
interface Props {
  doctor: Doctor;
  rank: number;
  compact?: boolean; // opcional
}

// o objeto props é "desestruturado"; compact = false: seu valor padrão
export default function DoctorCard({ doctor, rank, compact = false }: Props) {
  // um valor calculado a partir das props: recalculado se o pai as mudar
  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>
  );
}
  • linha 14: uma importação somente de tipo;
  • linha 16: uma importação do módulo CSS (veja abaixo);
  • linhas 19–23: os tipos das props do componente — os atributos que o pai escreve em [<DoctorCard ... />]. [compact?] é opcional;
  • linha 26: o [React] combina as props em UM objeto, que passa como primeiro parâmetro da função. Ele é imediatamente “desempacotado”: [{ doctor, rank, compact = false }] gera três variáveis, com [compact] igual a [false] se o pai não o fornecer. O tipo das props é verificado em tempo de compilação: [<DoctorCard doctor={42} />] seria rejeitado, assim como a omissão de [rank];
  • linha 28: um valor calculado a partir das props: se o pai mudar as props, o componente é reexecutado e o valor é recalculado;
  • linha 33: a classe CSS, lida do módulo CSS;
  • linha 36: a especialidade é exibida apenas no modo normal.

Regra de ouro: um componente nunca modifica suas próprias props. Os dados fluem do pai para o filho; para solicitar uma mudança, o filho chama uma função que o pai lhe passou (veja o Exemplo 11).

3.1.3. Um módulo CSS

/* um "módulo CSS" (arquivo *.module.css): o Vite renomeia cada classe
   (.initials -> ._initials_x7f3a_1); ela só pode, portanto, se aplicar aos
   elementos do componente que o 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;
}

Um arquivo cujo nome termina em [.module.css] é um módulo CSS: o [Vite] renomeia cada uma de suas classes ([.initials] torna-se, por exemplo, [._initials_x7f3a_1]) e, na importação, fornece um objeto que associa o nome original ao nome real: [styles.initials]. A classe só pode, portanto, ser aplicada a elementos do componente que a importa: isso equivale ao encapsulamento de estilos do [Angular]. As classes do [Bootstrap], que são globais, continuam utilizáveis em qualquer lugar.

3.1.4. O pai

// =========================================================================
// 10-components/src/App.tsx - o componente PAI
// -------------------------------------------------------------------------
// Ele importa o componente DoctorCard e o usa como uma nova
// tag, <DoctorCard />, quantas vezes for preciso: um componente é
// um pedaço REUTILIZÁVEL de interface, com seus próprios dados, seu JSX e
// seu estilo. Uma tag que começa com letra MAIÚSCULA é um componente;
// em minúscula (<div>, <p>), é um 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);

  // o pai modifica SEUS dados: o React chama o pai de novo, depois os
  // filhos, com suas novas 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} passa o OBJETO m (uma expressão);
                doctor="m", sem chaves, passaria a STRING "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, sem valor, é true */}
        <DoctorCard doctor={doctors[0]} rank={1} compact />
      </div>
    </div>
  );
}
  • linha 12: o componente filho é importado como qualquer outro módulo;
  • linhas 25–27: o pai modifica SEUS dados. O [React] o reexecuta e depois reexecuta os filhos com suas novas props: os cartões são atualizados;
  • linha 44: o componente é usado como uma nova tag. [doctor={m}] passa o OBJETO [m] (uma expressão); [doctor="m"], sem chaves, passaria a STRING “m”;
  • linha 51: um atributo sem valor ([compact]) é igual a [true].

Image

Marcando “compact display” e depois invertendo as configurações de disponibilidade:

Image

3.2. Exemplo 11: O filho notifica o pai

Os dados fluem para baixo pelas props. Para enviar informações de volta para cima, o pai passa funções ao filho, que as chama.

3.2.1. “Eventos” do filho

// =========================================================================
// 11-lifting-state-up/src/Counter.tsx
// -------------------------------------------------------------------------
// Um filho que NOTIFICA seu pai: o pai lhe passa FUNÇÕES
// nas props (por convenção, seu nome começa com "on"), e o filho
// as chama quando algo acontece:
//     <Counter label="Coffees" max={3} onIncrement={...} onLimit={...} />
// =========================================================================

import { useState } from 'react';

interface Props {
  label: string;
  max: number;
  onIncrement: (value: number) => void; // com o novo valor
  onLimit: () => void; // sem dados
}

export default function Counter({ label, max, onIncrement, onLimit }: Props) {
  // o estado PRÓPRIO deste contador: cada <Counter> tem o seu
  const [value, setValue] = useState(0);

  function plus() {
    if (value >= max) {
      onLimit();
      return;
    }
    setValue(value + 1);
    // value ainda não foi modificado (será na próxima chamada do
    // componente): value + 1 é passado
    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>
  );
}
  • Linhas 12–17: duas props são funções: [onIncrement] recebe o novo valor, enquanto [onLimit] não recebe nada. Por convenção, seus nomes começam com “on”, como [onClick];
  • Linha 21: o estado PRÓPRIO deste contador: cada [<Counter>] da página tem o seu. O estado está associado à posição do componente na árvore da página;
  • linhas 23–32: o pai é notificado. Atenção: [setValue(value + 1)] não altera a variável [value] (uma constante fixada para ESTA chamada do componente): ela será [value + 1] na PRÓXIMA chamada. Por isso, [value + 1] é passado ao pai.

3.2.2. Um componente controlado

// =========================================================================
// 11-lifting-state-up/src/TextField.tsx - um componente CONTROLADO
// -------------------------------------------------------------------------
// Um campo de formulário "caseiro" (rótulo + campo + ajuda + contador de
// caracteres) usado como um <input> controlado (cf. exemplo 05):
//     <TextField value={lastName} onChange={setLastName} label="Last name" max={20} />
// O componente NÃO tem estado: o valor pertence ao pai, que o passa
// (value) e que ele notifica a cada tecla digitada (onChange). É o
// pai que decide o novo 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: um identificador ÚNICO, diferente para cada <TextField> da
  // página, para ligar <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>
  );
}

Um campo de formulário “personalizado” (rótulo, campo, dica, contador de caracteres) usado como um [<input>] controlado (veja o Exemplo 05): o pai lhe passa o valor ([value]) e uma função chamada a cada tecla digitada ([onChange]).

  • linhas 14–20: as props; [help] é opcional;
  • linha 25: [useId()] fornece um identificador único, diferente para cada [<TextField>] da página, para vincular [<label htmlFor>] e [<input id>];
  • linha 31: cada tecla digitada chama a função do pai com o novo texto.

O componente não tem estado: o valor pertence ao pai, que determina o novo valor. É o que se chama de “elevar o estado” (lifting state up): os dados compartilhados por vários componentes são armazenados no ancestral comum mais próximo.

3.2.3. O pai

// =========================================================================
// 11-lifting-state-up/src/App.tsx - o pai escuta seus filhos
// -------------------------------------------------------------------------
// Os dados fluem para baixo (props); a informação sobe por meio de
// funções passadas nas props:
//   1. "eventos" do filho: onIncrement, onLimit;
//   2. um componente controlado: value + onChange, como um <input>. O estado
//      continua sendo propriedade do pai, que pode modificá-lo ele mesmo (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');

  // a função chamada por um contador: ela recebe o valor que ele passa
  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}: a função do estado, passada como está */}
        <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>
  );
}
  • linhas 22–25: a função chamada por um contador; ela recebe o valor que o contador lhe passa;
  • linhas 38–39: o pai passa funções arrow, que acrescentam o rótulo do contador;
  • linha 48: [onChange={setFirstName}]: a função de estado é passada como está; o filho a chama com o novo texto;
  • linha 51: o próprio pai modifica os valores; os campos acompanham.

Clique duas vezes, depois quatro vezes no primeiro “+1”, uma vez no segundo e digite “Dupont” no campo Last name:

Image

3.3. Exemplo 12: Composição

As props passam dados... mas também conteúdo: "JSX" é um valor como qualquer outro (como "[ReactNode]"), que pode ser passado a um componente, e o componente pode colocá-lo onde quiser.

3.3.1. Um cartão

// =========================================================================
// 12-composition/src/Card.tsx - um TEMPLATE reutilizável
// -------------------------------------------------------------------------
// As props passam DADOS... mas também CONTEÚDO: o JSX é
// um valor como outro qualquer (do tipo ReactNode), que pode ser passado a um
// componente e que ele coloca onde quiser:
//   - children: a prop especial que recebe o que o pai escreve ENTRE
//                <Card> e </Card> - o conteúdo "principal";
//   - header, footer: outros espaços reservados, fornecidos pelo pai na
//                forma de props; header tem um conteúdo padrão.
// O card define a moldura (borda, cabeçalho, rodapé), o pai fornece o que
// está dentro. É o equivalente, no lado do cliente, do template layout.hbs
// e de seu {{{body}}} no 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>
      {/* nenhum footer fornecido: nenhum rodapé */}
      {footer && <div className="card-footer text-muted small">{footer}</div>}
    </div>
  );
}
  • linhas 18–23: [header], [footer] e [children] são [ReactNode]: JSX, texto, um número ou nada;
  • linha 25: conteúdo padrão;
  • linha 29: [children] é uma propriedade especial: ela recebe tudo o que o pai escreve ENTRE [<Card>] e [</Card>] — o conteúdo “principal”;
  • linha 31: nenhum rodapé fornecido — nenhum rodapé é exibido.

O template define a moldura (borda, cabeçalho, rodapé); o pai fornece o conteúdo dentro dela: isso equivale à projeção de conteúdo do [Angular] ([<ng-content>]) e aos “slots” do [Vue.js]e, no lado do servidor, ao template [layout.hbs] e seu [{{{body}}}] no curso [NestJS].

3.3.2. Uma tabela genérica

// =========================================================================
// 12-composition/src/DataTable.tsx - uma tabela GENÉRICA
// -------------------------------------------------------------------------
// DataTable<T> é um componente genérico: ele exibe linhas de
// qualquer tipo T. Sabe percorrer as linhas, mas não como
// exibir UMA linha: é o pai que lhe diz, passando-lhe uma
// FUNÇÃO, renderRow(row, index), que retorna o JSX das células.
// É o que se chama de "render prop": o conteúdo fornecido pelo
// pai usa dados que pertencem ao filho (a linha, sua
// posição).
// =========================================================================

import type { ReactNode } from 'react';

interface Props<T> {
  rows: T[];
  columns: string[];
  renderRow: (row: T, index: number) => ReactNode;
  empty?: ReactNode; // exibido quando não há nenhuma linha
}

// <T extends { id: number }>: cada linha deve ter um id (a key)
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>
  );
}
  • linhas 15–20: um tipo genérico: as props de um array de linhas do tipo [T], sejam elas quais forem;
  • linha 18: uma prop que é uma função que retorna JSX: a tabela sabe percorrer as linhas, mas não sabe exibir UMA linha; o pai lhe diz como. Esse procedimento é chamado de “render prop”;
  • linha 23: um componente genérico: [T] é inferido em tempo de execução a partir do tipo das linhas. Cada linha deve ter um [id], que serve como chave;
  • linha 37: para cada linha, a tabela chama a função do pai, passando-lhe os dados que lhe pertencem (a linha, seu índice).

3.3.3. O pai

// =========================================================================
// 12-composition/src/App.tsx - usando os templates Card e 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 e footer: JSX passado nas props; entre as tags: children */}
      <Card color="primary" header={<span>Schedule of Mme PELISSIER</span>} footer={`${free} free slot(s)`}>
        {/* DataTable<Slot>: T é deduzido do tipo das linhas */}
        <DataTable
          rows={slots}
          columns={['#', 'Slot', 'Status']}
          // a "render prop": como exibir UMA linha; c recebe a linha, i sua posição
          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>

      {/* nenhum header fornecido: o conteúdo padrão, "Untitled" */}
      <Card>
        <DataTable<{ id: number; name: string }>
          rows={[]}
          columns={['Name']}
          renderRow={(p) => <td>{p.name}</td>}
          empty={<span>Nobody for now.</span>}
        />
      </Card>
    </div>
  );
}
  • Linha 28: [header] e [footer] recebem dados de JSX ou texto; o [<DataTable>] escrito entre as tags torna-se o [children] do cartão;
  • Linhas 34–43: a render prop: como exibir UMA linha; [c] recebe a linha (do tipo [Slot], derivado de [rows]), com [i] como sua posição;
  • Linha 56: com uma lista vazia, o [TypeScript] não consegue deduzir [T]: ele é fornecido explicitamente;
  • linha 60: o conteúdo exibido quando não há linhas.

Image

3.4. Exemplo 13: O ciclo de vida de um componente

3.4.1. Um relógio

// =========================================================================
// 13-lifecycle/src/Clock.tsx - um componente que inicia e para
// -------------------------------------------------------------------------
// A vida de um componente:
//   1. ele é EXIBIDO (montado): o React chama a função e coloca seu
//      resultado na página; depois executa seus efeitos (useEffect);
//   2. ele é ATUALIZADO, quantas vezes for preciso (seu estado ou suas
//      props mudam);
//   3. ele é REMOVIDO da página (desmontado): o React executa a LIMPEZA de
//      seus efeitos, a função que cada efeito retornou.
// Um relógio inicia um timer (setInterval) quando aparece... e
// deve obrigatoriamente pará-lo quando desaparece: caso contrário o timer
// continuaria rodando à toa (vazamento de memória).
// =========================================================================

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: uma função chamada POR um efeito, que sempre lê
  // as props mais recentes, sem ser uma dependência do efeito. Sem
  // isso, onLog teria de ser colocada nas dependências [...] abaixo,
  // e, como o pai passa uma função NOVA a cada exibição, o
  // timer seria parado e reiniciado a cada segundo
  const log = useEffectEvent((message: string) => onLog(message));

  // []: nenhuma dependência. O efeito roda UMA vez, após a primeira
  // exibição; a função que ele retorna, UMA vez, quando o componente é removido
  useEffect(() => {
    log('Clock: effect - starting the timer');
    const timer = setInterval(() => setTime(new Date().toLocaleTimeString()), 1000);
    // a LIMPEZA
    return () => {
      clearInterval(timer);
      log('Clock: cleanup - timer stopped');
    };
  }, []);

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

O ciclo de vida de um componente (linhas 4–10): ele é montado (exibido pela primeira vez), atualizado quantas vezes for necessário e, depois, desmontado (removido da página). O [React] não tem métodos separados para cada etapa: tudo passa por [useEffect].

  • Linhas 34–42: [useEffect(effect, [])]: com um array de dependências VAZIO, o efeito é executado uma única vez, após a primeira exibição. A função que ele retorna (linhas 38–41) cuida da limpeza: o [React] a executa quando o componente é removido da página (e antes de cada nova execução do efeito, quando suas dependências mudam). Um relógio inicia um timer ([setInterval]) na inicialização... e deve pará-lo ([clearInterval]) quando desaparece: caso contrário, o timer continuaria rodando à toa e tentaria modificar o estado de um componente que não existe mais;
  • Linha 30: o efeito chama a função [onLog] do pai. A rigor, ele deveria incluí-la em suas dependências: como o efeito usa uma prop, ele precisa ser reativado se a prop mudar. Porém, o pai cria uma função NOVA a cada exibição: o timer seria parado e reiniciado continuamente. [useEffectEvent] ([React] 19.2) cria uma função que sempre chama a versão mais recente de [onLog], sem ser uma dependência do efeito. Ela só pode ser chamada de dentro de um efeito.

3.4.2. O pai

// =========================================================================
// 13-lifecycle/src/App.tsx
// -------------------------------------------------------------------------
//   - {withClock && <Clock />}: marcar / desmarcar a caixa exibe /
//     remove o componente (efeito, depois limpeza, cf. Clock.tsx);
//   - useRef: uma referência ao elemento <input>, null enquanto ele não for
//     exibido; um efeito lhe dá o foco assim que ele aparece;
//   - um efeito que SINCRONIZA o título da aba com o input.
//
// Em desenvolvimento, o StrictMode (cf. main.tsx) monta cada componente,
// desmonta e em seguida remonta imediatamente: o log mostra, portanto, start,
// stop, start. É intencional: um efeito cuja limpeza está mal escrita
// (um timer nunca parado) se denuncia na hora. Em produção, o
// componente é montado apenas uma 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}`]);
  }

  // após a primeira exibição de App (duas vezes em desenvolvimento: StrictMode)
  useEffect(() => {
    trace('App: effect of the first display');
  }, []);

  // o campo acabou de aparecer: ele recebe o foco
  useEffect(() => {
    if (showSearch) {
      field.current?.focus();
    }
  }, [showSearch]);

  // o título da aba acompanha o input, desde o início
  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>
  );
}
  • linha 25: uma referência ao campo de busca, [null], enquanto ele não estiver exibido;
  • linhas 32–34: o efeito da primeira exibição de [App];
  • linhas 37–41: quando o campo aparece, ele recebe o foco: o efeito é executado DEPOIS da exibição, quando o elemento existe e a referência aponta para ele;
  • linhas 44–46: um efeito que sincroniza o título da aba com o estado;
  • linha 57: marcar/desmarcar a caixa exibe/oculta o relógio.

Na inicialização, o log é surpreendente: o relógio inicia, para e reinicia, e o efeito [App] é executado duas vezes. Isso é obra do [<StrictMode>] (veja [main.tsx]): apenas em desenvolvimento, o [React] monta cada componente, desmonta-o e o remonta imediatamente para verificar se seus efeitos sabem limpar após si mesmos. Um efeito mal escrito (como um timer que nunca para) é assim revelado de imediato: o relógio avançaria dois segundos por vez. Em produção, o componente é montado uma única vez. Observamos também que os efeitos dos filhos (o relógio) são executados ANTES dos do pai.

Depois, desmarque e marque a caixa novamente e digite “pediatrician” no campo de busca:

Image

Os efeitos são a parte mais delicada do [React]. Uma regra orienta seu uso: um efeito sincroniza o componente com algo fora do [React] (o título da aba, um timer, um ouvinte de evento do documento, um servidor). Para calcular um valor a partir de outro, use uma variável (Exemplo 02), não um efeito. Para responder a uma ação do usuário, use um tratador de evento, não um efeito.

3.5. Exemplo 14: Contextos

Como compartilhar dados e funções entre componentes distantes sem passá-los de prop em prop por todos os intermediários? Com um contexto. É assim que o [React] compartilha o que o [Angular] guarda em seus serviços, fornecidos por injeção de dependência.

3.5.1. Um contexto para toda a aplicação

// =========================================================================
// 14-contexts/src/contexts/log.tsx - um contexto para TODA a aplicação
// -------------------------------------------------------------------------
// Como compartilhar dados e funções entre componentes distantes,
// sem passá-los de props em props por todos os
// intermediários? Com um CONTEXTO:
//   1. createContext(defaultValue) cria o contexto;
//   2. um componente PROVIDER, <LogContext value={...}>, dá seu
//      valor a TODOS os seus descendentes, em qualquer profundidade;
//   3. um descendente o LÊ com use(LogContext) (ou useContext).
// Quando o valor fornecido muda, todos os componentes que o leem são
// chamados de novo.
//
// O costume: um arquivo por contexto, que exporta o provider (um
// componente que guarda o estado) e um HOOK para lê-lo (useLog).
// É assim que o React compartilha o que o Angular guarda em seus serviços.
// =========================================================================

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

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

// null: o valor lido se NENHUM provider envolver o componente
const LogContext = createContext<Log | null>(null);

// o provider: ele guarda o estado e o fornece a seus descendentes
export function LogProvider({ children }: { children: ReactNode }) {
  const [lines, setLines] = useState<string[]>([]);

  // useCallback: a MESMA função de uma exibição para a seguinte (e não
  // uma nova a cada vez), para que os componentes que a recebem
  // não pareçam ter mudado
  const trace = useCallback((message: string) => {
    setLines((l) => [`${new Date().toLocaleTimeString()} ${message}`, ...l].slice(0, 6));
  }, []);

  // useMemo: um novo objeto somente se lines mudou
  const value = useMemo(() => ({ lines, trace }), [lines, trace]);

  // React 19: o próprio contexto é o componente provider
  return <LogContext value={value}>{children}</LogContext>;
}

// o hook de leitura: um nome que começa com "use"
export function useLog(): Log {
  // use(context): o valor fornecido pelo provider MAIS PRÓXIMO
  const log = use(LogContext);
  if (log === null) {
    throw new Error('useLog must be used inside a <LogProvider>');
  }
  return log;
}
  • linhas 21–24: o que o contexto fornece: dados e uma função;
  • linha 27: [createContext(defaultValue)] cria o contexto. [null]: o valor lido por um componente que não está envolvido por nenhum provider;
  • linhas 30–45: o provider: um componente que contém o estado e o repassa a todos os seus descendentes, em qualquer profundidade:
    • linha 36: [useCallback(fn, [dependencies])] passa a MESMA função de uma exibição para a seguinte (enquanto as dependências não mudarem), em vez de criar uma nova. Aqui, não há dependências: [setLines] nunca muda;
    • linha 41: o objeto fornecido só é recriado se [lines] tiver mudado. Sem essas precauções, o provider forneceria um novo objeto a cada exibição, e todos os componentes que leem o contexto seriam chamados desnecessariamente;
    • linha 44: a partir do [React] 19, o próprio contexto é o componente provider (antes, escrevia-se [<LogContext.Provider>]);
  • Linhas 48–55: um hook de leitura. [use(context)] ([React] 19; antes [useContext]) retorna o valor do provider mais próximo. O hook verifica se há um: um erro claro é melhor do que um [null] inesperado.

3.5.2. Um contexto fornecido por um componente

// =========================================================================
// 14-contexts/src/contexts/cart.tsx - um contexto fornecido por UM componente
// -------------------------------------------------------------------------
// O carrinho só é fornecido a uma parte da árvore de componentes: aqueles
// envolvidos por <CartProvider> (cf. App.tsx). Dois providers colocados em
// dois lugares da página dariam dois carrinhos independentes.
// Um provider pode ele mesmo ler outros contextos: o carrinho
// usa o log.
// =========================================================================

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;
}

O carrinho de compras é fornecido apenas a uma parte da árvore de componentes: aqueles envolvidos por [<CartProvider>]. Dois providers colocados em locais diferentes da página resultariam em dois carrinhos independentes.

  • Linha 29: um provider é um componente; ele mesmo pode ler outros contextos; o carrinho de compras usa o log;
  • Linhas 32–46: os dados ([items], [total]) e as ações ([add], [remove]), que são recalculados quando os itens mudam.

3.5.3. Um contexto configurado

// =========================================================================
// 14-contexts/src/contexts/clock.tsx - um contexto PARAMETRIZADO
// -------------------------------------------------------------------------
// Um relógio, cujo período de atualização é uma prop do
// provider: <ClockProvider period={5000}>. Dois providers
// aninhados: um componente lê o que estiver MAIS PRÓXIMO dele.
// O relógio para quando seu provider desaparece (limpeza do efeito).
// =========================================================================

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

// o valor padrão: uma data congelada, lida por um componente sem provider
const ClockContext = createContext<Date>(new Date());

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

  // [period]: se o pai muda o período, o timer é reiniciado
  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);
}
  • linha 13: aqui, um verdadeiro valor padrão: uma data fixa;
  • linha 15: o período de atualização é uma prop do provider;
  • linhas 19–22: o timer; se o pai mudar o período, o efeito é limpo e depois reiniciado.

3.5.4. Os componentes

// 14-contexts/src/Catalog.tsx - um descendente que ADICIONA ao carrinho
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() {
  // o carrinho fornecido por App (erro se ninguém o fornecer)
  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()]: o carrinho de compras fornecido por um pai (erro se nenhum pai o fornecer).

// =========================================================================
// 14-contexts/src/CartSummary.tsx
// -------------------------------------------------------------------------
// Outro descendente: o MESMO carrinho de Catalog (fornecido por App), mas
// SEU PRÓPRIO relógio, atualizado a cada 5 segundos. Um componente só lê
// os providers colocados ACIMA dele: CartSummary, portanto, coloca
// um segundo <ClockProvider> em volta de seu conteúdo, que ele confia a um
// pequeno componente, Content.
// =========================================================================

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

function Content() {
  const cart = useCart();
  const now = useClock(); // o relógio mais próximo: o 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>
  );
}
  • linhas 14–34: o conteúdo do resumo lê o carrinho de compras E o relógio. O relógio mais próximo é o de 5 segundos;
  • linhas 36–42: um componente lê apenas os providers colocados ACIMA dele: [CartSummary] coloca, portanto, seu próprio [<ClockProvider period={5000}>] em volta de um subcomponente, [Content].
// =========================================================================
// 14-contexts/src/App.tsx - três níveis de contextos
// -------------------------------------------------------------------------
//   - o log: fornecido bem no topo (main.tsx), para toda a aplicação;
//   - o carrinho, fornecido por App: compartilhado por Catalog e CartSummary,
//     que veem o MESMO carrinho;
//   - o relógio, fornecido por App (período padrão, 1 s) E por
//     CartSummary (5 s): cada um com o seu.
// =========================================================================

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

// a hora do relógio de App: um pequeno componente, colocado ABAIXO do provider
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>
  );
}
  • linhas 18–20: [App] fornece o relógio; para lê-lo, é necessário um componente colocado ABAIXO dele: [AppTime];
  • linha 23: [App] lê o log, fornecido acima;
  • Linhas 26–27: [App] fornece o relógio (1 s) e o carrinho a seus descendentes.

E o provider do log, colocado no topo de tudo:

// =========================================================================
// 14-contexts/src/main.tsx - o provider do log envolve App: ele
// fica, portanto, disponível em TODA a aplicação
// =========================================================================

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

O relógio do [App] avança a cada segundo, enquanto o relógio do carrinho de compras avança a cada cinco segundos. Os dois componentes enxergam o mesmo carrinho, e o log registra cada adição.

Um contexto é suficiente para dados que raramente mudam (o usuário logado, o idioma, um tema) ou que se aplicam apenas a parte da página. Quando um estado é compartilhado por toda a aplicação e muda com frequência, prefere-se um “store” (Exemplo 20).

3.6. Exemplo 15: Escrevendo seus próprios hooks

Um componente reutiliza a visão; um hook personalizado reutiliza um comportamento, junto com seu estado. É uma função cujo nome começa com [use] e que, por sua vez, chama hooks. Este exemplo escreve dois deles, para os dois comportamentos que o Exemplo 15 do curso [Angular] atribuía a diretivas.

3.6.1. Destacar um elemento ao passar o mouse

// =========================================================================
// 15-custom-hooks/src/hooks/useHover.ts
// -------------------------------------------------------------------------
// Um HOOK PERSONALIZADO é uma função cujo nome começa com "use", e
// que ela mesma chama hooks (useState, useEffect, useRef...). Ele
// permite reutilizar um COMPORTAMENTO (com seu estado) em vários
// componentes, assim como um componente reutiliza a exibição.
//
// Este destaca um elemento sobre o qual o mouse passa. Ele retorna os atributos a colocar
// no elemento: <li {...useHover('#d1e7dd')}>. Cada chamada tem seu
// próprio estado: dois elementos destacados não interferem entre si.
// =========================================================================

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),
  };
}

O hook tem seu próprio estado ([hovered]) e retorna os atributos a serem aplicados ao elemento: um estilo e dois tratadores de evento. Cada componente que o chama tem seu próprio estado: dois elementos destacados não interferem um no outro.

3.6.2. Clique longo

// =========================================================================
// 15-custom-hooks/src/hooks/useLongPress.ts
// -------------------------------------------------------------------------
//     const longPress = useLongPress(() => remove(m), 1000);
//     <button {...longPress.handlers} className={longPress.pressing ? 'press' : ''}>
// A ação só é executada se o botão for mantido pressionado por um
// segundo: uma proteção contra cliques acidentais. pressing indica se um
// pressionamento está em andamento (para exibi-lo).
// O timer é parado se o componente desaparecer durante um pressionamento.
// =========================================================================

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

export function useLongPress(action: () => void, duration = 1000) {
  const [pressing, setPressing] = useState(false);
  // um valor que sobrevive às exibições SEM provocá-las: useRef
  const timer = useRef<number | undefined>(undefined);

  // quando o componente é removido: nenhum timer órfão
  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 },
  };
}
  • linha 17: o identificador do timer — um valor que deve persistir entre as exibições, mas não é exibido — uma referência;
  • linha 20: um efeito sem ação, que apenas faz a limpeza: se o componente desaparecer enquanto o botão estiver pressionado, o timer é interrompido;
  • linhas 22–28: a ação só é executada se o botão for mantido pressionado por um segundo: uma proteção contra cliques acidentais;
  • linhas 35–38: o hook retorna o estado ([pressing], para exibi-lo) e os tratadores de evento do ponteiro (mouse, dedo ou caneta).

3.6.3. Dar o foco

// =========================================================================
// 15-custom-hooks/src/hooks/autofocus.ts - um "ref callback"
// -------------------------------------------------------------------------
// ref={function}: o React chama a função com o elemento HTML assim que ele
// é colocado na página (e, no React 19, chama a função que ela
// eventualmente retornar quando ele é removido). Não é um hook:
// é uma função simples, reutilizável em qualquer lugar:
//     <input ref={autofocus} />
// (O React também trata o atributo autoFocus, que faz a mesma coisa.)
// =========================================================================

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

Uma ref callback: você pode atribuir uma função ao atributo [ref], que o [React] chama com o elemento HTML assim que ele é colocado na página. Isso não é um hook, mas uma simples função.

3.6.4. Uso

// =========================================================================
// 15-custom-hooks/src/App.tsx - reutilizando comportamentos
// -------------------------------------------------------------------------
// Os hooks só são chamados no NÍVEL SUPERIOR de um componente (nunca em
// um laço, uma condição ou uma função aninhada): o React
// os reconhece pela ORDEM de chamada. Para um comportamento por linha de
// uma lista, escrevemos portanto um pequeno componente por linha, que chama seus hooks.
// =========================================================================

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

// o estilo do botão durante um pressionamento longo
const pressStyle = { outline: '4px solid #dc3545' };

// uma linha da lista: ela chama SEUS hooks
function DoctorRow({ name, even, onRemove }: { name: string; even: boolean; onRemove: () => void }) {
  // uma linha em duas: a cor padrão; as demais, verde
  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>
  );
}

Os hooks seguem uma regra estrita: eles só são chamados no nível superior de um componente ou de outro hook, nunca dentro de um laço, de uma condição ou de uma função aninhada. O [React] identifica cada [useState] por sua ordem de chamada: se a ordem mudasse de uma exibição para outra, os estados se misturariam.

  • Linhas 19–33: para um comportamento linha a linha em uma lista, não é possível chamar os hooks diretamente dentro de [map]; em vez disso, escreva um pequeno componente para cada linha, que chama SEUS hooks;
  • Linha 25: os atributos do tooltip, espalhados pela linha;
  • linha 28: os tratadores de clique longo do botão e seu estilo enquanto pressionado;
  • linha 47: a referência de callback;
  • Linha 52: uma linha por médico.

Na inicialização, o campo tem o foco. Mantendo pressionado o segundo botão:

Image

Depois, quando um segundo tiver transcorrido:

Image

Os hooks personalizados são a principal forma de reutilizar código no [React]. As bibliotecas fornecem muitos deles: [useForm] (exemplo 08), [useNavigate] (exemplo 17), [useTranslation] (exemplo 21), [useQuery] (exemplo 24)...

3.7. Exemplo 16: uma janela de confirmação reutilizável

“Tem certeza?”: [window.confirm()] existe, mas seus botões não podem ser formatados nem traduzidos. Ele é substituído por uma janela [Bootstrap] controlada por um contexto.

3.7.1. O contexto

// =========================================================================
// 16-confirmation/src/confirmation/confirmation.tsx
// -------------------------------------------------------------------------
// "Tem certeza?": window.confirm() existe, mas não pode nem ser
// estilizado, nem ter seus botões traduzidos. Ele é substituído por um
// diálogo do Bootstrap, controlado por um contexto (cf. exemplo 14).
//
// O truque: confirm(message) retorna uma PROMISE, resolvida com true (Sim)
// ou false (Não) quando o usuário responde. O código chamador é então escrito
// tão simplesmente quanto com window.confirm:
//
//     const confirm = useConfirmation();
//     if (await confirm('Delete this doctor?')) { ... }
//
// O provider exibe o próprio diálogo: ele só precisa ser colocado
// uma vez, em volta de toda a aplicação (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: diálogo fechado
  // a função que resolverá a promise atual: ela não é exibida,
  // é portanto uma referência e não um estado
  const answer = useRef<((yes: boolean) => void) | null>(null);

  const confirm = useCallback<Confirm>((text) => {
    answer.current?.(false); // uma pergunta ainda em aberto? isso significa "não"
    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;
}

Dica: [confirm(message)] retorna uma promise, que é resolvida com [true] (Sim) ou [false] (Não) quando o usuário responde. O código chamador fica então tão simples quanto com [window.confirm]: [if (await confirm('Delete this doctor?')) {...}].

  • Linha 22: o que o contexto fornece: uma função;
  • linha 27: a mensagem exibida; [null]: a janela está fechada;
  • linha 30: a função que resolverá a promise atual. Ela não é exibida: é uma referência, não um estado;
  • Linhas 32–38: abrem a janela e retornam uma promise cuja função é mantida em [resolve]. Uma pergunta sem resposta é tratada como “não”;
  • linhas 40–45: a resposta: fecha a janela e resolve a promise;
  • linha 50: o provider exibe a própria janela quando há uma pergunta.

3.7.2. A janela

// =========================================================================
// 16-confirmation/src/confirmation/ConfirmDialog.tsx
// -------------------------------------------------------------------------
// O diálogo modal:
//   - mesmas classes do Bootstrap de um modal de verdade (.modal, .modal-backdrop),
//     exibido "fixo no código" (show d-block): sem necessidade do
//     JavaScript do Bootstrap;
//   - createPortal: o diálogo é colocado no final de <body>, e não onde o
//     componente está escrito. Assim ele escapa dos estilos de seus
//     ancestrais (overflow, z-index...), continuando a ser um componente
//     React comum (props, eventos);
//   - teclado: Escape = Não; o foco é colocado no botão "Não" (a escolha
//     menos perigosa) ao abrir.
// =========================================================================

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, em qualquer lugar da página: um listener colocado no DOCUMENT
  // ao abrir, removido ao fechar (limpeza do efeito)
  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>
      {/* um clique no fundo (e não no diálogo) significa "não" */}
      <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: o React dá o foco a este botão quando ele 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,
  );
}
  • linhas 27–33: a tecla Esc, em qualquer lugar da página: um listener anexado a DOCUMENT quando a janela abre e removido quando ela fecha (limpeza). Essa é tipicamente a função de um efeito: conectar-se a algo externo ao [React];
  • linha 35: [createPortal(jsx, element)] exibe JSX em um lugar diferente de onde o componente é escrito: aqui, no final de [<body>]. A janela escapa assim dos estilos de seus ancestrais ([overflow], [z-index]...), continuando a ser um componente [React] comum (props, eventos);
  • linhas 37–39: as classes [Bootstrap] de uma verdadeira janela modal, escritas diretamente ([show d-block]): não há necessidade do [JavaScript] do [Bootstrap];
  • linha 40: um clique no fundo (fora da janela) conta como “Não”;
  • linha 52: [React] dá o foco ao botão “Não” — a escolha mais segura — quando a janela aparece.

3.7.3. Uso

// =========================================================================
// 16-confirmation/src/App.tsx - usando o diálogo de confirmação
// -------------------------------------------------------------------------
// Mesma página do exemplo 21 do curso de NestJS (links, botões, confirmação),
// mas sem nenhuma ida e volta a um 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('');

  // uma função async: ela "espera" a resposta do usuário
  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>
  );
}
  • linha 17: a função de confirmação;
  • linhas 26–33: uma função [async]: ela “espera” ([await]) a resposta do usuário sem bloquear a 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';

// o diálogo de confirmação, UMA vez para toda a aplicação
createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <ConfirmationProvider>
      <App />
    </ConfirmationProvider>
  </StrictMode>,
);

UMA ÚNICA janela é usada para toda a aplicação: seu provider envolve [App].

Image

Confirme, depois solicite outra exclusão e pressione Esc:

Image