@thibezer/ui-components-kit 2.9.0 → 2.10.0

package/dist/card.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const e=require("./ui-card-BrjBL-yo.cjs");exports.UICard=e.UICard;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const e=require("./ui-card-0wu4rjEX.cjs");exports.UICard=e.UICard;

package/dist/card.js

@@ -1,5 +1,5 @@
 /* empty css               */
-import { U as m } from "./ui-card-BNYCQ7g-.js";
+import { U as m } from "./ui-card-DRtpOo3l.js";
 export {
   m as UICard
 };

package/dist/components/ui-area-texto/area-texto-altura.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Altura automática da área de texto (atributo `auto-altura`).
+ * `calcularAlturaAutomatica` é pura; `ajustarAlturaAutomatica` aplica o resultado no DOM.
+ */
+/**
+ * Altura (px) a aplicar para o conteúdo caber sem rolagem, ou `null` quando o conteúdo cabe nas linhas
+ * mínimas (a altura volta a ser definida por `rows`). Medidas inválidas resultam em `null`.
+ */
+export declare function calcularAlturaAutomatica(alturaConteudo: number, alturaVisivel: number): number | null;
+/**
+ * Faz o `textarea` crescer com o conteúdo. O envoltorio segura a altura atual durante a medição, para a
+ * página não encolher (e rolar sozinha) quando a área está no fim de um documento comprido.
+ */
+export declare function ajustarAlturaAutomatica(textarea: HTMLTextAreaElement, envoltorio: HTMLElement): void;
+/** Devolve a altura ao controle de `rows`/redimensionamento do navegador. */
+export declare function limparAlturaAutomatica(textarea: HTMLTextAreaElement, envoltorio: HTMLElement): void;

package/dist/components/ui-area-texto/area-texto-contador.d.ts

@@ -0,0 +1,6 @@
+import { EstadoContador } from './tipos';
+/**
+ * Estado do contador de caracteres. Função pura: tolera tamanho/limite inválidos (`NaN`, negativos, `Infinity`)
+ * e só gera anúncio para leitores de tela perto do limite, evitando falar a cada tecla.
+ */
+export declare function calcularContador(tamanho: number, limite: number | null): EstadoContador;

package/dist/components/ui-area-texto/area-texto-template.d.ts

@@ -0,0 +1,2 @@
+export declare const ATRIBUTOS_OBSERVADOS_AREA_TEXTO: string[];
+export declare function criarTemplateAreaTexto(): string;

package/dist/components/ui-area-texto/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ui-area-texto';
+export * from './tipos';
+export { calcularContador } from './area-texto-contador';

package/dist/components/ui-area-texto/tipos.d.ts

@@ -0,0 +1,19 @@
+/** Direções em que o usuário pode redimensionar a área de texto (atributo `redimensionar`). */
+export type RedimensionamentoAreaTexto = 'nenhum' | 'vertical' | 'horizontal' | 'ambos';
+/** `detail` de `ui-input` e `ui-change`. */
+export interface DetalheValorAreaTexto {
+    value: string;
+}
+/** `detail` de `ui-enviar` (Ctrl/Cmd + Enter). */
+export interface DetalheEnviarAreaTexto {
+    value: string;
+}
+/** Nível visual do contador de caracteres. */
+export type NivelContador = 'normal' | 'aviso' | 'excedido';
+export interface EstadoContador {
+    /** Texto visível: `42` ou `42 / 500`. */
+    texto: string;
+    nivel: NivelContador;
+    /** Mensagem para leitores de tela; vazia enquanto o nível for `normal`. */
+    anuncio: string;
+}

package/dist/components/ui-area-texto/ui-area-texto.d.ts

@@ -0,0 +1,100 @@
+import { FormAssociatedElement } from '../../core/form-associated-element';
+/**
+ * Área de texto de várias linhas (descrições, observações, laudos) com rótulo, ajuda/erro, contador de
+ * caracteres e altura automática. Participa de `<form>` (FACE).
+ *
+ * @element ui-area-texto
+ *
+ * @attr {string} label - Rótulo visível (sempre texto puro).
+ * @attr {string} placeholder - Texto de apoio quando vazio.
+ * @attr {string} value - Valor inicial (também restaurado por `form.reset()`).
+ * @attr {boolean} obrigatorio - Campo obrigatório (alias `required`).
+ * @attr {number} minlength - Mínimo de caracteres.
+ * @attr {number} maxlength - Máximo de caracteres; também é o limite do contador.
+ * @attr {string} helper-text - Texto de ajuda abaixo do campo.
+ * @attr {boolean} erro - Marca o campo como inválido.
+ * @attr {string} mensagem-erro - Mensagem exibida junto com `erro`.
+ * @attr {string} mensagem-validacao - Substitui as mensagens de validação nativas.
+ * @attr {boolean} disabled - Desabilita o campo.
+ * @attr {boolean} readonly - Somente leitura (continua focável e selecionável).
+ * @attr {number} linhas - Linhas visíveis (1–50, padrão 4).
+ * @attr {boolean} auto-altura - O campo cresce com o conteúdo.
+ * @attr {number} linhas-max - Com `auto-altura`, limite de linhas antes de rolar.
+ * @attr {string} redimensionar - `nenhum` | `vertical` (padrão) | `horizontal` | `ambos`.
+ * @attr {boolean} contador - Exibe o contador de caracteres.
+ *
+ * @fires ui-input - A cada edição. `detail: { value }`.
+ * @fires ui-change - Ao confirmar a edição (blur). `detail: { value }`.
+ * @fires ui-enviar - Ctrl/Cmd + Enter. `detail: { value }`. Enter comum insere quebra de linha.
+ * @fires input - Evento nativo, reemitido no host.
+ * @fires change - Evento nativo, reemitido no host.
+ *
+ * @csspart rotulo - Rótulo.
+ * @csspart campo - Invólucro com borda.
+ * @csspart input - O `<textarea>` interno.
+ * @csspart rodape - Linha de ajuda e contador.
+ * @csspart ajuda - Texto de ajuda ou erro.
+ * @csspart contador - Contador de caracteres.
+ */
+export declare class UIAreaTexto extends FormAssociatedElement {
+    static get observedAttributes(): string[];
+    private labelElement;
+    private wrapperElement;
+    private textareaElement;
+    private helperElement;
+    private contadorElement;
+    private anuncioElement;
+    private listeners;
+    private _focado;
+    private _textareaId;
+    private _defaultValue;
+    private _nivelAnunciado;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    focus(options?: FocusOptions): void;
+    blur(): void;
+    /** Seleciona todo o texto. */
+    select(): void;
+    /** Define a seleção; índices inválidos são ignorados pelo navegador, nunca lançam. */
+    setSelectionRange(inicio: number, fim: number, direcao?: 'forward' | 'backward' | 'none'): void;
+    /** Apaga o texto programaticamente (sem disparar eventos de edição). */
+    limpar(): void;
+    get value(): string;
+    set value(val: string);
+    get name(): string;
+    set name(val: string);
+    get type(): string;
+    get disabled(): boolean;
+    set disabled(val: boolean);
+    get readOnly(): boolean;
+    set readOnly(val: boolean);
+    get minLength(): number;
+    set minLength(val: number);
+    get maxLength(): number;
+    set maxLength(val: number);
+    formResetCallback(): void;
+    formStateRestoreCallback(state: unknown, _mode: 'restore' | 'autocomplete'): void;
+    atualizarValidade(): void;
+    protected syncState(): void;
+    private sincronizarRotulo;
+    private sincronizarLimites;
+    private sincronizarEstadoInterativo;
+    private sincronizarFeedback;
+    private sincronizarContador;
+    private sincronizarAltura;
+    private emitirEdicao;
+    private handleInput;
+    private handleChange;
+    private handleFocus;
+    private handleBlur;
+    /** Ctrl/Cmd + Enter pede o envio sem submeter o `<form>`; Enter comum continua inserindo quebra de linha. */
+    private handleKeyDown;
+    /** Clique em `<label>` externo associado ao host foca o textarea. */
+    private handleHostClick;
+    private handleResize;
+}
+/** Alias semântico: `<ui-textarea>` é idêntico a `<ui-area-texto>`. */
+export declare class UITextarea extends UIAreaTexto {
+}

package/dist/components/ui-campo-texto/campo-texto-estados.d.ts

@@ -9,4 +9,8 @@ export interface ContextoLabelPlaceholder {
 }
 export declare function sincronizarLabelEPlaceholder(ctx: ContextoLabelPlaceholder): void;
 export declare function sincronizarIconeSenha(container: HTMLSpanElement, ehSenhaOuAlternar: boolean, senhaVisivel: boolean): void;
-export declare function sincronizarFeedbackErro(wrapper: HTMLDivElement, input: HTMLInputElement, helper: HTMLDivElement, temErro: boolean, mensagemErro: string | null, helperText: string | null): void;
+/**
+ * Reflete erro e texto de ajuda no campo. `prefixo` é o bloco BEM do componente (padrão `ui-campo-texto`),
+ * permitindo que `<ui-area-texto>` reutilize a mesma regra com suas próprias classes.
+ */
+export declare function sincronizarFeedbackErro(wrapper: HTMLElement, input: HTMLInputElement | HTMLTextAreaElement, helper: HTMLElement, temErro: boolean, mensagemErro: string | null, helperText: string | null, prefixo?: string): void;

package/dist/components/ui-campo-texto/ui-campo-texto.d.ts

@@ -8,6 +8,7 @@ export declare class UICampoTexto extends FormAssociatedElement {
     private rightIconContainer;
     private leftSlotElement;
     private _senhaVisivel;
+    private listeners;
     private _checkTimer;
     private _focado;
     private _inputId;

package/dist/components/ui-canvas-cad/cad-acessibilidade.d.ts

@@ -11,5 +11,11 @@ export declare function textoSelecao(quantidade: number): string;
 export declare function textoFerramenta(ferramenta: string | null): string;
 /** Escreve na região viva (`#cad-status`); trocar o texto é o que dispara o anúncio. */
 export declare function anunciar(shadow: ShadowRoot, texto: string): void;
-/** Liga os anúncios aos eventos que o próprio componente emite; devolve a função que desliga. */
+/** Tempo (ms) que o aviso visível de uma recusa fica na tela. */
+export declare const TEMPO_AVISO_MS = 5000;
+/**
+ * Liga os anúncios aos eventos que o próprio componente emite; devolve a função que desliga.
+ * Recusas de desenho e de edição viram aviso visível e anúncio, a menos que o host tenha o atributo `sem-avisos`
+ * (o consumidor mostra o próprio aviso a partir de `cad-desenho-recusado` / `cad-edicao-recusada`).
+ */
 export declare function conectarAnuncios(host: HTMLElement, shadow: ShadowRoot): () => void;

package/dist/components/ui-canvas-cad/cad-recusas.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Textos (pt-BR) das recusas do <ui-canvas-cad>: o motivo que sai em `cad-desenho-recusado` e `cad-edicao-recusada`
+ * vira uma frase para o aviso visível e para o leitor de tela. Funções puras; motivo desconhecido recebe um texto genérico.
+ */
+export declare function textoDesenhoRecusado(motivo: unknown): string;
+export declare function textoEdicaoRecusada(motivo: unknown): string;

package/dist/components/ui-card/card-interacao.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Quando um clique ou uma tecla vinda de dentro do card deve ativá-lo.
+ * Responsabilidade única: decidir, sem tocar no DOM, se o evento pertence ao card ou a um controle interno.
+ */
+/**
+ * O alvo é (ou está dentro de) um controle com comportamento próprio, entre ele e a `raiz` (o host do card)?
+ * Aceita `Element`, e não só `HTMLElement`: o alvo de um clique num ícone é o `<path>` do SVG.
+ * Controles fora da `raiz` não contam (um card dentro de um `<a>` ou `<label>` continua clicável), e o próprio
+ * host e o `role="button"` da base do card não são "controle interno".
+ */
+export declare function ehControleInterno(alvo: EventTarget | null | undefined, raiz: Element): boolean;
+/**
+ * A tecla ativa o card? Só Enter/Espaço pressionados no próprio card, sem repetição (tecla mantida) e sem
+ * Ctrl/Alt/Meta. Teclas vindas de controles internos (campo, botão) não são do card: ativá-lo e chamar
+ * `preventDefault` impediria digitar espaço num `<input>` ou acionar o botão.
+ */
+export declare function teclaAtivaCard(e: Pick<KeyboardEvent, 'key' | 'repeat' | 'ctrlKey' | 'altKey' | 'metaKey' | 'target'>, base: EventTarget): boolean;

package/dist/components/ui-card/card-secoes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Seções opcionais do card (mídia, cabeçalho, rodapé).
+ * Responsabilidade única: dizer se um grupo de slots (nome em português e alias em inglês) tem conteúdo.
+ */
+/**
+ * Há conteúdo atribuído a algum dos slots `nomes`? Conta elementos e texto não vazio (espaços e quebras de linha
+ * entre as tags não contam). Também olha os filhos diretos do host com `slot="..."`, que cobre o intervalo antes do
+ * `slotchange`. Só filhos diretos: um `[slot]` aninhado em outro elemento pertence a outro componente.
+ */
+export declare function secaoTemConteudo(raiz: ShadowRoot | null, host: Element, nomes: readonly string[]): boolean;

package/dist/components/ui-card/ui-card.d.ts

@@ -1,4 +1,24 @@
 import { SafeHTMLElement } from '../../core/ssr-safe';
+/**
+ * Cartão de conteúdo com mídia, cabeçalho, corpo e rodapé opcionais; pode ser clicável (vira um botão).
+ *
+ * @attr {'plano'|'elevado'|'destaque'} elevacao - Profundidade visual (alias `elevation`).
+ * @attr {'plano'|'elevado'|'destaque'} variante - Estilo adicional (alias `variant`); valores desconhecidos são ignorados.
+ * @attr {boolean} clicavel - Torna o card um botão focável que emite `ui-clique` (alias `clickable`).
+ * @attr {boolean} compacto - Reduz os espaçamentos internos (alias `compact`).
+ * @attr {boolean} disabled - Desativa a interação e reduz a opacidade.
+ * @attr {string} aria-label - Nome acessível do card clicável (um card sem clique não é anunciado como controle).
+ * @slot - Corpo do card.
+ * @slot midia - Imagem ou vídeo no topo (alias `media`).
+ * @slot cabecalho - Título e ações (alias `header`); a seção some quando vazia.
+ * @slot rodape - Ações e metadados (alias `footer`); a seção some quando vazia.
+ * @csspart base - O contêiner do card.
+ * @csspart midia - A seção de mídia.
+ * @csspart cabecalho - A seção de cabeçalho.
+ * @csspart corpo - A seção do corpo.
+ * @csspart rodape - A seção de rodapé.
+ * @fires ui-clique - Card clicável ativado por clique, Enter ou Espaço (`detail.id`); também emitido como `ui-click`.
+ */
 export declare class UICard extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private cardElement;
@@ -8,6 +28,8 @@ export declare class UICard extends SafeHTMLElement {
     disconnectedCallback(): void;
     attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
     private handleSlotChange;
+    /** Leva o foco ao card clicável e habilitado; nos demais casos mantém o comportamento nativo do host. */
+    focus(options?: FocusOptions): void;
     get clicavel(): boolean;
     set clicavel(val: boolean);
     get disabled(): boolean;
@@ -15,4 +37,5 @@ export declare class UICard extends SafeHTMLElement {
     private syncState;
     private handleClick;
     private handleKeyDown;
+    private emitirClique;
 }

package/dist/components/ui-texto/ui-texto.d.ts

@@ -3,6 +3,22 @@ export type VarianteTexto = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'corpo' |
 export type CorTexto = 'primaria' | 'secundaria' | 'destaque' | 'erro' | 'sucesso' | 'alerta';
 export type PesoTexto = 'normal' | 'medio' | 'seminegrito' | 'negrito';
 export type AlinhamentoTexto = 'esquerda' | 'centro' | 'direita' | 'justificado';
+/**
+ * Tipografia semântica do kit. Texto longo: `linhas` limita o bloco a N linhas com reticências
+ * e o conteúdo quebra palavras muito compridas em vez de estourar o contêiner.
+ *
+ * @element ui-texto
+ *
+ * @attr {string} variante - `h1`–`h6`, `corpo` (padrão), `corpo-sm`, `caption`, `codigo`.
+ * @attr {string} tag - Tag semântica do elemento interno (somente tags de texto permitidas).
+ * @attr {string} cor - `primaria`, `secundaria`, `destaque`, `erro`, `sucesso`, `alerta`.
+ * @attr {string} peso - `normal`, `medio`, `seminegrito`, `negrito`.
+ * @attr {string} alinhamento - `esquerda`, `centro`, `direita`, `justificado`.
+ * @attr {boolean} truncar - Uma linha com reticências.
+ * @attr {number} linhas - Limita a N linhas (1–50) com reticências; `truncar` tem prioridade.
+ *
+ * @csspart base - O elemento de texto interno.
+ */
 export declare class UITexto extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private container;

package/dist/core/alvo-digitavel.d.ts

@@ -1 +1,6 @@
+/**
+ * O alvo real do evento (atravessando shadow roots) é um botão, link ou outro controle acionável?
+ * Serve para atalhos globais de Enter: com o foco num botão, o Enter pertence ao botão.
+ */
+export declare function focoEmControleAcionavel(evento: Event): boolean;
 export declare function focoEmCampoDeTexto(evento?: Event): boolean;

package/dist/core/opcoes.d.ts

@@ -7,3 +7,10 @@
 export declare function escolherOpcao<T extends string>(valor: string | null | undefined, permitidas: readonly T[], padrao: T): T;
 /** Como `escolherOpcao`, mas devolve `null` quando o valor não é reconhecido (opção opcional). */
 export declare function escolherOpcaoOpcional<T extends string>(valor: string | null | undefined, permitidas: readonly T[]): T | null;
+/**
+ * Converte um atributo numérico (hostil por definição) num inteiro dentro de [minimo, maximo].
+ * Texto vazio, não numérico, `NaN` ou `Infinity` devolvem `padrao`; valores fora da faixa são limitados.
+ */
+export declare function escolherInteiro(valor: string | number | null | undefined, minimo: number, maximo: number, padrao: number): number;
+/** Inteiro >= `minimo` ou `null` quando ausente/inválido (para limites opcionais como `maxlength`). */
+export declare function inteiroOuNulo(valor: string | null | undefined, minimo?: number): number | null;

package/dist/cores.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const r=require("./ui-controle-cores-uY__TgwW.cjs");exports.PALETA_CORES_PADRAO=r.PALETA_CORES_PADRAO;exports.UIControleCores=r.UIControleCores;exports.UISeletorCor=r.UISeletorCor;exports.abrirSeletorCor=r.abrirSeletorCor;exports.coresUnicas=r.coresUnicas;exports.escaparHtml=r.escaparHtml;exports.fecharSeletorCor=r.fecharSeletorCor;exports.normalizarCor=r.normalizarCor;exports.normalizarOpacidade=r.normalizarOpacidade;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const r=require("./ui-seletor-cor-2yGryC_Z.cjs"),e=require("./ui-controle-cores-BLhrZHMh.cjs");exports.PALETA_CORES_PADRAO=r.PALETA_CORES_PADRAO;exports.UISeletorCor=r.UISeletorCor;exports.abrirSeletorCor=r.abrirSeletorCor;exports.coresUnicas=r.coresUnicas;exports.escaparHtml=r.escaparHtml;exports.fecharSeletorCor=r.fecharSeletorCor;exports.normalizarCor=r.normalizarCor;exports.normalizarOpacidade=r.normalizarOpacidade;exports.UIControleCores=e.UIControleCores;

package/dist/cores.js

@@ -1,13 +1,14 @@
 /* empty css               */
-import { P as e, U as s, a as l, b as t, c as C, e as c, f as i, n as m, d as n } from "./ui-controle-cores-DgEza3wF.js";
+import { P as e, U as s, a as t, c as l, e as C, f as c, n as i, b as m } from "./ui-seletor-cor-BuyhoDZz.js";
+import { U as p } from "./ui-controle-cores-BEUKOq4n.js";
 export {
   e as PALETA_CORES_PADRAO,
-  s as UIControleCores,
-  l as UISeletorCor,
+  p as UIControleCores,
+  s as UISeletorCor,
   t as abrirSeletorCor,
-  C as coresUnicas,
-  c as escaparHtml,
-  i as fecharSeletorCor,
-  m as normalizarCor,
-  n as normalizarOpacidade
+  l as coresUnicas,
+  C as escaparHtml,
+  c as fecharSeletorCor,
+  i as normalizarCor,
+  m as normalizarOpacidade
 };