@celke/kole-react 0.5.0 → 0.6.0

package/dist/components/Kanban/Pecas.d.ts

@@ -0,0 +1,30 @@
+import { type CorKanban, type Prioridade } from './tipos.js';
+export interface SeloPrioridadeProps {
+    prioridade: Prioridade;
+    /** Só a bandeira colorida (o nome fica para o leitor de tela e a dica). */
+    compacto?: boolean;
+    className?: string;
+}
+/** Bandeira com o nível de prioridade: baixa, média, alta ou crítica. */
+export declare function SeloPrioridade({ prioridade, compacto, className }: SeloPrioridadeProps): import("react").JSX.Element;
+export interface SeloPrazoProps {
+    /** Data de vencimento (`Date` ou `AAAA-MM-DD`). */
+    vencimento: Date | string;
+    /** Concluído: mostra a data em verde, sem "Atrasado". */
+    concluido?: boolean;
+    /** Dias antes do vencimento em que vira "em breve" (padrão: 2). */
+    emBreve?: number;
+    /** Referência de "hoje" (padrão: agora). */
+    agora?: Date;
+    className?: string;
+}
+/** Vencimento com cor pela situação: atrasado, hoje, em breve ou no prazo. */
+export declare function SeloPrazo({ vencimento, concluido, emBreve, agora, className }: SeloPrazoProps): import("react").JSX.Element;
+export interface EtiquetaProps {
+    rotulo: string;
+    /** Cor do ponto e do fundo (padrão: `neutro`). */
+    cor?: CorKanban;
+    className?: string;
+}
+/** Etiqueta colorida de cartão e tarefa ("Design", "Urgente"…). */
+export declare function Etiqueta({ rotulo, cor, className }: EtiquetaProps): import("react").JSX.Element;

package/dist/components/Kanban/tipos.d.ts

@@ -0,0 +1,35 @@
+import type { IconeProp } from '../../utils/Icone.js';
+import type { Severidade } from '../../utils/tipos.js';
+/** Cores de coluna e etiqueta: tokens de severidade, a marca e as séries de gráfico. */
+export type CorKanban = 'pri' | 'ok' | 'warn' | 'err' | 'info' | 'destaque' | 'neutro' | 'graf-1' | 'graf-2' | 'graf-3' | 'graf-4' | 'graf-5' | 'graf-6';
+/** Prioridade de cartão ou tarefa. Use só os níveis de que precisa (ex.: baixa, média e alta). */
+export type Prioridade = 'baixa' | 'media' | 'alta' | 'critica';
+/** Rótulos em pt-BR (os componentes usam o dicionário do idioma ativo: `textos.kanban`). */
+export declare const PRIORIDADES: Record<Prioridade, {
+    rotulo: string;
+    severidade: Severidade;
+}>;
+export interface EtiquetaKanban {
+    rotulo: string;
+    cor?: CorKanban;
+}
+/** Situação de uma tarefa (a coluna do kanban, quando ele é agrupado por situação). */
+export type SituacaoTarefa = 'aberta' | 'andamento' | 'bloqueada' | 'concluida';
+/** Rótulos em pt-BR (os componentes usam o dicionário do idioma ativo: `textos.kanban`). */
+export declare const SITUACOES_TAREFA: Record<SituacaoTarefa, {
+    rotulo: string;
+    severidade: Severidade;
+    icone: IconeProp;
+}>;
+/** Chave do texto de cada prioridade em `textos.kanban`. */
+export declare const CHAVE_PRIORIDADE: {
+    readonly baixa: "prioridadeBaixa";
+    readonly media: "prioridadeMedia";
+    readonly alta: "prioridadeAlta";
+    readonly critica: "prioridadeCritica";
+};
+/** Subtarefas feitas e total (o cartão mostra a barra de progresso). */
+export interface ContagemSubtarefas {
+    feitas: number;
+    total: number;
+}

package/dist/components/ListaCards/ListaCards.d.ts

@@ -25,4 +25,4 @@ export interface ListaCardsProps<T> {
     className?: string;
 }
 /** Listagem em grade de cards, irmã da `Tabela` (a ordenação fica na barra de filtros). */
-export declare function ListaCards<T>({ itens, card, chave, larguraMin, alturaCard, rotulo, carregando, atualizando, erro, aoRecarregar, vazioTitulo, vazioDescricao, vazioIcone, vazioAcoes, paginacao, className, }: ListaCardsProps<T>): import("react").JSX.Element;
+export declare function ListaCards<T>({ itens, card, chave, larguraMin, alturaCard, rotulo, carregando, atualizando, erro, aoRecarregar, vazioTitulo: vazioTituloProp, vazioDescricao, vazioIcone, vazioAcoes, paginacao, className, }: ListaCardsProps<T>): import("react").JSX.Element;

package/dist/components/ListaConversas/ListaConversas.d.ts

@@ -0,0 +1,40 @@
+import { type ReactNode } from 'react';
+export interface ItemConversa {
+    id: string | number;
+    titulo: string;
+    /** Última atividade: define o grupo (Hoje, Ontem, Últimos 7 dias…). */
+    data: Date;
+    /** Fica no grupo "Fixadas", no topo. */
+    fixada?: boolean;
+}
+export interface ListaConversasProps {
+    itens: ItemConversa[];
+    /** Id da conversa aberta. */
+    ativa?: ItemConversa['id'] | null;
+    aoEscolher: (id: ItemConversa['id']) => void;
+    /** Mostra o botão "Nova conversa". */
+    aoNova?: () => void;
+    /** Liga o "Renomear" no menu do item (edição no próprio item: Enter salva, Esc cancela). */
+    aoRenomear?: (id: ItemConversa['id'], titulo: string) => void;
+    /** Liga o "Excluir" no menu do item. A confirmação, se houver, é do app. */
+    aoExcluir?: (id: ItemConversa['id']) => void;
+    /** Liga o "Fixar"/"Desafixar" no menu do item. */
+    aoFixar?: (id: ItemConversa['id'], fixada: boolean) => void;
+    /** Campo de busca pelo título (sem acento e sem diferença de maiúsculas). Padrão: `true`. */
+    busca?: boolean;
+    carregando?: boolean;
+    /** Sem conversas. */
+    textoVazio?: string;
+    /** Acima da lista, abaixo da busca (ex.: filtros). */
+    extra?: ReactNode;
+    rotulo?: string;
+    rotuloNova?: string;
+    /** "Hoje" dos grupos (para testes). Padrão: a data atual. */
+    hoje?: Date;
+    className?: string;
+}
+/**
+ * Histórico de conversas de um assistente: "Nova conversa", busca e os itens agrupados por
+ * data, com renomear, fixar e excluir. O app guarda o histórico; a lista mostra e avisa.
+ */
+export declare function ListaConversas({ itens, ativa, aoEscolher, aoNova, aoRenomear, aoExcluir, aoFixar, busca, carregando, textoVazio: textoVazioProp, extra, rotulo: rotuloProp, rotuloNova: rotuloNovaProp, hoje: hojeProp, className, }: ListaConversasProps): import("react").JSX.Element;

package/dist/components/ListaTarefas/ListaTarefas.d.ts

@@ -0,0 +1,52 @@
+import type { ReactNode } from 'react';
+import { type PessoaAvatar } from '../Avatar/GrupoAvatares.js';
+import { type ContagemSubtarefas, type EtiquetaKanban, type Prioridade, type SituacaoTarefa } from '../Kanban/tipos.js';
+export interface TarefaLista {
+    id: string;
+    titulo: string;
+    /** Marcada como feita (sem isto, vale `situacao === 'concluida'`). */
+    concluida?: boolean;
+    /** Mostrada como selo quando é "Em andamento" ou "Bloqueada". */
+    situacao?: SituacaoTarefa;
+    prioridade?: Prioridade;
+    /** Data de vencimento (`Date` ou `AAAA-MM-DD`). */
+    vencimento?: Date | string;
+    etiquetas?: EtiquetaKanban[];
+    responsaveis?: PessoaAvatar[];
+    subtarefas?: ContagemSubtarefas;
+}
+/** O que `aoReordenar` recebe além da lista nova. */
+export interface ReordenarTarefa<T> {
+    tarefa: T;
+    de: number;
+    para: number;
+}
+export interface ListaTarefasProps<T extends TarefaLista> {
+    tarefas: T[];
+    /** Marcar ou desmarcar como concluída. Sem isto, o círculo não aparece. */
+    aoConcluir?: (tarefa: T, concluida: boolean) => void;
+    /** Clicar na tarefa abre o detalhe (ex.: um `Dialogo` lateral). */
+    aoAbrir?: (tarefa: T) => void;
+    /** Liga o arraste para reordenar; recebe a lista na ordem nova, ao soltar. */
+    aoReordenar?: (tarefas: T[], evento: ReordenarTarefa<T>) => void;
+    /** Id da tarefa aberta no detalhe (fica destacada). */
+    selecionada?: string;
+    /** Visão e filtros: as tarefas com `false` somem, e a ordem das outras continua valendo ao arrastar. */
+    filtro?: (tarefa: T) => boolean;
+    /** Conteúdo a mais em cada linha, antes dos responsáveis. */
+    extra?: (tarefa: T) => ReactNode;
+    carregando?: boolean;
+    vazioTitulo?: string;
+    vazioDescricao?: string;
+    vazioAcoes?: ReactNode;
+    /** Referência de "hoje" para os prazos (padrão: agora). */
+    agora?: Date;
+    /** Nome acessível da lista (padrão: "Tarefas"). */
+    rotulo?: string;
+    className?: string;
+}
+/**
+ * Lista de tarefas: marcar como feita, prioridade, prazo, etiquetas e
+ * responsáveis em cada linha; reordena arrastando (mouse, toque e teclado).
+ */
+export declare function ListaTarefas<T extends TarefaLista>({ tarefas, aoConcluir, aoAbrir, aoReordenar, selecionada, filtro, extra, carregando, vazioTitulo: vazioTituloProp, vazioDescricao, vazioAcoes, agora, rotulo: rotuloProp, className, }: ListaTarefasProps<T>): import("react").JSX.Element;

package/dist/components/Mensagem/Mensagem.d.ts

@@ -37,4 +37,4 @@ export interface MensagemProps {
     className?: string;
 }
 /** Uma mensagem da `Conversa`: bolha com autor, hora, estado e ações. */
-export declare function Mensagem({ autor, children, nome, avatar, hora, estado, erro, aoTentarNovamente, copiavel, textoCopia, acoes, rodape, rotuloTentarNovamente, rotuloCopiar, rotuloGerando, rotuloEnviando, className, }: MensagemProps): import("react").JSX.Element;
+export declare function Mensagem({ autor, children, nome, avatar, hora, estado, erro, aoTentarNovamente, copiavel, textoCopia, acoes, rodape, rotuloTentarNovamente: rotuloTentarNovamenteProp, rotuloCopiar: rotuloCopiarProp, rotuloGerando: rotuloGerandoProp, rotuloEnviando: rotuloEnviandoProp, className, }: MensagemProps): import("react").JSX.Element;

package/dist/components/NavegadorPeriodo/NavegadorPeriodo.d.ts

@@ -0,0 +1,28 @@
+import { type Periodo } from '../../utils/periodo.js';
+import { type BotaoProps } from '../Botao/Botao.js';
+export interface AtalhoPeriodo {
+    rotulo: string;
+    /** O período, ou uma função de "agora" (ex.: o mês passado). */
+    periodo: Periodo | ((agora: Date) => Periodo);
+}
+export interface NavegadorPeriodoProps {
+    valor: Periodo;
+    aoMudar: (periodo: Periodo) => void;
+    /** Atalhos do painel. Padrão: este mês, mês passado, este trimestre, este ano e ano passado. */
+    atalhos?: AtalhoPeriodo[];
+    /** Intervalo livre (de/até) no painel. Padrão `true`. */
+    personalizado?: boolean;
+    /** "Hoje" de referência (testes, fuso do servidor). */
+    agora?: Date;
+    /** Nome do grupo para leitor de tela. Padrão "Período". */
+    rotulo?: string;
+    tamanho?: BotaoProps['tamanho'];
+    className?: string;
+}
+/** Atalhos padrão com os rótulos em pt-BR (sem `atalhos`, o componente usa os do idioma ativo). */
+export declare const ATALHOS_PERIODO: AtalhoPeriodo[];
+/**
+ * "‹ novembro de 2026 ›": anda de mês em mês (ou trimestre, ano, intervalo)
+ * pelas setas, e o rótulo abre os atalhos e o intervalo livre.
+ */
+export declare function NavegadorPeriodo({ valor, aoMudar, atalhos: atalhosProp, personalizado, agora, rotulo: rotuloProp, tamanho, className }: NavegadorPeriodoProps): import("react").JSX.Element;

package/dist/components/Picklist/Picklist.d.ts

@@ -25,4 +25,4 @@ export interface PicklistProps<T> extends Omit<CampoBaseProps, 'variante'> {
  * setas movem o foco, Espaço marca, Enter transfere, Alt+setas reordena;
  * duplo clique também transfere.
  */
-export declare function Picklist<T>({ rotulo, dica, erro, aviso, obrigatorio, className, id: idExterno, valor: valorBruto, aoMudar, rotuloFonte, rotuloAlvo, paraRotulo, renderItem, filtro, dragdrop, reordenar, alturaLista, disabled, }: PicklistProps<T>): import("react").JSX.Element;
+export declare function Picklist<T>({ rotulo, dica, erro, aviso, obrigatorio, className, id: idExterno, valor: valorBruto, aoMudar, rotuloFonte: rotuloFonteProp, rotuloAlvo: rotuloAlvoProp, paraRotulo, renderItem, filtro, dragdrop, reordenar, alturaLista, disabled, }: PicklistProps<T>): import("react").JSX.Element;

package/dist/components/Preferencias/Preferencias.d.ts

@@ -1,4 +1,6 @@
 import { type ReactNode } from 'react';
+import { type TextosParciais } from '../../i18n/textos.js';
+import type { Idioma } from '../../i18n/idiomas.js';
 /** `sistema` = segue o modo do sistema operacional, inclusive quando ele muda com a página aberta. */
 export type Tema = 'claro' | 'escuro' | 'sistema';
 export type Densidade = 'compacta' | 'confortavel' | 'espacosa';
@@ -7,9 +9,13 @@ export interface Preferencias {
     /** O tema que está na tela: com `sistema`, o do sistema operacional agora. */
     escuro: boolean;
     densidade: Densidade;
+    /** Idioma dos textos da biblioteca (padrão `pt-BR`). */
+    idioma: Idioma;
     definirTema: (t: Tema) => void;
     alternarTema: () => void;
     definirDensidade: (d: Densidade) => void;
+    /** Troca o idioma: todos os componentes mudam na hora, e a escolha fica lembrada. */
+    definirIdioma: (i: Idioma) => void;
 }
 /**
  * Script para o `<head>` que aplica tema e densidade ANTES da primeira pintura.
@@ -20,22 +26,39 @@ export interface Preferencias {
  * SSR: `<script dangerouslySetInnerHTML={{ __html: scriptTemaInicial() }} />`.
  * Vite/HTML estático: o README traz o script pronto para colar no index.html.
  */
-export declare function scriptTemaInicial({ temaInicial, densidadeInicial }?: {
+export declare function scriptTemaInicial({ temaInicial, densidadeInicial, idiomaInicial, }?: {
     temaInicial?: Tema;
     densidadeInicial?: Densidade;
+    idiomaInicial?: Idioma;
 }): string;
 export interface ProvedorPreferenciasProps {
     children: ReactNode;
     /** Tema enquanto a pessoa não escolhe outro. Padrão: `sistema`. */
     temaInicial?: Tema;
     densidadeInicial?: Densidade;
+    /**
+     * Idioma enquanto a pessoa não escolhe outro (ex.: o `users.locale` do
+     * servidor). Padrão: `pt-BR`. O navegador não é consultado.
+     */
+    idiomaInicial?: Idioma;
+    /**
+     * Chamado ao montar e a cada troca de idioma: o lugar de sincronizar o i18n
+     * do sistema (ex.: `i18n.changeLanguage`) e de gravar a escolha no servidor.
+     */
+    aoMudarIdioma?: (idioma: Idioma) => void;
+    /**
+     * Textos por idioma, por cima dos da biblioteca: troca um texto
+     * (`{ 'pt-BR': { tabela: { rotulo: 'Lista' } } }`) ou acrescenta um idioma
+     * (`{ fr: { … } }`; o que faltar sai em pt-BR).
+     */
+    textos?: Partial<Record<Idioma, TextosParciais>>;
 }
 /**
  * Tema (claro/escuro/sistema) e densidade, lembrados no navegador. Aplica
  * `data-theme` (`light`/`dark`/`system`) no <html> e a classe de densidade no
  * <body>. Para não piscar ao abrir, use também o `scriptTemaInicial` no <head>.
  */
-export declare function ProvedorPreferencias({ children, temaInicial, densidadeInicial }: ProvedorPreferenciasProps): import("react").JSX.Element;
+export declare function ProvedorPreferencias({ children, temaInicial, densidadeInicial, idiomaInicial, aoMudarIdioma, textos }: ProvedorPreferenciasProps): import("react").JSX.Element;
 export declare function usePreferencias(): Preferencias;
 /** Tudo que a biblioteca precisa na raiz do app: preferências, toasts e confirmação. */
 export declare function ProvedorUi({ children, ...prefs }: ProvedorPreferenciasProps): import("react").JSX.Element;

package/dist/components/QuadroArrastavel/QuadroArrastavel.d.ts

@@ -4,24 +4,77 @@ export interface ColunaArrastavel<T> {
     /** Nome da coluna (anunciado ao mover pelo teclado). */
     titulo?: string;
     itens: T[];
+    /** Recolhida: os itens somem e soltar nela põe o item no fim. */
+    recolhida?: boolean;
+}
+/** Lugar de um item: id da coluna e posição nela (contando sem o próprio item). */
+export interface PosicaoQuadro {
+    coluna: string;
+    indice: number;
+}
+/** O que `aoSoltar` recebe quando um item muda de lugar. */
+export interface SoltarItem<T, C = ColunaArrastavel<T>> {
+    item: T;
+    de: PosicaoQuadro;
+    para: PosicaoQuadro;
+    /** As colunas já com o item no lugar novo (as mesmas de `aoMudar`). */
+    colunas: C[];
+}
+/** O que `aoSoltarColuna` recebe quando uma coluna muda de lugar. */
+export interface SoltarColuna<C> {
+    coluna: C;
+    de: number;
+    para: number;
+    colunas: C[];
 }
 export interface QuadroArrastavelProps<T extends {
     id: string;
-}> {
-    colunas: ColunaArrastavel<T>[];
-    /** Recebe as colunas já reordenadas. */
-    aoMudar: (colunas: ColunaArrastavel<T>[]) => void;
+}, C extends ColunaArrastavel<T> = ColunaArrastavel<T>> {
+    /** Colunas com os itens; podem ter campos a mais (cor, limite…), que voltam em `aoMudar`. */
+    colunas: (ColunaArrastavel<T> & C)[];
+    /** Recebe as colunas na ordem nova, uma vez, ao soltar (durante o arraste o quadro mostra uma prévia). */
+    aoMudar: (colunas: C[]) => void;
+    /** Avisa de onde para onde o item foi, ao soltar: é o que o servidor precisa para gravar. */
+    aoSoltar?: (evento: SoltarItem<T, C>) => void;
+    /**
+     * Regra de destino: `false` impede soltar o item ali (ex.: coluna cheia).
+     * `de` é o lugar onde o arraste começou.
+     */
+    podeSoltar?: (item: T, para: PosicaoQuadro, de: PosicaoQuadro) => boolean;
+    /** Filtro: os itens com `false` ficam escondidos, mas continuam no lugar ao arrastar os outros. */
+    visivel?: (item: T) => boolean;
     /** Desenha o item; ponha a `alca` (botão de arrastar) onde quiser, ex.: no cabeçalho do card. */
     renderItem: (item: T, alca: ReactNode) => ReactNode;
     /** Nome de cada item para leitor de tela (ex.: o título do card). */
     nomeItem: (item: T) => string;
+    /**
+     * `grade` (padrão) = as colunas dividem a largura e quebram linha ·
+     * `faixa` = colunas de largura fixa lado a lado, com rolagem horizontal (kanban).
+     */
+    layout?: 'grade' | 'faixa';
+    /** Na `faixa`, a largura de cada coluna; na `grade`, a largura mínima (padrão: 18rem e 16rem). */
+    larguraColuna?: string;
+    /** Topo de cada coluna. `alca` é o botão de arrastar a coluna (com `colunasArrastaveis`). */
+    cabecalhoColuna?: (coluna: C, alca: ReactNode) => ReactNode;
+    /** Pé de cada coluna (ex.: "Adicionar cartão"). Some na coluna recolhida. */
+    rodapeColuna?: (coluna: C) => ReactNode;
+    /** As colunas também se reordenam, pela alça do cabeçalho. */
+    colunasArrastaveis?: boolean;
+    /** Avisa a coluna que mudou de lugar, ao soltar. */
+    aoSoltarColuna?: (evento: SoltarColuna<C>) => void;
+    /** Conteúdo depois da última coluna, na mesma fileira (ex.: "Adicionar coluna"). */
+    fim?: ReactNode;
+    /** Classe extra de cada coluna (vale também para a cópia que segue o ponteiro). */
+    classeColuna?: (coluna: C) => string | undefined;
+    /** Nome acessível do quadro. */
+    rotulo?: string;
     className?: string;
 }
 /**
  * Colunas de itens (cards) que se reordenam arrastando, entre colunas
  * inclusive. Mouse, toque e teclado: na alça, Espaço pega/solta, setas movem,
- * Esc devolve ao lugar de origem.
+ * Esc devolve ao lugar de origem. Perto da borda, a tela rola sozinha.
  */
 export declare function QuadroArrastavel<T extends {
     id: string;
-}>({ colunas, aoMudar, renderItem, nomeItem, className }: QuadroArrastavelProps<T>): import("react").JSX.Element;
+}, C extends ColunaArrastavel<T> = ColunaArrastavel<T>>({ colunas, aoMudar, aoSoltar, podeSoltar, visivel, renderItem, nomeItem, layout, larguraColuna, cabecalhoColuna, rodapeColuna, colunasArrastaveis, aoSoltarColuna, fim, classeColuna, rotulo, className, }: QuadroArrastavelProps<T, C>): import("react").JSX.Element;

package/dist/components/Referencias/Referencias.d.ts

@@ -21,4 +21,4 @@ export interface ReferenciasProps {
     className?: string;
 }
 /** Lista recolhível de fontes/citações de uma mensagem (vai no `rodape` da `Mensagem`). */
-export declare function Referencias({ itens, abertoInicial, rotulo, rotuloMostrarMais, rotuloMostrarMenos, className, }: ReferenciasProps): import("react").JSX.Element | null;
+export declare function Referencias({ itens, abertoInicial, rotulo: rotuloProp, rotuloMostrarMais: rotuloMostrarMaisProp, rotuloMostrarMenos: rotuloMostrarMenosProp, className, }: ReferenciasProps): import("react").JSX.Element | null;

package/dist/components/SeletorContexto/SeletorContexto.d.ts

@@ -0,0 +1,32 @@
+import { type IconeProp } from '../../utils/Icone.js';
+import { type ItemMenuSuspenso } from '../MenuSuspenso/MenuSuspenso.js';
+export interface OpcaoContexto {
+    id: string;
+    nome: string;
+    /** Linha miúda (ex.: "Pessoal", o CNPJ, a cidade da filial). */
+    descricao?: string;
+    /** Ícone no quadrado; sem ele, as iniciais do nome. */
+    icone?: IconeProp;
+    /** Cor do quadrado: `pri`, `ok`, `warn`, `err`, `info`, `graf-1` a `graf-6` ou qualquer cor CSS. */
+    cor?: string;
+}
+export interface SeletorContextoProps {
+    opcoes: OpcaoContexto[];
+    /** `id` da opção atual. */
+    valor: string;
+    aoMudar: (id: string) => void;
+    /** Título do menu e nome acessível. Padrão "Trocar de espaço". */
+    rotulo?: string;
+    /** Itens depois das opções (ex.: "Gerenciar espaços"), separados por um divisor. */
+    acoes?: ItemMenuSuspenso[];
+    aoEscolherAcao?: (id: string) => void;
+    /** Só o quadrado, sem o nome (topo estreito). Padrão: some sozinho abaixo de 40rem. */
+    compacto?: boolean;
+    className?: string;
+}
+/**
+ * Troca o contexto do sistema inteiro: Pessoal × Empresa, a empresa do grupo,
+ * a filial, a escola. Fica no topo (prop `contexto` da `Estrutura`) ou onde o
+ * app quiser.
+ */
+export declare function SeletorContexto({ opcoes, valor, aoMudar, rotulo: rotuloProp, acoes, aoEscolherAcao, compacto, className }: SeletorContextoProps): import("react").JSX.Element | null;

package/dist/components/SeletorIdioma/Bandeira.d.ts

@@ -0,0 +1,10 @@
+import type { Idioma } from '../../i18n/idiomas.js';
+/**
+ * Bandeira do idioma em SVG próprio (emoji de bandeira não aparece no Windows).
+ * Desenho simplificado, para 1em; decorativa (o nome do idioma vai em texto).
+ * Idioma sem bandeira própria mostra o globo.
+ */
+export declare function Bandeira({ idioma, className }: {
+    idioma: Idioma;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/components/SeletorIdioma/SeletorIdioma.d.ts

@@ -0,0 +1,23 @@
+import { type Idioma } from '../../i18n/idiomas.js';
+import { type AlinhamentoMenu } from '../MenuSuspenso/MenuSuspenso.js';
+export interface SeletorIdiomaProps {
+    /** Idiomas oferecidos, na ordem do menu. Padrão: pt-BR, inglês e espanhol. */
+    idiomas?: readonly Idioma[];
+    /** Idioma atual. Padrão: o do `ProvedorPreferencias`. */
+    valor?: Idioma;
+    /** Padrão: troca o idioma do `ProvedorPreferencias` (que avisa o sistema em `aoMudarIdioma`). */
+    aoMudar?: (idioma: Idioma) => void;
+    /**
+     * `icone` = só a bandeira, num botão redondo (topo da `Estrutura`) ·
+     * `botao` = bandeira e nome do idioma (tela de login, preferências).
+     */
+    aparencia?: 'icone' | 'botao';
+    alinhamento?: AlinhamentoMenu;
+    className?: string;
+}
+/**
+ * Troca o idioma dos textos da biblioteca. Cada idioma aparece com o nome no
+ * próprio idioma ("Português", "English", "Español") e a bandeira; o atual
+ * fica marcado.
+ */
+export declare function SeletorIdioma({ idiomas, valor, aoMudar, aparencia, alinhamento, className }: SeletorIdiomaProps): import("react").JSX.Element;

package/dist/components/Site/CampoPesquisa.d.ts

@@ -12,4 +12,4 @@ export interface CampoPesquisaProps {
     className?: string;
 }
 /** Busca em pílula com botão (`role="search"`), como nas faixas e listagens do site. */
-export declare function CampoPesquisa({ valor, aoMudar, aoPesquisar, placeholder, rotulo, rotuloBotao, aparencia, className }: CampoPesquisaProps): import("react").JSX.Element;
+export declare function CampoPesquisa({ valor, aoMudar, aoPesquisar, placeholder: placeholderProp, rotulo, rotuloBotao: rotuloBotaoProp, aparencia, className }: CampoPesquisaProps): import("react").JSX.Element;

package/dist/components/Site/CardPlano.d.ts

@@ -19,4 +19,4 @@ export interface CardPlanoProps {
     className?: string;
 }
 /** Cartão de plano ou preço: nome, valor, lista do que inclui e o botão de contratar. */
-export declare function CardPlano({ nome, descricao, preco, moeda, periodo, itens, destaque, rotuloDestaque, acao, className }: CardPlanoProps): import("react").JSX.Element;
+export declare function CardPlano({ nome, descricao, preco, moeda, periodo, itens, destaque, rotuloDestaque: rotuloDestaqueProp, acao, className }: CardPlanoProps): import("react").JSX.Element;

package/dist/components/Site/Newsletter.d.ts

@@ -13,4 +13,4 @@ export interface NewsletterProps {
     className?: string;
 }
 /** Inscrição por e-mail (newsletter), para fundo marinho: rodapé ou coluna lateral. */
-export declare function Newsletter({ aoInscrever, titulo, descricao, placeholder, rotuloBotao, mensagemSucesso, aparencia, className, }: NewsletterProps): import("react").JSX.Element;
+export declare function Newsletter({ aoInscrever, titulo: tituloProp, descricao, placeholder: placeholderProp, rotuloBotao: rotuloBotaoProp, mensagemSucesso: mensagemSucessoProp, aparencia, className, }: NewsletterProps): import("react").JSX.Element;

package/dist/components/Site/SumarioPagina.d.ts

@@ -14,4 +14,4 @@ export interface SumarioPaginaProps {
  * seções, com a seção em leitura marcada. Rola até a seção sem trocar o
  * endereço, então funciona também em app com rotas no `#hash`.
  */
-export declare function SumarioPagina({ itens, titulo, className }: SumarioPaginaProps): import("react").JSX.Element;
+export declare function SumarioPagina({ itens, titulo: tituloProp, className }: SumarioPaginaProps): import("react").JSX.Element;

package/dist/components/Tabela/Tabela.d.ts

@@ -54,4 +54,4 @@ export interface TabelaProps<T> {
 }
 /** Mantido por compatibilidade: é o `lerCampo` dos utilitários. */
 export declare const valorDoCampo: typeof lerCampo;
-export declare function Tabela<T>({ colunas, registros, chave, acoes, aparencia, rotulo, carregando, atualizando, erro, aoRecarregar, vazioTitulo, vazioDescricao, vazioIcone, vazioAcoes, ordenacao, aoOrdenar, selecao, selecionados, aoMudarSelecao, aoClicarLinha, paginacao, className, }: TabelaProps<T>): import("react").JSX.Element;
+export declare function Tabela<T>({ colunas, registros, chave, acoes, aparencia, rotulo: rotuloProp, carregando, atualizando, erro, aoRecarregar, vazioTitulo: vazioTituloProp, vazioDescricao, vazioIcone, vazioAcoes, ordenacao, aoOrdenar, selecao, selecionados, aoMudarSelecao, aoClicarLinha, paginacao, className, }: TabelaProps<T>): import("react").JSX.Element;

package/dist/components/TelaLogin/TelaLogin.d.ts

@@ -63,4 +63,4 @@ export interface TelaLoginProps {
     className?: string;
 }
 /** Tela de login institucional: imagem + painel com identificação, senha e 2FA. */
-export declare function TelaLogin({ marca, modelo, apresentacao, ambiente, identificador, titulo, descricao, aoEntrar, aoConfirmarCodigo, confiarDispositivo, instrucaoCodigo, linkSenha, acoes, rodape, className, }: TelaLoginProps): import("react").JSX.Element;
+export declare function TelaLogin({ marca, modelo, apresentacao, ambiente, identificador, titulo: tituloProp, descricao: descricaoProp, aoEntrar, aoConfirmarCodigo, confiarDispositivo, instrucaoCodigo: instrucaoCodigoProp, linkSenha, acoes, rodape, className, }: TelaLoginProps): import("react").JSX.Element;

package/dist/components/Valor/Valor.d.ts

@@ -0,0 +1,53 @@
+import { type ReactNode } from 'react';
+import { type OpcoesMoeda } from '../../utils/dinheiro.js';
+import { type BotaoProps } from '../Botao/Botao.js';
+interface ContextoValores {
+    ocultos: boolean;
+    alternar: () => void;
+    definir: (ocultos: boolean) => void;
+}
+export interface ProvedorValoresProps {
+    children: ReactNode;
+    /** Começa com os valores escondidos. Padrão `false`. */
+    ocultosInicial?: boolean;
+    /**
+     * Chave no `localStorage` para lembrar a escolha entre visitas. Sem ela, vale
+     * só enquanto a página estiver aberta.
+     */
+    chave?: string;
+}
+/** Guarda o "ocultar valores" de uma área: todo `Valor` dentro dela obedece ao `BotaoOcultarValores`. */
+export declare function ProvedorValores({ children, ocultosInicial, chave }: ProvedorValoresProps): import("react").JSX.Element;
+/** `{ ocultos, alternar, definir }` do `ProvedorValores` mais próximo (fora dele, nada fica oculto). */
+export declare function useValoresOcultos(): ContextoValores;
+export type BotaoOcultarValoresProps = Omit<BotaoProps, 'onClick' | 'icone' | 'pressionado' | 'children'>;
+/** Olho que esconde e mostra os valores do `ProvedorValores`. */
+export declare function BotaoOcultarValores({ rotulo, aparencia, severidade, ...resto }: BotaoOcultarValoresProps): import("react").JSX.Element;
+export interface ValorProps extends OpcoesMoeda {
+    valor: number;
+    /**
+     * Cor pelo sinal: verde no positivo, vermelho no negativo. Padrão: `true`
+     * com `tipo`, `false` sem ele.
+     */
+    colorir?: boolean;
+    /**
+     * Força o sentido, para valores guardados sempre positivos: `receita` = entrada (+) ·
+     * `despesa` = saída (−) · `neutro` = sem cor nem `+` (transferência).
+     */
+    tipo?: 'receita' | 'despesa' | 'neutro';
+    /** Força oculto/visível; sem ele, segue o `ProvedorValores`. */
+    oculto?: boolean;
+    tamanho?: 'pequeno' | 'normal' | 'grande' | 'destaque';
+    /** Texto forte. */
+    forte?: boolean;
+    /** Riscado (ex.: lançamento cancelado). */
+    riscado?: boolean;
+    className?: string;
+}
+/**
+ * Valor em dinheiro: `R$ 1.234,56`, com sinal e cor de entrada/saída e o
+ * "ocultar valores" dos apps de finanças. Os números têm largura fixa
+ * (alinham em coluna).
+ */
+export declare function Valor({ valor, colorir, tipo, oculto, tamanho, forte, riscado, className, sinal, ...opcoes }: ValorProps): import("react").JSX.Element;
+export {};