@adatechnology/conversations-ui 0.1.0-rc.2 → 0.1.0-rc.20

package/src/EmojiPicker.tsx

@@ -1,39 +1,27 @@
-import { useState, useCallback } from 'react'
+import { useState, useCallback, useMemo } from 'react'
+import { EMOJI_CATEGORIES, searchEmojis, type EmojiEntry } from './emojiCatalog'
+
+export interface EmojiPickerLabels {
+  search: string
+  noResults: string
+}
+
+export const DEFAULT_EMOJI_PICKER_LABELS: EmojiPickerLabels = {
+  search: 'Buscar emoji',
+  noResults: 'Nenhum emoji encontrado',
+}
 
 export interface EmojiPickerProps {
   onSelect: (emoji: string) => void
+  labels?: Partial<EmojiPickerLabels>
   className?: string
 }
 
-const EMOJI_CATEGORIES: { name: string; emojis: string[] }[] = [
-  {
-    name: 'Smileys',
-    emojis: ['😀', '😃', '😄', '😁', '😅', '😂', '🤣', '😊', '😇', '🙂', '😉', '😌', '😍', '🥰', '😘', '😗', '😋', '😛', '😜', '🤪'],
-  },
-  {
-    name: 'Gestures',
-    emojis: ['👍', '👎', '👌', '✌️', '🤞', '🤟', '🤘', '🤙', '👋', '🤚', '🖐️', '✋', '🖖', '👏', '🙌', '🤝', '🙏', '✍️', '💅', '🤳'],
-  },
-  {
-    name: 'Hearts',
-    emojis: ['❤️', '🧡', '💛', '💚', '💙', '💜', '🖤', '🤍', '🤎', '💔', '❣️', '💕', '💞', '💓', '💗', '💖', '💘', '💝', '💟', '♥️'],
-  },
-  {
-    name: 'Food',
-    emojis: ['🍔', '🍟', '🍕', '🌭', '🍿', '🧂', '🥓', '🥚', '🍳', '🧇', '🥞', '🧈', '🍞', '🥐', '🥨', '🥯', '🥖', '🧀', '🥗', '🥙'],
-  },
-  {
-    name: 'Drinks',
-    emojis: ['☕', '🍵', '🍶', '🍾', '🍷', '🍸', '🍹', '🍺', '🍻', '🥂', '🥃', '🥤', '🧋', '🧃', '🧉', '🧊', '🥢', '🍽️', '🍴', '🥄'],
-  },
-  {
-    name: 'Objects',
-    emojis: ['🎁', '🎂', '🎈', '🎉', '🎊', '🎀', '📱', '💻', '⌚', '📷', '🔑', '💰', '💳', '📝', '📌', '📍', '✂️', '🔍', '💡', '🔔'],
-  },
-]
-
-export const EmojiPicker = ({ onSelect, className = '' }: EmojiPickerProps) => {
+export const EmojiPicker = ({ onSelect, labels, className = '' }: EmojiPickerProps) => {
+  const searchLabel = labels?.search ?? DEFAULT_EMOJI_PICKER_LABELS.search
+  const noResultsLabel = labels?.noResults ?? DEFAULT_EMOJI_PICKER_LABELS.noResults
   const [activeCategory, setActiveCategory] = useState(0)
+  const [query, setQuery] = useState('')
 
   const handleSelect = useCallback(
     (emoji: string) => {
@@ -42,36 +30,62 @@ export const EmojiPicker = ({ onSelect, className = '' }: EmojiPickerProps) => {
     [onSelect],
   )
 
+  // Buscando, as abas de categoria saem do caminho: o resultado atravessa todas elas, e manter uma
+  // aba destacada sugeriria que a busca está restrita àquela categoria.
+  const isSearching = query.trim().length > 0
+  const visibleEntries: readonly EmojiEntry[] = useMemo(
+    () => (isSearching ? searchEmojis(query) : EMOJI_CATEGORIES[activeCategory].entries),
+    [isSearching, query, activeCategory],
+  )
+
   return (
     <div className={`bg-white border border-gray-200 rounded-lg shadow-lg overflow-hidden ${className}`}>
-      <div className="flex border-b border-gray-200 overflow-x-auto">
-        {EMOJI_CATEGORIES.map((category, index) => (
-          <button
-            key={category.name}
-            onClick={() => setActiveCategory(index)}
-            className={`px-3 py-2 text-xs font-medium whitespace-nowrap border-b-2 transition-colors ${
-              activeCategory === index
-                ? 'border-blue-500 text-blue-600'
-                : 'border-transparent text-gray-500 hover:text-gray-700'
-            }`}
-          >
-            {category.emojis[0]} {category.name}
-          </button>
-        ))}
+      <div className="p-2 border-b border-gray-200">
+        <input
+          type="search"
+          value={query}
+          onChange={(event) => setQuery(event.target.value)}
+          placeholder={searchLabel}
+          aria-label={searchLabel}
+          className="w-full rounded-md border border-gray-200 px-2 py-1.5 text-sm outline-none focus:border-blue-500"
+        />
       </div>
 
-      <div className="grid grid-cols-10 gap-0.5 p-2 max-h-[240px] overflow-y-auto">
-        {EMOJI_CATEGORIES[activeCategory].emojis.map((emoji) => (
-          <button
-            key={emoji}
-            onClick={() => handleSelect(emoji)}
-            className="w-8 h-8 flex items-center justify-center text-lg hover:bg-gray-100 rounded transition-colors cursor-pointer"
-            aria-label={emoji}
-          >
-            {emoji}
-          </button>
-        ))}
-      </div>
+      {isSearching ? null : (
+        <div className="flex border-b border-gray-200 overflow-x-auto">
+          {EMOJI_CATEGORIES.map((category, index) => (
+            <button
+              key={category.name}
+              onClick={() => setActiveCategory(index)}
+              className={`px-3 py-2 text-xs font-medium whitespace-nowrap border-b-2 transition-colors ${
+                activeCategory === index
+                  ? 'border-blue-500 text-blue-600'
+                  : 'border-transparent text-gray-500 hover:text-gray-700'
+              }`}
+            >
+              {category.entries[0].emoji} {category.name}
+            </button>
+          ))}
+        </div>
+      )}
+
+      {visibleEntries.length === 0 ? (
+        <p className="px-3 py-6 text-center text-sm text-gray-500">{noResultsLabel}</p>
+      ) : (
+        <div className="grid grid-cols-10 gap-0.5 p-2 max-h-[240px] overflow-y-auto">
+          {visibleEntries.map((entry) => (
+            <button
+              key={entry.emoji}
+              onClick={() => handleSelect(entry.emoji)}
+              className="w-8 h-8 flex items-center justify-center text-lg hover:bg-gray-100 rounded transition-colors cursor-pointer"
+              aria-label={entry.emoji}
+              title={entry.keywords[0]}
+            >
+              {entry.emoji}
+            </button>
+          ))}
+        </div>
+      )}
     </div>
   )
 }

package/src/FileIcon.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'bun:test'
+
+import { resolveFileIconExtension } from './FileIcon'
+
+describe('resolveFileIconExtension', () => {
+  // Regressão: o painel de documentos passava só o mimeType, e o do Office é longo
+  // (`application/vnd.openxmlformats-officedocument.wordprocessingml.document`), então docx, doc,
+  // xlsx e xls apareciam todos com o ícone genérico cinza.
+  const OFFICE_MIME_TYPES = [
+    {
+      filename: 'contrato.docx',
+      mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      expected: 'docx',
+    },
+    { filename: 'procuracao.doc', mimeType: 'application/msword', expected: 'doc' },
+    {
+      filename: 'pedido.xlsx',
+      mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      expected: 'xlsx',
+    },
+    { filename: 'tabela.xls', mimeType: 'application/vnd.ms-excel', expected: 'xls' },
+  ]
+
+  for (const testCase of OFFICE_MIME_TYPES) {
+    it(`resolve ${testCase.expected} pelo nome, já que o mimeType do Office não bate`, () => {
+      expect(resolveFileIconExtension(testCase.filename, testCase.mimeType)).toBe(testCase.expected)
+    })
+  }
+
+  it('resolve pelo mimeType quando o nome não tem extensão conhecida', () => {
+    expect(resolveFileIconExtension(undefined, 'application/pdf')).toBe('pdf')
+    expect(resolveFileIconExtension('recibo', 'application/zip')).toBe('zip')
+  })
+
+  it('devolve algo fora do mapa para tipo desconhecido, caindo no ícone genérico', () => {
+    expect(resolveFileIconExtension('backup', 'application/octet-stream')).toBe('octet-stream')
+  })
+
+  // Imagem, vídeo e áudio entram na biblioteca junto dos documentos — o backend linka as cinco
+  // espécies de mídia (image/audio/video/document/sticker), não só `document`.
+  const MEDIA_TYPES = [
+    { filename: 'foto.jpg', mimeType: 'image/jpeg', expected: 'jpg' },
+    { filename: 'prateleira.png', mimeType: 'image/png', expected: 'png' },
+    { filename: 'video-do-produto.mp4', mimeType: 'video/mp4', expected: 'mp4' },
+    { filename: 'antigo.3gp', mimeType: 'video/3gp', expected: '3gp' },
+    { filename: 'musica.mp3', mimeType: 'audio/mpeg', expected: 'mp3' },
+    { filename: 'recado.m4a', mimeType: 'audio/mp4', expected: 'm4a' },
+    { filename: 'lista-compras.txt', mimeType: 'text/plain', expected: 'txt' },
+    { filename: 'planilha.csv', mimeType: 'text/csv', expected: 'csv' },
+    {
+      filename: 'apresentacao.pptx',
+      mimeType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+      expected: 'pptx',
+    },
+  ]
+
+  for (const testCase of MEDIA_TYPES) {
+    it(`resolve ${testCase.expected}`, () => {
+      expect(resolveFileIconExtension(testCase.filename, testCase.mimeType)).toBe(testCase.expected)
+    })
+  }
+
+  // Áudio e sticker chegam da Meta sem nome de arquivo: o backend salva o id da mídia como rótulo,
+  // então a única pista de tipo é o mimeType.
+  it('resolve pela família quando o nome é o id da mídia, sem extensão', () => {
+    expect(resolveFileIconExtension('wamid-abc123', 'image/webp')).toBe('image')
+    expect(resolveFileIconExtension('wamid-abc123', 'video/mp4')).toBe('video')
+    expect(resolveFileIconExtension('wamid-abc123', 'audio/aac')).toBe('audio')
+  })
+
+  // `audio/ogg; codecs=opus` é o formato do áudio de WhatsApp. Com o parâmetro colado, o subtipo
+  // viria "ogg; codecs=opus" e o áudio cairia no ícone genérico.
+  it('descarta parâmetro do mimeType', () => {
+    expect(resolveFileIconExtension('wamid-audio', 'audio/ogg; codecs=opus')).toBe('audio')
+  })
+
+  // Pelo subtipo, `audio/mp4` casaria a chave `mp4` — que é vídeo. A família vem primeiro
+  // justamente para um m4a não aparecer com ícone de filme.
+  it('não confunde audio/mp4 com vídeo', () => {
+    expect(resolveFileIconExtension(undefined, 'audio/mp4')).toBe('audio')
+    expect(resolveFileIconExtension(undefined, 'video/mp4')).toBe('video')
+  })
+})

package/src/FileIcon.tsx

@@ -1,4 +1,15 @@
-import { FileArchive, FileSpreadsheet, FileText, File as FileGeneric } from 'lucide-react'
+import {
+  FileArchive,
+  FileAudio,
+  FileImage,
+  FileSpreadsheet,
+  FileText,
+  FileVideo,
+  File as FileGeneric,
+  Presentation,
+} from 'lucide-react'
+
+import { cn } from './lib/cn'
 
 export interface FileIconProps {
   filename?: string
@@ -7,27 +18,93 @@ export interface FileIconProps {
   className?: string
 }
 
-const EXTENSION_STYLE: Record<string, { Icon: typeof FileText; colorClass: string }> = {
+type IconStyle = { Icon: typeof FileText; colorClass: string }
+
+// Um estilo por família, reaproveitado por todas as extensões dela: assim o ícone de um `.jpg`
+// resolvido pelo nome é o mesmo de um `image/jpeg` resolvido pelo mimeType. Com cor por extensão, a
+// mesma foto trocaria de cor conforme o dado que chegou junto.
+const IMAGE_STYLE: IconStyle = { Icon: FileImage, colorClass: 'text-violet-500' }
+const VIDEO_STYLE: IconStyle = { Icon: FileVideo, colorClass: 'text-fuchsia-500' }
+const AUDIO_STYLE: IconStyle = { Icon: FileAudio, colorClass: 'text-amber-500' }
+const SHEET_STYLE: IconStyle = { Icon: FileSpreadsheet, colorClass: 'text-green-600' }
+const WORD_STYLE: IconStyle = { Icon: FileText, colorClass: 'text-blue-500' }
+const SLIDES_STYLE: IconStyle = { Icon: Presentation, colorClass: 'text-orange-600' }
+const TEXT_STYLE: IconStyle = { Icon: FileText, colorClass: 'text-gray-500' }
+
+const EXTENSION_STYLE: Record<string, IconStyle> = {
   pdf: { Icon: FileText, colorClass: 'text-red-500' },
-  doc: { Icon: FileText, colorClass: 'text-blue-500' },
-  docx: { Icon: FileText, colorClass: 'text-blue-500' },
-  xls: { Icon: FileSpreadsheet, colorClass: 'text-green-600' },
-  xlsx: { Icon: FileSpreadsheet, colorClass: 'text-green-600' },
+  doc: WORD_STYLE,
+  docx: WORD_STYLE,
+  xls: SHEET_STYLE,
+  xlsx: SHEET_STYLE,
+  csv: SHEET_STYLE,
+  ppt: SLIDES_STYLE,
+  pptx: SLIDES_STYLE,
   zip: { Icon: FileArchive, colorClass: 'text-orange-500' },
+  txt: TEXT_STYLE,
+  plain: TEXT_STYLE,
+
+  image: IMAGE_STYLE,
+  jpg: IMAGE_STYLE,
+  jpeg: IMAGE_STYLE,
+  png: IMAGE_STYLE,
+  webp: IMAGE_STYLE,
+  gif: IMAGE_STYLE,
+  heic: IMAGE_STYLE,
+
+  video: VIDEO_STYLE,
+  mp4: VIDEO_STYLE,
+  '3gp': VIDEO_STYLE,
+  '3gpp': VIDEO_STYLE,
+  mov: VIDEO_STYLE,
+  webm: VIDEO_STYLE,
+
+  audio: AUDIO_STYLE,
+  mp3: AUDIO_STYLE,
+  mpeg: AUDIO_STYLE,
+  ogg: AUDIO_STYLE,
+  oga: AUDIO_STYLE,
+  opus: AUDIO_STYLE,
+  aac: AUDIO_STYLE,
+  amr: AUDIO_STYLE,
+  m4a: AUDIO_STYLE,
+  wav: AUDIO_STYLE,
 }
 
-function getExtension(filename?: string, mimeType?: string): string {
+const MEDIA_FAMILIES = new Set(['image', 'video', 'audio'])
+
+/**
+ * A chave de estilo do arquivo, na ordem em que cada dado é confiável.
+ *
+ * 1. **extensão do nome** — o mimeType do Office é longo (`…wordprocessingml.document`) e nunca
+ *    casaria, então quem olhasse só o mimeType perderia o ícone de Word e de Excel;
+ * 2. **família do mimeType** (`image/`, `video/`, `audio/`) — tem de vir ANTES do subtipo por causa
+ *    de `audio/mp4`: pelo subtipo, um áudio m4a ganharia o ícone de vídeo;
+ * 3. **subtipo** — cobre `application/pdf` e `application/zip`, que chegam sem nome de arquivo.
+ *
+ * Áudio de WhatsApp chega como `audio/ogg; codecs=opus`; o parâmetro depois do `;` é descartado,
+ * senão o subtipo viria `ogg; codecs=opus` e não casaria nada.
+ *
+ * Exportada para teste: é a regra que já regrediu uma vez no painel de documentos.
+ */
+export function resolveFileIconExtension(filename?: string, mimeType?: string): string {
   const fromFilename = filename?.split('.').pop()?.toLowerCase()
   if (fromFilename && EXTENSION_STYLE[fromFilename]) return fromFilename
-  return mimeType?.split('/')[1]?.toLowerCase() ?? ''
+
+  const [family, subtype] = (mimeType ?? '').split(';')[0]!.toLowerCase().split('/')
+  if (family && MEDIA_FAMILIES.has(family)) return family
+
+  return subtype ?? ''
 }
 
 // Melhoria sobre a paridade da bolha de documento (T6.7 usava um único ícone genérico
 // para qualquer tipo de arquivo) — ícone e cor variam por extensão/mimeType.
-export function FileIcon({ filename, mimeType, size = 20, className = '' }: FileIconProps) {
-  const extension = getExtension(filename, mimeType)
+export function FileIcon({ filename, mimeType, size = 20, className }: FileIconProps) {
+  const extension = resolveFileIconExtension(filename, mimeType)
   const style = EXTENSION_STYLE[extension] ?? { Icon: FileGeneric, colorClass: 'text-gray-500' }
   const { Icon, colorClass } = style
 
-  return <Icon size={size} className={`${colorClass} ${className}`.trim()} />
+  // `cn` em vez de concatenar: a cor por extensão é a base, e produto que passa `text-*` precisa
+  // ganhar dela — concatenado, quem vence é a ordem no CSS gerado, não a intenção de quem chamou.
+  return <Icon size={size} className={cn(colorClass, className)} />
 }

package/src/InteractiveMessage.test.tsx

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'bun:test'
+import { renderToStaticMarkup } from 'react-dom/server'
+
+import { InteractiveMessage } from './InteractiveMessage'
+import type { InteractivePayload } from './types'
+
+function render(payload: InteractivePayload): string {
+  return renderToStaticMarkup(<InteractiveMessage payload={payload} />)
+}
+
+describe('InteractiveMessage', () => {
+  it('formata negrito no corpo, como o aparelho faz', () => {
+    const markup = render({ type: 'button', body: { text: 'Qual o *prazo desejado*?' } })
+
+    expect(markup).toContain('<strong>prazo desejado</strong>')
+    expect(markup).not.toContain('*prazo desejado*')
+  })
+
+  it('formata cabeçalho e rodapé também', () => {
+    const markup = render({
+      type: 'list',
+      header: { text: '*Menu*' },
+      body: { text: 'corpo' },
+      footer: { text: '_Selecione_' },
+    })
+
+    expect(markup).toContain('<strong>Menu</strong>')
+    expect(markup).toContain('<em>Selecione</em>')
+  })
+
+  it('deixa título de opção literal, porque o WhatsApp não formata ali', () => {
+    const markup = render({
+      type: 'button',
+      body: { text: 'corpo' },
+      action: { buttons: [{ reply: { id: 'sim', title: '*Sim*' } }] },
+    })
+
+    expect(markup).toContain('*Sim*')
+    expect(markup).not.toContain('<strong>Sim</strong>')
+  })
+})

package/src/InteractiveMessage.tsx

@@ -0,0 +1,143 @@
+/**
+ * Menu interativo do WhatsApp — botões de resposta rápida e lista de opções.
+ *
+ * A mensagem é gravada com o payload cru que foi enviado à Meta, então a UI apenas o desenha; não
+ * há segunda fonte de verdade sobre quais opções existiam naquele momento. Sem isto, mensagem
+ * `interactive` aparecia como texto solto e o menu simplesmente sumia da conversa — inclusive no
+ * simulador, onde o operador precisa ver exatamente o que o cliente vê.
+ *
+ * `onSelect` é opcional de propósito: no histórico da inbox as opções são leitura (o operador não
+ * responde no lugar do cliente); no simulador elas são clicáveis.
+ */
+
+import { useState } from 'react'
+import type { InteractiveOption, InteractivePayload, InteractiveSelection } from './types'
+import { cn } from './lib/cn'
+import { parseWhatsAppFormatting } from './lib/whatsapp-formatting'
+
+/** `parseWhatsAppFormatting` emite `<strong>`/`<em>`/`<del>`, que o reset do Tailwind zera. */
+const FORMATTING_CLASSES = '[&_strong]:font-bold [&_em]:italic [&_del]:line-through'
+
+export interface InteractiveMessageLabels {
+  /** Fallback do rótulo do botão que abre a lista, quando o payload não traz um. */
+  openList: string
+}
+
+export const DEFAULT_INTERACTIVE_MESSAGE_LABELS: InteractiveMessageLabels = {
+  openList: 'Ver opções',
+}
+
+export interface InteractiveMessageProps {
+  payload: InteractivePayload
+  onSelect?: (selection: InteractiveSelection) => void
+  labels?: Partial<InteractiveMessageLabels>
+  className?: string
+}
+
+function collectRows(payload: InteractivePayload): InteractiveOption[] {
+  return (payload.action?.sections ?? []).flatMap((section) => section.rows ?? [])
+}
+
+function collectButtons(payload: InteractivePayload): InteractiveOption[] {
+  return (payload.action?.buttons ?? [])
+    .map((button) => button.reply)
+    .filter((reply): reply is InteractiveOption => reply !== undefined)
+}
+
+export function InteractiveMessage({ payload, onSelect, labels, className }: InteractiveMessageProps) {
+  const openListLabel = labels?.openList ?? DEFAULT_INTERACTIVE_MESSAGE_LABELS.openList
+  const [isListOpen, setIsListOpen] = useState(false)
+
+  const buttons = collectButtons(payload)
+  const sections = payload.action?.sections ?? []
+  const hasRows = collectRows(payload).length > 0
+  const isInteractable = onSelect !== undefined
+
+  return (
+    <div className={cn('flex flex-col gap-1', className)}>
+      {/* Cabeçalho, corpo e rodapé passam pela formatação do WhatsApp — o aparelho renderiza
+          `*negrito*` neles como em qualquer texto. Título e descrição de opção NÃO: ali o WhatsApp
+          mostra os asteriscos literais, e formatá-los aqui deixaria o simulador mais bonito que o
+          aparelho, que é o tipo de divergência que só aparece com o cliente na frente. */}
+      {payload.header?.text ? (
+        <p className={cn('text-sm font-semibold text-gray-900 dark:text-gray-100', FORMATTING_CLASSES)}>
+          {parseWhatsAppFormatting(payload.header.text)}
+        </p>
+      ) : null}
+
+      {payload.body?.text ? (
+        <p
+          className={cn(
+            'whitespace-pre-wrap break-words text-sm text-gray-900 dark:text-gray-100',
+            FORMATTING_CLASSES,
+          )}
+        >
+          {parseWhatsAppFormatting(payload.body.text)}
+        </p>
+      ) : null}
+
+      {payload.footer?.text ? (
+        <p className={cn('text-xs text-gray-500 dark:text-gray-400', FORMATTING_CLASSES)}>
+          {parseWhatsAppFormatting(payload.footer.text)}
+        </p>
+      ) : null}
+
+      {buttons.length > 0 ? (
+        <div className="mt-1 flex flex-col gap-1 border-t border-gray-200 pt-1 dark:border-gray-700">
+          {buttons.map((button) => (
+            <button
+              key={button.id}
+              type="button"
+              disabled={!isInteractable}
+              onClick={() => onSelect?.({ kind: 'button', option: button })}
+              className="rounded-md px-3 py-1.5 text-sm font-medium text-teal-700 transition-colors enabled:hover:bg-teal-50 disabled:cursor-default dark:text-teal-300 dark:enabled:hover:bg-teal-900/30"
+            >
+              {button.title}
+            </button>
+          ))}
+        </div>
+      ) : null}
+
+      {hasRows ? (
+        <div className="mt-1 border-t border-gray-200 pt-1 dark:border-gray-700">
+          <button
+            type="button"
+            onClick={() => setIsListOpen((open) => !open)}
+            aria-expanded={isListOpen}
+            className="w-full rounded-md px-3 py-1.5 text-sm font-medium text-teal-700 transition-colors hover:bg-teal-50 dark:text-teal-300 dark:hover:bg-teal-900/30"
+          >
+            ☰ {payload.action?.button ?? openListLabel}
+          </button>
+
+          {isListOpen ? (
+            <div className="mt-1 flex flex-col gap-1">
+              {sections.map((section, sectionIndex) => (
+                <div key={section.title ?? sectionIndex} className="flex flex-col">
+                  {section.title ? (
+                    <p className="px-3 py-1 text-xs font-semibold uppercase text-gray-500 dark:text-gray-400">
+                      {section.title}
+                    </p>
+                  ) : null}
+                  {(section.rows ?? []).map((row) => (
+                    <button
+                      key={row.id}
+                      type="button"
+                      disabled={!isInteractable}
+                      onClick={() => onSelect?.({ kind: 'list', option: row })}
+                      className="rounded-md px-3 py-1.5 text-left text-sm text-gray-900 transition-colors enabled:hover:bg-gray-100 disabled:cursor-default dark:text-gray-100 dark:enabled:hover:bg-gray-700"
+                    >
+                      <span className="block">{row.title}</span>
+                      {row.description ? (
+                        <span className="block text-xs text-gray-500 dark:text-gray-400">{row.description}</span>
+                      ) : null}
+                    </button>
+                  ))}
+                </div>
+              ))}
+            </div>
+          ) : null}
+        </div>
+      ) : null}
+    </div>
+  )
+}

package/src/Lightbox.tsx

@@ -1,16 +1,31 @@
+export interface LightboxLabels {
+  /** Texto alternativo quando a imagem não tem legenda — sem ele o leitor de tela anuncia a URL. */
+  imageAlt: string
+  close: string
+}
+
 export interface LightboxProps {
   imageUrl: string
   caption?: string
   onClose: () => void
+  labels?: Partial<LightboxLabels>
 }
 
-export function Lightbox({ imageUrl, caption, onClose }: LightboxProps) {
+export const DEFAULT_LIGHTBOX_LABELS: LightboxLabels = {
+  imageAlt: 'Imagem',
+  close: 'Fechar',
+}
+
+export function Lightbox({ imageUrl, caption, onClose, labels }: LightboxProps) {
+  const imageAltLabel = labels?.imageAlt ?? DEFAULT_LIGHTBOX_LABELS.imageAlt
+  const closeLabel = labels?.close ?? DEFAULT_LIGHTBOX_LABELS.close
+
   return (
     <div className="fixed inset-0 z-50 bg-black/85 flex items-center justify-center p-4" onClick={onClose}>
       <div className="max-w-[90vw] max-h-[90vh] flex flex-col items-center" onClick={(e) => e.stopPropagation()}>
-        <img src={imageUrl} alt={caption ?? 'Image'} className="max-w-full max-h-[80vh] object-contain rounded-lg" />
+        <img src={imageUrl} alt={caption ?? imageAltLabel} className="max-w-full max-h-[80vh] object-contain rounded-lg" />
         {caption && <p className="text-white text-sm mt-3 text-center">{caption}</p>}
-        <button onClick={onClose} className="mt-4 px-4 py-2 bg-white/20 text-white rounded-lg hover:bg-white/30 transition-colors">Fechar</button>
+        <button onClick={onClose} className="mt-4 px-4 py-2 bg-white/20 text-white rounded-lg hover:bg-white/30 transition-colors">{closeLabel}</button>
       </div>
     </div>
   )