@thibezer/ui-components-kit 2.8.1 → 2.8.2

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

@@ -1,4 +1,5 @@
 import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { LayerStyleDef } from '../../gerencigeo-canvas/types';
 import { Feicao, EstiloFeicao, LatLonPar } from '../../gerencigeo-canvas/feature_types';
 import { RegraVersoes } from '../../gerencigeo-canvas/feature_versoes';
 import { UsuarioRemoto } from '../../gerencigeo-canvas/feature_cursores';
@@ -6,15 +7,48 @@ import { RefFeicao } from '../../gerencigeo-canvas/feature_selecao';
 import { CaixaPx, ModoCaixa } from '../../gerencigeo-canvas/feature_caixa';
 import { MargensPopup } from '../../gerencigeo-canvas/feature_popup';
 import { default as L } from 'leaflet';
+import { MotivoRecusaEdicao } from '../../gerencigeo-canvas/feature_edicao_ops';
 import { ExcluirSnap } from '../../gerencigeo-canvas/feature_snap';
-import { EditorVertices } from '../../gerencigeo-canvas/feature_editor_vertices';
-import { ControleDesenho } from '../../gerencigeo-canvas/feature_desenho_controle';
 import { Ferramenta } from '../../gerencigeo-canvas/feature_desenho';
 import { MargensHud } from '../../gerencigeo-canvas/feature_hud';
-import { ModoPopups } from '../../gerencigeo-canvas/popup_gate';
-import { TIPO_CAMADA_FEICOES, OpcoesCamadaFeicoes, OpcoesLote, AtualizacaoFeicao, LoteFeicoes, ResultadoLote, ResultadoFeicoes, OpcoesPopup, ResultadoFerramenta, ResultadoEdicao } from './cad-feicoes-tipos';
-export { TIPO_CAMADA_FEICOES };
-export type { OpcoesCamadaFeicoes, OpcoesLote, AtualizacaoFeicao, LoteFeicoes, ResultadoLote, ResultadoFeicoes, OpcoesPopup, ResultadoFerramenta, ResultadoEdicao };
+export declare const TIPO_CAMADA_FEICOES = "feicoes";
+export interface OpcoesCamadaFeicoes {
+    nome?: string;
+    zIndex?: number;
+    opacidade?: number;
+    interativo?: boolean;
+    estilo?: Partial<LayerStyleDef>;
+}
+/** Opções de `aplicarLote` / `atualizarFeicao`. */
+export interface OpcoesLote extends OpcoesCamadaFeicoes {
+    /**
+     * Em atualizações, `propriedades` informadas SUBSTITUEM as atuais (o padrão é mesclar, e chaves apagadas
+     * pelo consumidor ficam para trás). Sem `propriedades` no item, nada muda.
+     */
+    substituirPropriedades?: boolean;
+}
+/** Itens de atualização: `id` aponta a feição; o resto é mesclado como em `atualizarFeicao`. */
+export type AtualizacaoFeicao = Record<string, any> & {
+    id: string;
+};
+export interface LoteFeicoes {
+    adicionar?: unknown[];
+    atualizar?: AtualizacaoFeicao[];
+    remover?: string[];
+}
+export interface ResultadoLote {
+    adicionadas: number;
+    atualizadas: number;
+    removidas: number;
+    /** Ids (ou posições, quando não há id) recusados: geometria inválida, feição inexistente numa atualização, camada que não é de feições. */
+    recusadas: string[];
+}
+export interface ResultadoFeicoes {
+    /** Quantas feições entraram na camada. */
+    aceitas: number;
+    /** Ids (ou posições, quando não há id) das feições recusadas por geometria inválida. */
+    recusadas: string[];
+}
 interface Contexto {
     obterLayerManager: () => CanvasLayerManager;
     obterMapa: () => L.Map | null;
@@ -26,29 +60,37 @@ interface Contexto {
     aoFerramenta?: (ferramenta: Ferramenta | null) => void;
     /** Regra de oficial × prévia compartilhada com o renderizador (o componente a põe no contexto de renderização). */
     regra?: RegraVersoes;
-    /**
-     * Quando o popup da feição abre: `sob-demanda` (padrão do componente) só por duplo clique ou `abrirPopupFeicao`;
-     * `automatico` também ao selecionar uma feição. Sem esta função (uso direto do gerenciador), vale `automatico`.
-     */
-    modoPopups?: () => ModoPopups;
-    /** Executa a abertura de um popup como pedido explícito, passando pelo portão de popups do mapa. */
-    liberarPopups?: <T>(fn: () => T) => T;
+}
+/** Opções do popup da feição. */
+export interface OpcoesPopup {
+    /** A ação "copiar" grava as coordenadas na área de transferência (padrão `true`); `cad-feicao-acao` sai de qualquer jeito. */
+    copiarParaAreaDeTransferencia?: boolean;
+}
+export interface ResultadoFerramenta {
+    ok: boolean;
+    motivo?: 'ferramenta-invalida' | 'sem-mapa' | 'sem-camada' | 'camada-invalida' | 'camada-bloqueada';
+}
+export interface ResultadoEdicao {
+    ok: boolean;
+    motivo?: MotivoRecusaEdicao | 'inexistente' | 'sem-mapa';
 }
 export declare class GerenciadorFeicoes {
     private contexto;
-    private operacoes;
     private selecao;
     private popup;
-    private edicao;
-    private consulta;
-    private ponteiro;
-    private regiao;
+    private editor;
     private snap;
-    private ferramentas;
-    private versoes;
-    private camera;
-    private repositorio;
+    private desenho;
+    private camadaDesenho;
+    private estiloDesenho;
+    private sequenciaId;
+    private regra;
+    private cacheOficiais;
+    /** id -> posição na lista da camada (válido enquanto `lista` for a lista atual); evita varrer a camada a cada consulta. */
+    private posicoes;
     private cursores;
+    private hoverId;
+    private hoverAgendado;
     private margensHud;
     /** Aceita a coordenada (0, 0) exata nas feições de entrada (atributo `aceitar-origem`). */
     aceitarOrigem: boolean;
@@ -57,18 +99,28 @@ export declare class GerenciadorFeicoes {
     /** Depois de qualquer mudança nos dados: descarta seleção órfã e atualiza/fecha o popup aberto. */
     private aposDados;
     private lista;
+    private posicaoDe;
     /** Feição da camada pelo id (O(1)); `undefined` se não existe. */
     buscar(camadaId: string, id: string): Feicao | undefined;
+    private garantirCamada;
     private opcoesNormalizacao;
     definirFeicoes(camadaId: string, brutas: unknown[], opcoes?: OpcoesCamadaFeicoes): ResultadoFeicoes;
     adicionarFeicao(camadaId: string, bruta: unknown, opcoes?: OpcoesCamadaFeicoes): Feicao | null;
-    /** Mescla campos de primeiro nível; `estilo` e `propriedades` também são mesclados. Ver `RepositorioFeicoes`. */
+    /**
+     * Mescla campos de primeiro nível; `estilo` e `propriedades` também são mesclados. Com `substituirPropriedades`,
+     * `propriedades` informadas trocam as atuais por inteiro (atributos ausentes somem).
+     */
     atualizarFeicao(camadaId: string, id: string, parcial: Record<string, any>, opcoes?: Pick<OpcoesLote, 'substituirPropriedades'>): Feicao | null;
     /** Grava uma feição já normalizada (usado quando o próprio mapa a altera, como ao arrastar um texto). */
     substituir(camadaId: string, feicao: Feicao): void;
     removerFeicao(camadaId: string, id: string): boolean;
-    /** Várias mudanças numa só regravação e num só `aposDados`: remove, depois atualiza, depois adiciona. */
+    /**
+     * Várias mudanças numa só regravação e num só `aposDados`: remove, depois atualiza, depois adiciona.
+     * Adicionar um id que já existe substitui a feição mantendo a posição (a ordem de empilhamento não muda).
+     */
     aplicarLote(camadaId: string, lote: LoteFeicoes, opcoes?: OpcoesLote): ResultadoLote;
+    private mesclar;
+    private aplicar;
     obterFeicoes(camadaId: string): Feicao[];
     /** Traduz as ações vindas do renderizador no evento a disparar pelo componente. */
     tratarAcaoCamada(acao: string, detalhe: {
@@ -82,17 +134,12 @@ export declare class GerenciadorFeicoes {
     /** Esc ou clique no vazio: durante a edição só encerra a edição; fora dela, limpa a seleção. */
     aoPedirLimpeza(): void;
     obterFeicoesSelecionadas(): Feicao[];
-    /** Laço: seleciona (substituindo) as feições tocadas pelo polígono; a ferramenta encerra. */
+    /** Laço: seleciona (substituindo) as feições de camadas selecionáveis tocadas pelo polígono; a ferramenta encerra. */
     private selecionarNoLaco;
     /** Caixa de seleção: só feições de camadas visíveis, interativas e desbloqueadas, com toque geométrico real. */
     selecionarNaCaixa(caixa: CaixaPx, modo: ModoCaixa, aditivo: boolean): void;
     definirMargensPopup(m: Partial<MargensPopup>): void;
     fecharPopup(): void;
-    private modoPopups;
-    /** Pedido explícito: abre o popup da feição (vale em qualquer modo). `false` se não existe, foi excluída ou não está na tela. */
-    abrirPopupFeicao(camadaId: string, id: string): boolean;
-    /** Duplo clique no mapa: abre o popup da feição sob o cursor (a não ser que os popups estejam desligados). */
-    aoDuploClique(e: MouseEvent): void;
     /** Opções do popup (hoje: se "copiar" escreve na área de transferência). Mescla com o que já foi definido. */
     definirOpcoesPopup(opcoes: OpcoesPopup): void;
     obterOpcoesPopup(): Required<OpcoesPopup>;
@@ -103,12 +150,14 @@ export declare class GerenciadorFeicoes {
     definirMargensHud(m: Partial<MargensHud>): void;
     private aplicarMargensHud;
     get regraVersoes(): RegraVersoes;
+    private oficiaisDe;
     /** Aparece segundo a regra de oficial × prévia? */
     visivelPorVersao(f: Feicao): boolean;
     /** Vai para a tela e responde a clique, caixa, laço, snap e hover: não excluída, não oculta e visível pela regra de versões. */
     desenhada(f: Feicao): boolean;
     /** Regra da seleção: a feição em edição continua selecionada mesmo se for ocultada no meio da edição. */
     private selecionavelAgora;
+    private aplicarVersoes;
     get previasGlobais(): boolean;
     /** Mostra (ou esconde) as prévias de todas as entidades. Prévias de entidades sem oficial aparecem sempre. */
     definirPreviasGlobais(ligado: boolean): void;
@@ -121,6 +170,10 @@ export declare class GerenciadorFeicoes {
     removerCursorRemoto(id: string): boolean;
     limparCursoresRemotos(): void;
     get cursoresRemotos(): number;
+    /** Mostra o que estava escondido (camada oculta, prévia não solicitada) para a feição poder ser vista. */
+    private garantirVisivel;
+    private limitesDe;
+    private enquadrar;
     /** Aproxima da feição; liga a camada e a prévia, se estiverem escondidas. Ponto: voa até z ≥ 17. */
     zoomParaFeicao(camadaId: string, id: string): boolean;
     zoomParaFeicoes(refs: RefFeicao[]): boolean;
@@ -128,6 +181,7 @@ export declare class GerenciadorFeicoes {
     ajustarTudo(): boolean;
     /** Enquadra a camada inteira; se estava oculta, torna-a visível. */
     ajustarCamada(camadaId: string): boolean;
+    private feicaoSob;
     /** Emite `cad-feicao-hover` quando a feição sob o mouse muda (uma checagem por quadro). */
     aoMoverMouse(e: MouseEvent): void;
     /** Botão direito: emite `cad-feicao-menu` com a feição sob o cursor (ou `null`), para o consumidor abrir o próprio menu. */
@@ -140,19 +194,13 @@ export declare class GerenciadorFeicoes {
     alternarSnap(): void;
     conectarTeclado(): void;
     desconectarTeclado(): void;
-    /** Feições visíveis cujo envelope toca um quadrado de `tolPx` px em volta de `coord`. */
+    /** Feições visíveis das camadas de feições cujo envelope toca um quadrado de `tolPx` px em volta de `coord`. */
     private candidatasEm;
     /** Snap de uma coordenada contra as feições visíveis de todas as camadas de feições (via índice espacial). */
     buscarSnapEm(coord: [number, number], excluir?: ExcluirSnap): import('../../gerencigeo-canvas').ResultadoSnap | null;
-    /** @internal Editor de vértices (usado pelos testes de caracterização). */
-    get editor(): EditorVertices | null;
     get editando(): boolean;
     iniciarEdicao(camadaId: string, id: string): ResultadoEdicao;
     pararEdicao(): void;
-    /** @internal Controle de desenho (usado pelos testes de caracterização). */
-    get desenho(): ControleDesenho | null;
-    /** @internal Conta-gotas (usado pelos testes de caracterização). */
-    amostrarEstilo(coord: LatLonPar): void;
     get ferramentaAtiva(): Ferramenta | null;
     /** Camada que recebe o que for desenhado. Não existe camada padrão: o consumidor escolhe. */
     definirCamadaDesenho(camadaId: string | null): void;
@@ -172,8 +220,22 @@ export declare class GerenciadorFeicoes {
     desfazerVerticeDesenho(): boolean;
     /** Liga/desliga a tecla S do snap (o botão e `definirSnap` continuam valendo). */
     definirAtalhoSnap(ligado: boolean): void;
+    private motivoCamadaDesenhoInvalida;
+    private novoId;
     private idLivre;
-    /** Divide polígonos pela linha de corte (selecionados; sem seleção, o primeiro cortado). Ver `OperacoesFeicoes`. */
+    /**
+     * Clique da ferramenta texto: emite `cad-texto-solicitado` (cancelável). Com `preventDefault()` o consumidor assume a
+     * entrada do texto e depois chama `detalhe.concluir(texto)` (cria na camada de desenho, com o estilo de desenho) ou
+     * simplesmente não faz nada para cancelar. Sem `preventDefault()`, aparece o campo inline.
+     */
+    private solicitarTexto;
+    private concluirFerramenta;
+    /** Conta-gotas: copia o estilo da feição sob o clique para o estilo de desenho. */
+    private amostrarEstilo;
+    /**
+     * Divide polígonos pela linha de corte. Alvos: os polígonos selecionados; sem seleção, o primeiro
+     * polígono (de camada visível, interativa e desbloqueada) que a linha corta.
+     */
     dividirComLinha(linha: LatLonPar[]): boolean;
     /** Cria um polígono de buffer ao redor da feição (na camada dela, ou em `camadaDestino`). */
     gerarBuffer(camadaId: string, id: string, metros: number, opcoes?: {
@@ -187,9 +249,14 @@ export declare class GerenciadorFeicoes {
     }, opcoes?: {
         id?: string;
     }): Feicao | null;
-    /** Junta linhas (encadeando pontas) ou dois polígonos numa feição só; as originais saem. Ver `OperacoesFeicoes`. */
+    /**
+     * Junta linhas (encadeando pontas) ou dois polígonos (por uma ponte) numa feição só; as originais saem.
+     * Linhas com pontas a até `toleranciaM` se ligam; polígonos precisam estar a até `toleranciaM` e
+     * não podem ter bordas que se cruzam.
+     */
     juntarFeicoes(camadaId: string, ids: string[], opcoes?: {
         toleranciaM?: number;
         id?: string;
     }): Feicao | null;
 }
+export {};

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

@@ -3,8 +3,6 @@ import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controlle
 import { GerenciadorToolbarPainel } from './cad-toolbar-painel';
 import { GerenciadorColecoesDados } from './cad-colecoes-dados';
 import { ContextoEventosCanvas } from './cad-eventos-canvas';
-import { EventoMapaCad, LatLngEvento } from './tipos';
-import { PontoPixel } from './cad-evento-coordenadas';
 export interface ContextoInicializadorCAD {
     host: UICanvasCAD;
     shadow: ShadowRoot;
@@ -15,7 +13,7 @@ export interface ContextoInicializadorCAD {
     obterContextoEventos: () => ContextoEventosCanvas;
     renderLayersUI: () => void;
     invalidateSizeSafely: () => void;
-    tratarCliqueLivreCanvas: (e: MouseEvent | EventoMapaCad, latlng?: LatLngEvento, containerPoint?: PontoPixel) => void;
+    tratarCliqueLivreCanvas: (e: any, latlng?: any, containerPoint?: any) => void;
     dispararAcaoPopup: (acaoId: string, elementoId: string | number, elemento?: any) => void;
 }
 export declare function inicializarCAD(ctx: ContextoInicializadorCAD): void;

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

@@ -2,10 +2,7 @@ import { default as L } from 'leaflet';
 import { Ponto, Segmento, BancoPonto, Confrontante, CanvasLayerState, CanvasGraphicScale, ScaleMode, PontoCAD, ConexaoCAD, PoligonoCAD, DestacarElementoOpcoes } from '../../gerencigeo-canvas/types';
 import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
 import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
-import { ModoPopups } from '../../gerencigeo-canvas/popup_gate';
 import { UsuarioRemoto } from '../../gerencigeo-canvas/feature_cursores';
-import { EventoMapaCad, LatLngEvento } from './tipos';
-import { PontoPixel } from './cad-evento-coordenadas';
 import { OpcoesCamadaFeicoes, OpcoesLote, LoteFeicoes, ResultadoLote, ResultadoFeicoes, ResultadoEdicao, ResultadoFerramenta } from './cad-feicoes';
 import { EstiloFeicao, Feicao } from '../../gerencigeo-canvas/feature_types';
 import { SafeHTMLElement } from '../../core/ssr-safe';
@@ -23,7 +20,6 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     private feicoes;
     private barraFerramentas;
     private hoverListeners;
-    private desligarAnuncios;
     private layerItemListeners;
     private initTimeout?;
     private estilosExternos;
@@ -50,7 +46,7 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     definirEstilosExternos(css: EstilosExternos): void;
     private initCAD;
     private obterContextoEventos;
-    tratarCliqueLivreCanvas(e: MouseEvent | EventoMapaCad, latLng?: LatLngEvento, pt?: PontoPixel): void;
+    tratarCliqueLivreCanvas(e: MouseEvent | any, latLng?: any, pt?: any): void;
     dispararAcaoPopup(acaoId: string, elementoId: string | number, elemento?: any): void;
     toggleLayersPanel(): void;
     closeLayersPanel(): void;
@@ -73,13 +69,6 @@ export declare class UICanvasCAD extends SafeHTMLElement {
      */
     get aceitarOrigem(): boolean;
     set aceitarOrigem(val: boolean);
-    /**
-     * Quando os popups abrem (atributo `popups`): `sob-demanda` (padrão) só por duplo clique sobre a feição/camada ou por
-     * `abrirPopupFeicao()`, sem mover o mapa; `automatico` abre ao clicar e o Leaflet ajusta a vista (comportamento antigo);
-     * `desligado` só por `abrirPopupFeicao()`. Valor inválido usa o padrão.
-     */
-    get popups(): ModoPopups;
-    set popups(val: ModoPopups);
     get modoSequencial(): boolean;
     set modoSequencial(val: boolean);
     get chaveGrupo(): string | undefined;
@@ -90,7 +79,6 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     set canalConfiguracao(val: string | null);
     fitBounds(pontos?: Ponto[], padding?: [number, number], incluirVizinhos?: boolean): void;
     zoomExtents(): void;
-    /** Seleciona o vértice. A vista só se move (e o popup abre) se `zoomLevel` for informado: é o pedido de "ir até o ponto". */
     selectPonto(id: string | number, zoomLevel?: number): void;
     selecionarPonto(id: string | number, zoomLevel?: number): void;
     get pontosSelecionados(): (string | number)[];
@@ -215,8 +203,6 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     removerCursorRemoto(id: string): boolean;
     limparCursoresRemotos(): void;
     fecharPopupFeicao(): void;
-    /** Abre o popup da feição (pedido explícito, vale em qualquer modo de `popups`). `false` se ela não existe ou não está na tela. */
-    abrirPopupFeicao(camadaId: string, id: string): boolean;
     /**
      * Opções do popup. `copiarParaAreaDeTransferencia` (padrão `true`): a ação "copiar" também grava as coordenadas na área de
      * transferência; com `false` só sai `cad-feicao-acao` e o consumidor decide (ex.: para mostrar o próprio aviso).

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

@@ -25,14 +25,11 @@ export declare class UICheckbox extends FormAssociatedElement {
     set disabled(val: boolean);
     get type(): string;
     atualizarValidade(): void;
-    /** `focus()` no host leva o foco ao controle interno (necessário para o foco de validação do formulário). */
-    focus(options?: FocusOptions): void;
     alternar(): void;
     protected syncState(): void;
     formResetCallback(): void;
-    formStateRestoreCallback(state: unknown, _mode: 'restore' | 'autocomplete'): void;
+    formStateRestoreCallback(state: any, _mode: 'restore' | 'autocomplete'): void;
     private handleClick;
-    private handleHostClick;
     private handleKeyDown;
     private handleFocus;
     private handleBlur;

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

@@ -41,8 +41,6 @@ export interface OpcoesSeletorCor {
     coresProjeto?: ValorCor[];
     /** Substitui a paleta padrão. */
     paleta?: ValorCor[];
-    /** Leva o foco do teclado para o painel ao abrir (ao fechar, o foco volta para a âncora). Padrão: `false`. */
-    focar?: boolean;
     /** Cada alteração (pré-visualização, ainda não confirmada). */
     aoAlterar?: (detalhe: DetalheSeletorCor) => void;
     /** Ao fechar confirmando: Concluir, ✕, Enter no hexadecimal, Esc ou clique fora. */

package/dist/components/ui-cores/ui-controle-cores.d.ts

@@ -79,16 +79,11 @@ export declare class UIControleCores extends SafeHTMLElement {
     semCor(alvo?: AlvoCor): void;
     /** Volta às cores de `padrao-preenchimento` e `padrao-traco`; emite `ui-cores-change` confirmado. */
     restaurarPadrao(): void;
-    /** Abre o seletor de cor ancorado na amostra do alvo (que passa a ser o ativo). Com `focar`, leva o foco do teclado para o painel. */
-    abrirSeletor(alvo?: AlvoCor, focar?: boolean): void;
-    /**
-     * Fecha o seletor aberto por este controle. Com `confirmar` (padrão), grava o que foi editado;
-     * sem ele, cancela: as cores iniciais voltam (com um `ui-cores-change` não confirmado) e nada é confirmado.
-     */
+    /** Abre o seletor de cor ancorado na amostra do alvo (que passa a ser o ativo). */
+    abrirSeletor(alvo?: AlvoCor): void;
+    /** Fecha o seletor aberto por este controle (confirmando, por padrão). */
     fecharSeletor(confirmar?: boolean): void;
     private mudarAlvo;
-    /** Mantém a aba do seletor aberto igual ao alvo do controle. */
-    private sincronizarSeletor;
     private aplicarDoSeletor;
     private emitirCores;
     private dica;

package/dist/components/ui-cores/ui-seletor-cor.d.ts

@@ -1,7 +1,7 @@
 import { SafeHTMLElement } from '../../core/ssr-safe';
 import { AlvoCor, DetalheSeletorCor, OpcoesSeletorCor, SeletorCorAberto, ValorCor } from './tipos';
 /** Configuração aceita por `UISeletorCor.configurar()` (as opções de `abrirSeletorCor` sem âncora e callbacks). */
-export type ConfiguracaoSeletorCor = Omit<OpcoesSeletorCor, 'ancora' | 'focar' | 'aoAlterar' | 'aoConfirmar' | 'aoCancelar' | 'aoTrocarAlvo'>;
+export type ConfiguracaoSeletorCor = Omit<OpcoesSeletorCor, 'ancora' | 'aoAlterar' | 'aoConfirmar' | 'aoCancelar' | 'aoTrocarAlvo'>;
 /**
  * <ui-seletor-cor> — painel de cor no estilo Illustrator: abas Preenchimento/Traço, prévia
  * antes × depois, hexadecimal, seletor do sistema, opacidade do preenchimento, cores do projeto,
@@ -51,8 +51,6 @@ export declare class UISeletorCor extends SafeHTMLElement {
     private get opacidadeVisivel();
     private renderizar;
     private atualizarVisual;
-    /** `activeElement` lança em alguns DOMs simulados quando o foco está em outra árvore de sombra. */
-    private campoEmFoco;
     private vincularEventos;
     private emitir;
 }

package/dist/components/ui-mapa/ui-mapa-linha.d.ts

@@ -1,19 +1,12 @@
 import { SafeHTMLElement } from '../../core/ssr-safe';
-/**
- * Polilinha dentro de um `<ui-mapa>`.
- *
- * @attr {string} pontos - JSON `[[lat, lng], ...]`; pares inválidos são ignorados.
- * @attr {string} cor - Cor do traço (hex, rgb/hsl ou nome; outro valor usa a cor padrão).
- * @attr {number} espessura - Espessura em pixels (inteiro positivo; padrão 3).
- */
 export declare class UIMapaLinha extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private polyline;
-    private vinculo;
+    private _initTimer;
+    private _retryCount;
     connectedCallback(): void;
     disconnectedCallback(): void;
-    attributeChangedCallback(name: string, oldVal: string | null, newVal: string | null): void;
-    private estilo;
-    private removerLinha;
-    private criarLinha;
+    attributeChangedCallback(name: string, oldVal: string, newVal: string): void;
+    private getPontos;
+    private initLinha;
 }

package/dist/components/ui-mapa/ui-mapa-marcador.d.ts

@@ -1,24 +1,15 @@
 import { SafeHTMLElement } from '../../core/ssr-safe';
-/**
- * Marcador dentro de um `<ui-mapa>`.
- *
- * @attr {number} lat - Latitude (inválida: o marcador não é criado).
- * @attr {number} lng - Longitude.
- * @attr {string} titulo - Texto do popup e nome acessível do marcador (aria-label e title).
- * @attr {string} cor - Cor do ícone (hex, rgb/hsl ou nome; outro valor usa a cor padrão).
- * @attr {'pin'|'circle'} formato - Forma do ícone (padrão `pin`).
- */
 export declare class UIMapaMarcador extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private marker;
-    private vinculo;
+    private _initTimer;
+    private _retryCount;
+    private _parentMap;
     connectedCallback(): void;
     disconnectedCallback(): void;
-    attributeChangedCallback(name: string, oldVal: string | null, newVal: string | null): void;
-    private removerMarcador;
+    private handleMapReady;
+    attributeChangedCallback(name: string, oldVal: string, newVal: string): void;
     private createPopupContent;
     private createIcon;
-    /** O ícone é um `div`: o nome acessível vai em `aria-label` (o Leaflet já põe `role=button` e `tabindex=0`). */
-    private aplicarNomeAcessivel;
-    private criarMarcador;
+    private initMarker;
 }

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

@@ -1,15 +1,5 @@
 import { default as L } from 'leaflet';
 import { SafeHTMLElement } from '../../core/ssr-safe';
-/**
- * Mapa Leaflet encapsulado. Aceita `<ui-mapa-marcador>` e `<ui-mapa-linha>` como filhos.
- *
- * @attr {number} lat - Latitude do centro (-90..90; inválida cai no padrão).
- * @attr {number} lng - Longitude do centro (-180..180; inválida cai no padrão).
- * @attr {number} zoom - Zoom inicial (0..22; inválido cai no padrão).
- * @attr {string} camadas - Camadas base separadas por vírgula (`osm`, `satelite`, `topografia`, `ruas`).
- * @attr {string} aria-label - Nome acessível da região do mapa (padrão: "Mapa").
- * @fires ui-mapa-pronto - O mapa foi criado (`detail.map`); é emitido de novo se o elemento for reconectado.
- */
 export declare class UIMapa extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private mapContainer;
@@ -17,13 +7,10 @@ export declare class UIMapa extends SafeHTMLElement {
     private _initTimer;
     private _resizeObserver?;
     private _resizeTimer?;
-    private _invalidarTimer?;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
-    attributeChangedCallback(name: string, oldVal: string | null, newVal: string | null): void;
-    /** Nome acessível da região: o `aria-label` do host ou "Mapa". */
-    private sincronizarRotulo;
+    attributeChangedCallback(_name: string, oldVal: string, newVal: string): void;
     private initMap;
     getMap(): L.Map | null;
 }

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

@@ -1,12 +1,12 @@
 /**
- * Isolamento do <ui-modal> para tecnologias assistivas: `inert` em tudo o que está "atrás" do modal.
- * Responsabilidade única: aplicar e desfazer o `inert`, preservando o que a página já tinha inerte.
+ * Utilitários de Acessibilidade WAI-ARIA e Gerenciamento de 'inert' para UIModal / UIDialog.
  */
 /**
- * Aplica `inert` em todos os elementos da página que estejam "atrás" do modal,
+ * Aplica o atributo 'inert' em todos os elementos da página que estejam "atrás" do modal,
  * isolando o modal para tecnologias assistivas e interação de teclado/mouse.
- * Devolve o conjunto afetado (os que já eram inertes ficam de fora, para não serem liberados depois).
  */
 export declare function aplicarInertForaDoModal(modalElement: HTMLElement): Set<HTMLElement>;
-/** Remove o estado `inert` dos elementos afetados pelo modal quando este é fechado. */
+/**
+ * Remove o estado 'inert' dos elementos afetados pelo modal quando este é fechado.
+ */
 export declare function removerInertForaDoModal(elementosAfetados: Set<HTMLElement>): void;

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

@@ -5,8 +5,8 @@ export declare class UIModal extends SafeHTMLElement {
     private dialogElement;
     private tituloElement;
     private closeElement;
-    private ouvintes;
     private _elementoGatilho;
+    private _focables;
     private _tituloId;
     /** Estado já aplicado (pilha, inert, scroll, eventos); difere de `aberto` durante uma transição. */
     private _estaAberto;
@@ -26,9 +26,19 @@ export declare class UIModal extends SafeHTMLElement {
      */
     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 handleKeyDown;
 }
 export declare class UIDialog extends UIModal {

package/dist/components/ui-radio/radio-grupo-registry.d.ts

@@ -1,20 +1,10 @@
 import { UIRadio } from './ui-radio';
-/**
- * Grupos de radios por nome, dentro do escopo do formulário (ou da raiz, sem formulário).
- * O registro de cada radio é guardado ao registrar: assim o cancelamento usa o nome e o escopo de ANTES,
- * mesmo que o radio já tenha saído do formulário (disconnectedCallback roda depois da remoção) ou mudado de nome.
- */
 export declare class RadioGrupoRegistry {
     private static registry;
-    private static registros;
     static getScopeNode(radio: HTMLElement): Node;
-    /** Registra (ou re-registra, se o nome ou o escopo mudaram) o radio no grupo do seu nome atual. */
     static registrar(radio: UIRadio): void;
     static desregistrar(radio: UIRadio): void;
-    /** Radios do mesmo grupo que `radio`, usando o registro (não o nome atual, que pode ainda não ter sido registrado). */
     static obterRadiosDoGrupo(radio: UIRadio): UIRadio[];
     static desmarcarOutros(radio: UIRadio): void;
-    /** Reavalia o tabindex (roving) dos radios; use depois de entrar, sair ou mudar de grupo. */
-    static atualizarGrupo(radios: UIRadio[]): void;
     static tratarNavegacaoTeclado(e: KeyboardEvent, radioAtual: UIRadio): void;
 }

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

@@ -3,12 +3,11 @@ export declare class UIRadio extends FormAssociatedElement {
     static get observedAttributes(): string[];
     containerElement: HTMLDivElement;
     private labelElement;
-    private listeners;
     private _defaultChecked;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
-    attributeChangedCallback(nome: string, _old: string | null, _value: string | null): void;
+    attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
     get marcado(): boolean;
     set marcado(val: boolean);
     get name(): string;
@@ -19,16 +18,10 @@ export declare class UIRadio extends FormAssociatedElement {
     atualizarValidade(): void;
     focus(options?: FocusOptions): void;
     selecionar(): void;
-    /**
-     * Roving tabindex: só um radio do grupo entra na ordem de Tab (o marcado; sem marcado, o primeiro habilitado).
-     * Isolado de `syncState` para reavaliar os vizinhos sem mexer no valor/validade do formulário.
-     */
-    atualizarTabindex(): void;
     syncState(): void;
     formResetCallback(): void;
-    formStateRestoreCallback(state: unknown, _mode: 'restore' | 'autocomplete'): void;
+    formStateRestoreCallback(state: any, _mode: 'restore' | 'autocomplete'): void;
     private handleClick;
-    private handleHostClick;
     private handleKeyDown;
     private handleFocus;
     private handleBlur;

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

@@ -4,18 +4,9 @@ export type AnimacaoSkeleton = 'shimmer' | 'pulso' | 'nenhum';
 export declare class UISkeleton extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private rootElement;
-    /** O que este componente escreveu em aria-hidden / role (para não sobrescrever o consumidor). */
-    private _ocultoAuto;
-    private _papelAuto;
-    private _sincronizando;
     constructor();
     connectedCallback(): void;
     attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
-    /**
-     * Decorativo por padrão (`aria-hidden`). Com `aria-label` vira uma região de status anunciável
-     * ("Carregando tabela"). O que o consumidor definiu em aria-hidden/role é preservado.
-     */
-    private sincronizarAcessibilidade;
     get variante(): VarianteSkeleton;
     set variante(val: VarianteSkeleton);
     get animado(): AnimacaoSkeleton;

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

@@ -22,12 +22,10 @@ export declare class UISwitch extends FormAssociatedElement {
     set disabled(val: boolean);
     get type(): string;
     atualizarValidade(): void;
-    /** `focus()` no host leva o foco ao controle interno (necessário para o foco de validação do formulário). */
-    focus(options?: FocusOptions): void;
     alternar(): void;
     protected syncState(): void;
     formResetCallback(): void;
-    formStateRestoreCallback(state: unknown, _mode: 'restore' | 'autocomplete'): void;
+    formStateRestoreCallback(state: any, _mode: 'restore' | 'autocomplete'): void;
     private handleClick;
     private handleHostClick;
     private handleKeyDown;