@thibezer/ui-components-kit 1.0.0 → 2.1.0

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

@@ -1,6 +1,5 @@
 import { SafeHTMLElement } from '../../core/ssr-safe';
 export declare class UIModal extends SafeHTMLElement {
-    static _openCount: number;
     static get observedAttributes(): string[];
     private backdropElement;
     private dialogElement;
@@ -9,21 +8,37 @@ export declare class UIModal extends SafeHTMLElement {
     private _elementoGatilho;
     private _focables;
     private _tituloId;
-    private _elementosInertes;
+    /** Estado já aplicado (pilha, inert, scroll, eventos); difere de `aberto` durante uma transição. */
+    private _estaAberto;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
-    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
     private handleSlotChange;
     get aberto(): boolean;
     set aberto(val: boolean);
     abrir(): void;
+    /** Fecha o modal, exceto com `bloquear-fechamento` (remova o atributo ou use `aberto = false` para forçar). */
     fechar(): void;
+    /**
+     * Abrir/fechar pelo método, pela propriedade ou pelo atributo (`aberto`/`open`, comum em
+     * React/Vue) passa sempre por aqui: mesmos eventos, mesmo foco e mesma camada de inert.
+     */
+    private aoAbrir;
+    private aoFechar;
+    /**
+     * Foco inicial: `[autofocus]`, senão o primeiro controle do conteúdo/rodapé.
+     * O botão "✕" não recebe o foco inicial, evitando fechar o modal com um Enter acidental;
+     * sem controles, o próprio diálogo é focado para que o leitor de tela anuncie o título.
+     */
+    private focarConteudoInicial;
     private syncState;
     private handleBackdropClick;
     private handleCloseClick;
+    private static ehFocavel;
+    /** Focáveis do conteúdo projetado (corpo e rodapé), na ordem dos slots. */
+    private obterFocaveisDoConteudo;
     private _atualizarFocables;
-    private _isTopMostModal;
     private handleKeyDown;
 }
 export declare class UIDialog extends UIModal {

package/dist/components/ui-seletor-mapa-base/ui-seletor-mapa-base.d.ts

@@ -26,6 +26,8 @@ export declare class UISeletorMapaBase extends SafeHTMLElement {
     set aberto(valor: boolean);
     get compacto(): boolean;
     set compacto(valor: boolean);
+    get desabilitado(): boolean;
+    set desabilitado(valor: boolean);
     get mapasBase(): MapaBaseItem[];
     definirMapasBase(novosMapas: MapaBaseItem[]): void;
     abrir(): void;
@@ -36,6 +38,7 @@ export declare class UISeletorMapaBase extends SafeHTMLElement {
     private aplicarEstadoAberto;
     private atualizarGatilho;
     private renderizarOpcoes;
+    private focarItem;
     private atualizarSelecaoVisual;
     private conectarEventos;
 }

package/dist/components/ui-tabela/tabela-atributos-sync.d.ts

@@ -5,6 +5,9 @@ export interface ContextoAtributosTabela {
     loadingElement: HTMLDivElement | null;
     onTextoVazioAlterado: (texto: string) => void;
     onVirtualizarAlterado: (virtualizar: boolean) => void;
+    /** O atributo `src` foi lido (sem buscar nada); `null` = sem atributo. */
+    onSrcLido: (src: string | null) => void;
+    /** O atributo `src` mudou com o elemento conectado: busca os dados. */
     onCarregarSrc: (src: string) => void;
     onCarregandoAlterado: (carregando: boolean) => void;
     onRenderBody: () => void;

package/dist/components/ui-tabela/tabela-corpo.d.ts

@@ -9,6 +9,8 @@ export interface ContextoCorpoTabela {
     chaveId: string;
     virtualizar: boolean;
     rowHeight: number;
+    /** Linha que recebe tabindex=0 (foco móvel); fora da janela renderizada, vale a primeira visível. */
+    indiceAtivo?: number | null;
     isItemSelecionado: (item: Record<string, any>, index: number) => boolean;
     onLinhaClique: (item: Record<string, any>, index: number) => void;
     formatWidth: (largura?: string | number) => string;

package/dist/components/ui-tabela/tabela-localizador.d.ts

@@ -1,4 +1,11 @@
+/** Converte `idOuIndice` em índice de linha válido, ou -1. Aceita número inteiro ou string só com dígitos. */
+export declare function interpretarIndice(idOuIndice: string | number, total: number): number;
 /**
  * Localiza o índice de um item pelo ID, chave customizada, predicado funcional ou índice direto.
+ *
+ * Ordem de busca: predicado → chave configurada (`chaveId`) em todos os itens → chaves
+ * alternativas (`id`, `_id`, `codigo`, `key`), uma de cada vez → índice numérico.
+ * Assim um item cujo `codigo` coincide com o valor nunca "rouba" o item da chave configurada.
+ * Com `porIndice`, o valor é tratado apenas como índice de linha (sem ambiguidade com IDs numéricos).
  */
-export declare function localizarIndiceItem(dados: Record<string, any>[], idOuIndice: string | number | ((item: any, idx: number) => boolean), chaveId?: string): number;
+export declare function localizarIndiceItem(dados: Record<string, any>[], idOuIndice: string | number | ((item: any, idx: number) => boolean), chaveId?: string, porIndice?: boolean): number;

package/dist/components/ui-tabela/tabela-orquestrador-dados.d.ts

@@ -5,6 +5,9 @@ export declare class TabelaOrquestradorDados {
     private colunaOrdenada;
     private direcaoOrdenacao;
     private ultimoFiltro;
+    /** Colunas declaradas: o filtro olha só elas (vazio = todos os campos do registro). */
+    private colunasFiltro;
+    setColunasFiltro(ids: string[]): void;
     getDadosOriginais(): Record<string, any>[];
     setDadosOriginais(dados: Record<string, any>[]): void;
     getDadosExibicao(): Record<string, any>[];
@@ -13,6 +16,7 @@ export declare class TabelaOrquestradorDados {
     getDirecaoOrdenacao(): 'asc' | 'desc' | 'original';
     setDirecaoOrdenacao(dir: 'asc' | 'desc' | 'original'): void;
     alternarOrdenacaoColuna(coluna: TabelaColuna): UISortDetail | null;
+    /** Recalcula a lista exibida: ordenação da coluna e, por cima, o filtro vigente (os dois valem juntos). */
     aplicarOrdenacao(): void;
     filtrar(termo: string): void;
 }

package/dist/components/ui-tabela/tabela-renderizador.d.ts

@@ -19,6 +19,7 @@ export interface ContextoOrquestradorRender {
     chaveId: string;
     virtualizar: boolean;
     rowHeight: number;
+    indiceAtivo: number | null;
     onSetIsResizing: (resizing: boolean) => void;
     onActiveResizeCleanup: (cleanup: (() => void) | null) => void;
     onHeaderClick: (col: TabelaColuna) => void;

package/dist/components/ui-tabela/tabela-selecao.d.ts

@@ -1,22 +1,37 @@
 import { UIRowScrollOptions } from './tipos';
+/**
+ * Contexto lido sob demanda (getters): dados, chave e tbody sempre refletem o estado atual da tabela,
+ * mesmo após ordenar, filtrar, trocar dados ou mudar `chave-id`.
+ */
 export interface ContextoTabelaSelecao {
     host: HTMLElement;
-    tbodyElement: HTMLTableSectionElement | null;
-    containerElement: HTMLDivElement | null;
-    dadosExibicao: Record<string, any>[];
-    chaveId: string;
-    getRowHeight: () => number;
-    onRenderBody: () => void;
+    getTbody: () => HTMLTableSectionElement | null;
+    getDadosExibicao: () => Record<string, any>[];
+    getDadosOriginais: () => Record<string, any>[];
+    getChaveId: () => string;
+    /** Posiciona a linha exibida `indice` na área visível; retorna false se a tabela ainda não foi montada. */
+    onRolarParaIndice: (indice: number, comportamento: 'smooth' | 'auto') => boolean;
+    /** Chamado quando uma seleção programática muda a linha ativa (foco móvel do teclado). */
+    onLinhaAtiva: (indice: number) => void;
 }
 export declare class TabelaSelecaoController {
     private ctx;
     private itemSelecionado;
     private indiceSelecionado;
     constructor(ctx: ContextoTabelaSelecao);
+    /** Mesmo objeto ou mesmo valor na chave configurada. */
+    private indiceDoItem;
     getItemSelecionado(): Record<string, any> | null;
     setItemSelecionado(item: Record<string, any> | null): void;
     getIndiceSelecionado(): number | null;
     setIndiceSelecionado(idx: number | null): void;
+    /**
+     * Reaplica a seleção após ordenar, filtrar ou trocar os dados.
+     * - Item ainda exibido: atualiza o índice (e a referência, se veio um objeto novo com a mesma chave).
+     * - Item só escondido pelo filtro: mantém a seleção (sem índice) para reaparecer ao limpar o filtro.
+     * - Item removido dos dados: limpa a seleção e emite `ui-selecao-removida`.
+     */
+    reconciliar(): void;
     limparSelecao(): void;
     isItemSelecionado(item: Record<string, any>, index: number): boolean;
     atualizarLinhasSelecionadas(): void;

package/dist/components/ui-tabela/tipos.d.ts

@@ -24,4 +24,10 @@ export interface UIColumnResizeDetail {
 export interface UIRowScrollOptions {
     comportamento?: 'smooth' | 'auto';
     selecionar?: boolean;
+    /** Trata o valor apenas como índice da linha exibida, nunca como ID (evita ambiguidade com IDs numéricos). */
+    porIndice?: boolean;
+}
+export interface UISelecaoRemovidaDetail {
+    /** Item que estava selecionado e deixou de existir nos dados. */
+    item: Record<string, any>;
 }

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

@@ -1,6 +1,6 @@
-import { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions } from './tipos';
+import { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions, UISelecaoRemovidaDetail } from './tipos';
 import { SafeHTMLElement } from '../../core/ssr-safe';
-export type { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions };
+export type { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions, UISelecaoRemovidaDetail };
 export declare class UITabela extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private shadow;
@@ -20,6 +20,13 @@ export declare class UITabela extends SafeHTMLElement {
     private _scrollHandler;
     private _activeResizeCleanup;
     private _headerListeners;
+    private _corpoListeners;
+    /** Linha com o foco móvel (navegação por teclado); null = primeira linha visível. */
+    private _indiceAtivo;
+    /** Altura real das linhas medida no DOM; null = usa a estimativa da densidade. */
+    private _alturaLinhaMedida;
+    /** Cancela a correção pendente de uma rolagem suave anterior. */
+    private _cancelarCorrecaoRolagem;
     private remotaController;
     private selecaoController;
     private dadosController;
@@ -27,6 +34,8 @@ export declare class UITabela extends SafeHTMLElement {
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(name: string, _oldVal: string | null, newVal: string | null): void;
+    /** Nome acessível vem do host (`aria-label`); `aria-busy` acompanha o carregamento remoto. */
+    private sincronizarAria;
     private syncAttributes;
     private obterContextoAtributos;
     get src(): string | null;
@@ -61,13 +70,58 @@ export declare class UITabela extends SafeHTMLElement {
     get textoVazio(): string;
     set textoVazio(txt: string);
     private handleHeaderClick;
+    /** Altura fixa das linhas em px (`altura-linha`), sobrepõe a densidade; null = vale a densidade. */
+    get alturaLinha(): number | null;
+    set alturaLinha(val: number | null);
+    /** Publica a altura fixa como variável CSS (usada pelo estilo `:host([altura-linha])`). */
+    private aplicarAlturaLinha;
+    /** Altura usada na virtualização: a fixa (`altura-linha`), a medida no DOM ou a estimativa da densidade. */
     private getRowHeight;
+    /**
+     * Mede a altura real das linhas uma vez por configuração (densidade/colunas): padding, fonte e
+     * renderizadores customizados mudam a altura, e a estimativa fixa desalinharia a janela virtual.
+     * Não remede a cada rolagem para os espaçadores não "pularem" com linhas de alturas diferentes.
+     */
+    private medirAlturaLinha;
+    /** Ordenar, filtrar, trocar os dados ou a chave mantém a linha selecionada (se ainda existir). */
     private atualizarContextoSelecao;
     renderTotal(): void;
+    /** Mantém um único tabindex=0 (foco móvel): Tab entra na tabela pela última linha ativa. */
+    private handleFocoLinha;
+    private definirLinhaAtiva;
+    /**
+     * Teclado nas linhas: setas, Home/End e PageUp/PageDown movem o foco;
+     * Enter/Espaço selecionam a linha (mesmo caminho do clique, emite `ui-linha-clique`).
+     */
+    private handleTecladoCorpo;
+    private linhasPorPagina;
+    /** Foca a linha, renderizando a janela virtual se necessário, e a mantém visível abaixo do cabeçalho fixo. */
+    private focarLinha;
+    /**
+     * Quanto o container precisa rolar para a linha ficar inteira na área útil: abaixo do cabeçalho
+     * fixo e acima da barra de rolagem horizontal. 0 = já visível. Linha maior que a área alinha pelo topo.
+     */
+    private deslocamentoAteLinha;
+    /** Rola só o container da tabela (nunca a página, ao contrário de `scrollIntoView`). */
+    private rolarContainer;
+    /**
+     * Posiciona a linha exibida `indice` na área visível.
+     * Fora da janela virtual, rola até a posição estimada, renderiza a janela e corrige pela posição
+     * real da linha. No modo suave a correção ocorre ao fim da animação (`scrollend`, com timeout de
+     * segurança para navegadores sem o evento ou quando não há rolagem a fazer).
+     */
+    private posicionarLinha;
     private obterContextoRenderizador;
     private renderHeader;
     renderBody(): void;
+    /**
+     * Rola até um item e opcionalmente o seleciona. Aceita ID (pela `chave-id`, depois `id`, `_id`,
+     * `codigo`, `key`), predicado ou índice. Um número é procurado primeiro como ID; use
+     * `{ porIndice: true }` ou `rolarParaIndice()` para tratá-lo só como índice da linha exibida.
+     */
     rolarPara(idOuIndice: string | number | ((item: any, index: number) => boolean), opcoes?: UIRowScrollOptions): boolean;
+    /** Rola até a linha exibida de índice `indice` (posição após ordenação/filtro, base 0). */
+    rolarParaIndice(indice: number, opcoes?: Omit<UIRowScrollOptions, 'porIndice'>): boolean;
 }
 export * from './tabela-ordenacao';
 export * from './tabela-localizador';

package/dist/components/ui-tabela-propriedades/avaliador-expressao.d.ts

@@ -1,6 +1 @@
-/**
- * Avaliador de expressões matemáticas para campos numéricos técnicos (AutoCAD / Revit / Blender).
- * Parser seguro de descida recursiva sem eval(), com suporte a +, -, *, /, ^, parênteses,
- * porcentagens, constantes (pi, e) e funções matemáticas (sqrt, abs, round, floor, ceil, sin, cos, tan).
- */
 export declare function avaliarExpressaoMatematica(expr: string): number | null;

package/dist/components/ui-tabela-propriedades/propriedades-dom-utils.d.ts

@@ -1,6 +1,22 @@
 import { CategoriaPropriedades } from './tipos';
-export declare function focarProximoEditor(shadow: ShadowRoot, atual: HTMLElement): void;
+/**
+ * Linha de uma propriedade. Compara o atributo em vez de montar um seletor CSS com o id:
+ * ids com aspas, colchetes ou barras não quebram a consulta.
+ */
+export declare function buscarLinhaPropriedade(raiz: ParentNode | null | undefined, propId: string): HTMLElement | null;
+/** Cada editor registra como refletir um novo valor (usado por `definirValor` e pelo scrubber). */
+export declare function registrarAtualizadorEditor(editor: Element, atualizar: (valor: any) => void): void;
+/**
+ * Atualiza o editor na tela para o novo valor, qualquer que seja o tipo (texto, número, seleção,
+ * booleano, cores, linha). Não recria a linha: preserva foco e arrastos em andamento.
+ */
 export declare function atualizarCampoVisual(shadow: ShadowRoot, propId: string, novoValor: any): void;
+/**
+ * Seleciona a opção correspondente ao valor. Valor fora da lista ganha uma opção própria
+ * (`data-externa`) em vez de o select exibir a primeira opção como se fosse o valor real.
+ */
+export declare function sincronizarSelect(select: HTMLSelectElement, valor: any, corresponde?: (opcao: string, valor: any) => boolean, rotuloExterno?: (valor: any) => string): void;
+export declare function focarProximoEditor(shadow: ShadowRoot, atual: HTMLElement): void;
 export declare function expandirTodasCategorias(shadow: ShadowRoot, categorias: CategoriaPropriedades[]): void;
 export declare function colapsarTodasCategorias(shadow: ShadowRoot, categorias: CategoriaPropriedades[]): void;
 export declare function alternarCategoria(shadow: ShadowRoot, host: HTMLElement, categorias: CategoriaPropriedades[], idCategoria: string): void;

package/dist/components/ui-tabela-propriedades/propriedades-flutuante.d.ts

@@ -1,6 +1,8 @@
 import { ListenerBag } from '../../core/listener-bag';
 /**
  * Aplica ao host o posicionamento flutuante (fixed) ou o restaura ao fluxo normal.
+ * Ao acoplar, devolve a largura/altura originais (o painel não fica preso em 300×480);
+ * ao flutuar de novo, volta à última posição e tamanho flutuantes.
  * Retorna o novo estado (true = flutuante).
  */
 export declare function alternarPosicionamentoFlutuante(host: HTMLElement): boolean;

package/dist/components/ui-tabela-propriedades/propriedades-gerenciador-valores.d.ts

@@ -7,20 +7,29 @@ export interface ContextoGerenciadorValores {
     onRenderCategorias: () => void;
     isModoManual: () => boolean;
 }
+/** Igualdade de valores de propriedade: estrita, com null/undefined equivalentes e NaN igual a NaN. */
+export declare function valoresIguais(a: any, b: any): boolean;
 export declare class GerenciadorValoresPropriedades {
     private ctx;
     private valoresOriginais;
     private valoresAtuais;
-    private dirty;
     constructor(ctx: ContextoGerenciadorValores);
     inicializarCategorias(categorias: CategoriaPropriedades[]): void;
+    /** Há alguma propriedade com valor diferente do original (último aplicar/carregar)? */
     get isDirty(): boolean;
+    isModificada(propId: string): boolean;
     getValores(): Record<string, any>;
+    getValoresOriginais(): Record<string, any>;
     setValores(novosValores: Record<string, any>): void;
     obterValor(propId: string): any;
+    /** Alteração programática: atualiza o editor na tela; não emite se o valor não mudou. */
     definirValor(propId: string, novoValor: any, emitirEvento?: boolean): void;
+    /** Alteração feita pelo usuário num editor. Em modo manual só emite no Aplicar. */
     registrarAlteracao(categoriaId: string, propId: string, novoValor: any): void;
     aplicar(): void;
     desfazer(): void;
+    /** Marca/desmarca a linha e recalcula os botões do rodapé (voltar ao original limpa o estado). */
+    private aposAlterar;
+    private categoriaDe;
     private emitirAlteracao;
 }

package/dist/components/ui-tabela-propriedades/propriedades-render-arvore.d.ts

@@ -2,8 +2,10 @@ import { ItemPropriedade, CategoriaPropriedades } from './tipos';
 import { ContextoEditorPropriedade } from './propriedades-editores';
 export interface ContextoLinhaPropriedade {
     valoresAtuais: Record<string, any>;
+    /** Valores do último carregar/aplicar: a linha é marcada como modificada quando difere deles. */
     valoresOriginais: Record<string, any>;
-    isDirty: boolean;
+    /** @deprecated Não é mais usado: o destaque compara cada valor com o original. */
+    isDirty?: boolean;
     editorCtx: ContextoEditorPropriedade;
     onAtualizarCampoVisual: (propId: string, novoValor: any) => void;
 }

package/dist/components/ui-tabela-propriedades/ui-tabela-propriedades.d.ts

@@ -32,7 +32,11 @@ export declare class UITabelaPropriedades extends SafeHTMLElement {
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
-    attributeChangedCallback(name: string, _oldVal: string | null, newVal: string | null): void;
+    /**
+     * Cada atributo atualiza só o que depende dele: redesenhar todas as linhas (ex.: ao trocar o
+     * `titulo`) tiraria o foco de um campo em edição.
+     */
+    attributeChangedCallback(name: string, oldVal: string | null, newVal: string | null): void;
     get categorias(): CategoriaPropriedades[];
     set categorias(novasCategorias: CategoriaPropriedades[]);
     get tipos(): SeletorTipoItem[];

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

@@ -4,6 +4,9 @@ export declare class UITooltip extends SafeHTMLElement {
     private containerElement;
     private bubbleElement;
     private _posicionamentoAtivo;
+    private _timerOcultar;
+    /** Gatilho que recebeu `aria-description` deste tooltip (para remover depois). */
+    private _gatilhoDescrito;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
@@ -18,6 +21,18 @@ export declare class UITooltip extends SafeHTMLElement {
     private syncState;
     private handleMouseEnter;
     private handleMouseLeave;
+    private cancelarOcultar;
+    /**
+     * Escape fecha o tooltip sem mover o foco (WCAG 1.4.13). Ouvido na captura e interrompido,
+     * para que dentro de um modal o primeiro Escape feche só o tooltip.
+     */
+    private handleEscape;
+    /**
+     * O balão vive no Shadow DOM, fora do alcance de `aria-describedby` do gatilho (light DOM).
+     * O texto é exposto como `aria-description` no gatilho, sem sobrescrever uma descrição do consumidor.
+     */
+    private sincronizarDescricao;
+    private removerDescricao;
     private handleClick;
     private handleClickOutside;
 }

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

@@ -0,0 +1 @@
+export declare function focoEmCampoDeTexto(evento?: Event): boolean;

package/dist/core/form-submissao.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Submissão de formulários a partir de controles encapsulados no Shadow DOM.
+ * O <button> e o <input> internos não pertencem ao <form> do consumidor, então
+ * o navegador não reconhece o botão como "submitter" nem o Enter no campo como
+ * submissão implícita. Estas funções reproduzem o comportamento nativo.
+ */
+/**
+ * Submete o formulário com validação nativa. Quando `nome` é informado, um <button>
+ * temporário leva o par nome/valor ao FormData, como faria um submitter nativo.
+ */
+export declare function submeterFormulario(form: HTMLFormElement, nome?: string | null, valor?: string | null): void;
+/**
+ * Submissão implícita (Enter em um campo de texto): aciona o botão padrão do formulário
+ * ou, sem botão, submete apenas se houver um único campo de texto.
+ */
+export declare function submeterImplicitamente(form: HTMLFormElement): void;

package/dist/core/index.d.ts

@@ -5,3 +5,4 @@ export * from './leaflet-loader';
 export * from './ssr-safe';
 export * from './form-validacao';
 export * from './acessibilidade';
+export * from './svg-seguro';

package/dist/core/parts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Liga ou desliga um nome no atributo `part`, expondo estados ao CSS do consumidor
+ * (ex.: `ui-tabela::part(linha-selecionada)`). Usa o atributo em vez de `Element.part`
+ * para funcionar também em ambientes sem DOMTokenList de part (SSR, happy-dom).
+ */
+export declare function alternarPart(el: Element, nome: string, ativo: boolean): void;

package/dist/core/rotulo.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Escreve o texto do rótulo sempre como texto puro (nunca HTML), evitando que um
+ * `label` vindo de dados do servidor injete marcação. Quando obrigatório, acrescenta
+ * o asterisco decorativo, oculto de leitores de tela.
+ */
+export declare function renderizarRotulo(rotulo: HTMLElement, texto: string, obrigatorio: boolean, classeAsterisco: string): void;

package/dist/core/svg-seguro.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Higienização de ícones SVG vindos de dados (props, APIs, configuração do usuário).
+ *
+ * Lista de permissão de elementos: tudo fora dela é removido com o conteúdo — inclusive
+ * `script`, `foreignObject`, `a`, `image`, `animate`/`set` (que podem reescrever `href`)
+ * e `style`. Atributos `on*` são removidos; `href` só aceita referências locais (`#id`);
+ * valores com `javascript:`/`data:`/`vbscript:` ou `url()` externo são descartados.
+ */
+/** Retorna o `<svg>` higienizado (já pronto para inserir no DOM) ou null se não houver SVG. */
+export declare function higienizarSvg(codigo: string): SVGSVGElement | null;

package/dist/core/ui-bus.d.ts

@@ -28,6 +28,7 @@ export interface UIBusEventsMap {
 export type UIEmitterCallback<T = any> = (dados?: T) => void;
 declare class UIBusManager {
     private listeners;
+    constructor();
     /**
      * Registra um ouvinte para um canal ou evento global tipado.
      */
@@ -54,6 +55,7 @@ declare class UIBusManager {
     abrirModal(idModal: string): boolean;
     /**
      * Fecha um modal pelo seu ID ou todos os modais abertos se nenhum ID for passado.
+     * Retorna `false` se o modal não existir ou continuar aberto (`bloquear-fechamento`).
      */
     fecharModal(idModal?: string): boolean;
     /**
@@ -77,9 +79,18 @@ declare class UIBusManager {
      */
     definirDensidade(densidade: 'compacta' | 'normal' | 'padrao' | 'relaxada' | number): void;
     /**
-     * Alterna ou define o tema visual global.
+     * Tema em vigor: o forçado na raiz (`data-tema`, `data-theme`, `.dark`/`.light`)
+     * ou, sem nenhum, o do sistema operacional (`prefers-color-scheme`).
      */
-    definirTema(tema?: 'claro' | 'escuro'): string;
+    obterTema(): 'claro' | 'escuro';
+    /**
+     * Define o tema global. Sem argumento, alterna o tema em vigor;
+     * `'auto'` remove o tema forçado e volta a seguir o sistema operacional.
+     */
+    definirTema(tema?: 'claro' | 'escuro' | 'auto'): 'claro' | 'escuro';
+    /** Com o tema seguindo o SO, avisa `tema:alterado` quando o usuário troca o tema do sistema. */
+    private observarTemaDoSistema;
+    private _observandoSistema;
 }
 export declare const UIBus: UIBusManager;
 export {};

package/dist/core.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./zero-js-triggers-QGD7FOTv.cjs"),i=require("./listener-bag-D5omxZ9h.cjs"),t=require("./leaflet-loader-94z5VsdY.cjs"),o=require("./ssr-safe-CiHD1adl.cjs"),e=require("./form-validacao-ytRYSF3E.cjs");typeof document<"u"&&r.initZeroJSTriggers();exports.UIBus=r.UIBus;exports.initZeroJSTriggers=r.initZeroJSTriggers;exports.ListenerBag=i.ListenerBag;exports.carregarLeaflet=t.carregarLeaflet;exports.obterLeafletSincrono=t.obterLeafletSincrono;exports.SafeHTMLElement=o.SafeHTMLElement;exports.definirCustomElement=o.definirCustomElement;exports.isBrowser=o.isBrowser;exports.aplicarValidadeInternals=e.aplicarValidadeInternals;exports.cliqueVeioDeRotuloExterno=e.cliqueVeioDeRotuloExterno;exports.gerarIdUnico=e.gerarIdUnico;exports.obterRotuloExterno=e.obterRotuloExterno;exports.validarRestricoesCampoTexto=e.validarRestricoesCampoTexto;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./zero-js-triggers-C_gtaojZ.cjs"),t=require("./listener-bag-D5omxZ9h.cjs"),i=require("./leaflet-loader-94z5VsdY.cjs"),o=require("./ssr-safe-CiHD1adl.cjs"),e=require("./form-validacao-ytRYSF3E.cjs"),a=require("./svg-seguro-C76iLlAZ.cjs");typeof document<"u"&&r.initZeroJSTriggers();exports.UIBus=r.UIBus;exports.initZeroJSTriggers=r.initZeroJSTriggers;exports.ListenerBag=t.ListenerBag;exports.carregarLeaflet=i.carregarLeaflet;exports.obterLeafletSincrono=i.obterLeafletSincrono;exports.SafeHTMLElement=o.SafeHTMLElement;exports.definirCustomElement=o.definirCustomElement;exports.isBrowser=o.isBrowser;exports.aplicarValidadeInternals=e.aplicarValidadeInternals;exports.cliqueVeioDeRotuloExterno=e.cliqueVeioDeRotuloExterno;exports.gerarIdUnico=e.gerarIdUnico;exports.obterRotuloExterno=e.obterRotuloExterno;exports.validarRestricoesCampoTexto=e.validarRestricoesCampoTexto;exports.higienizarSvg=a.higienizarSvg;

package/dist/core.js

@@ -1,22 +1,24 @@
-import { i as e } from "./zero-js-triggers-DdESy0tk.js";
-import { U as t } from "./zero-js-triggers-DdESy0tk.js";
-import { L as i } from "./listener-bag-DQgv7OON.js";
+import { i as e } from "./zero-js-triggers-C_KrvFOQ.js";
+import { U as t } from "./zero-js-triggers-C_KrvFOQ.js";
+import { L as s } from "./listener-bag-DQgv7OON.js";
 import { c as f, o as m } from "./leaflet-loader-Cjcdgj5R.js";
-import { S as p, d as c, i as d } from "./ssr-safe-5cWfJP-s.js";
-import { a as u, c as g, g as L, o as E, v as S } from "./form-validacao-BIOXxt-1.js";
+import { S as p, d as x, i as c } from "./ssr-safe-5cWfJP-s.js";
+import { a as g, c as u, g as L, o as S, v as E } from "./form-validacao-BIOXxt-1.js";
+import { h as B } from "./svg-seguro-BsbNQqpd.js";
 typeof document < "u" && e();
 export {
-  i as ListenerBag,
+  s as ListenerBag,
   p as SafeHTMLElement,
   t as UIBus,
-  u as aplicarValidadeInternals,
+  g as aplicarValidadeInternals,
   f as carregarLeaflet,
-  g as cliqueVeioDeRotuloExterno,
-  c as definirCustomElement,
+  u as cliqueVeioDeRotuloExterno,
+  x as definirCustomElement,
   L as gerarIdUnico,
+  B as higienizarSvg,
   e as initZeroJSTriggers,
-  d as isBrowser,
+  c as isBrowser,
   m as obterLeafletSincrono,
-  E as obterRotuloExterno,
-  S as validarRestricoesCampoTexto
+  S as obterRotuloExterno,
+  E as validarRestricoesCampoTexto
 };