@thibezer/ui-components-kit 2.8.2 → 2.10.0

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

@@ -1,5 +1,4 @@
 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';
@@ -7,48 +6,15 @@ 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';
-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[];
-}
+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 };
 interface Contexto {
     obterLayerManager: () => CanvasLayerManager;
     obterMapa: () => L.Map | null;
@@ -60,37 +26,29 @@ 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;
-}
-/** 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';
+    /**
+     * 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;
 }
 export declare class GerenciadorFeicoes {
     private contexto;
+    private operacoes;
     private selecao;
     private popup;
-    private editor;
+    private edicao;
+    private consulta;
+    private ponteiro;
+    private regiao;
     private snap;
-    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 ferramentas;
+    private versoes;
+    private camera;
+    private repositorio;
     private cursores;
-    private hoverId;
-    private hoverAgendado;
     private margensHud;
     /** Aceita a coordenada (0, 0) exata nas feições de entrada (atributo `aceitar-origem`). */
     aceitarOrigem: boolean;
@@ -99,28 +57,18 @@ 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. Com `substituirPropriedades`,
-     * `propriedades` informadas trocam as atuais por inteiro (atributos ausentes somem).
-     */
+    /** Mescla campos de primeiro nível; `estilo` e `propriedades` também são mesclados. Ver `RepositorioFeicoes`. */
     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.
-     * Adicionar um id que já existe substitui a feição mantendo a posição (a ordem de empilhamento não muda).
-     */
+    /** Várias mudanças numa só regravação e num só `aposDados`: remove, depois atualiza, depois adiciona. */
     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: {
@@ -134,12 +82,17 @@ 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 de camadas selecionáveis tocadas pelo polígono; a ferramenta encerra. */
+    /** Laço: seleciona (substituindo) as feições 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>;
@@ -150,14 +103,12 @@ 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;
@@ -170,10 +121,6 @@ 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;
@@ -181,7 +128,6 @@ 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. */
@@ -194,13 +140,19 @@ export declare class GerenciadorFeicoes {
     alternarSnap(): void;
     conectarTeclado(): void;
     desconectarTeclado(): void;
-    /** Feições visíveis das camadas de feições cujo envelope toca um quadrado de `tolPx` px em volta de `coord`. */
+    /** Feições visíveis 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;
@@ -220,22 +172,8 @@ 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;
-    /**
-     * 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.
-     */
+    /** Divide polígonos pela linha de corte (selecionados; sem seleção, o primeiro cortado). Ver `OperacoesFeicoes`. */
     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?: {
@@ -249,14 +187,9 @@ export declare class GerenciadorFeicoes {
     }, opcoes?: {
         id?: string;
     }): Feicao | null;
-    /**
-     * 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.
-     */
+    /** Junta linhas (encadeando pontas) ou dois polígonos numa feição só; as originais saem. Ver `OperacoesFeicoes`. */
     juntarFeicoes(camadaId: string, ids: string[], opcoes?: {
         toleranciaM?: number;
         id?: string;
     }): Feicao | null;
 }
-export {};

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

@@ -3,6 +3,8 @@ 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;
@@ -13,7 +15,7 @@ export interface ContextoInicializadorCAD {
     obterContextoEventos: () => ContextoEventosCanvas;
     renderLayersUI: () => void;
     invalidateSizeSafely: () => void;
-    tratarCliqueLivreCanvas: (e: any, latlng?: any, containerPoint?: any) => void;
+    tratarCliqueLivreCanvas: (e: MouseEvent | EventoMapaCad, latlng?: LatLngEvento, containerPoint?: PontoPixel) => void;
     dispararAcaoPopup: (acaoId: string, elementoId: string | number, elemento?: any) => void;
 }
 export declare function inicializarCAD(ctx: ContextoInicializadorCAD): void;

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

@@ -0,0 +1,5 @@
+/**
+ * O Leaflet recusa inicializar um contêiner já marcado com `_leaflet_id` ("Map container is already initialized").
+ * Limpa a marca; devolve `true` se havia uma.
+ */
+export declare function liberarContainerLeaflet(container: HTMLElement | null | undefined): boolean;

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-canvas-cad/cad-selecao-pontos.d.ts

@@ -0,0 +1,5 @@
+import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
+type IdPonto = string | number;
+export declare function lerPontosSelecionados(controller: GerenciGeoMapaController): IdPonto[];
+export declare function gravarPontosSelecionados(controller: GerenciGeoMapaController, ids: IdPonto[]): void;
+export {};

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

@@ -0,0 +1,37 @@
+/**
+ * Tipos "emprestados" do Leaflet e do contexto do mapa usados pelo <ui-canvas-cad>.
+ * Responsabilidade única: descrever, em um só lugar, as formas dinâmicas que o código antes acessava com `as any`.
+ */
+/** Contêiner de mapa do Leaflet: o Leaflet marca o elemento com `_leaflet_id` ao inicializar. */
+export type ContainerLeaflet = HTMLElement & {
+    _leaflet_id?: number;
+};
+export interface PontoPixelEvento {
+    x?: number;
+    y?: number;
+}
+export interface LatLngEvento {
+    lat?: number;
+    lng?: number;
+    /** Alguns emissores usam `lon`. */
+    lon?: number;
+}
+/** Evento de mapa/DOM como chega ao canvas: pode ser do Leaflet (com `originalEvent`) ou um MouseEvent cru. */
+export interface EventoMapaCad {
+    originalEvent?: EventoMapaCad;
+    target?: EventTarget | null;
+    composedPath?: () => EventTarget[];
+    clientX?: number;
+    clientY?: number;
+    containerPoint?: PontoPixelEvento;
+    layerPoint?: PontoPixelEvento;
+    latlng?: LatLngEvento;
+}
+/** Elemento com coordenadas em qualquer das grafias aceitas na entrada. */
+export interface ElementoComCoordenadas {
+    lat?: number | string;
+    lon?: number | string;
+    lng?: number | string;
+    latitude?: number | string;
+    longitude?: number | string;
+}

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

@@ -2,7 +2,12 @@ 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 { ModoRenderizador } from '../../gerencigeo-canvas/renderers/feicoes_despachante';
+import { EstatisticasFeicoes } from '../../gerencigeo-canvas/renderers/renderizador_feicoes_tipos';
 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';
@@ -20,6 +25,7 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     private feicoes;
     private barraFerramentas;
     private hoverListeners;
+    private desligarAnuncios;
     private layerItemListeners;
     private initTimeout?;
     private estilosExternos;
@@ -46,7 +52,7 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     definirEstilosExternos(css: EstilosExternos): void;
     private initCAD;
     private obterContextoEventos;
-    tratarCliqueLivreCanvas(e: MouseEvent | any, latLng?: any, pt?: any): void;
+    tratarCliqueLivreCanvas(e: MouseEvent | EventoMapaCad, latLng?: LatLngEvento, pt?: PontoPixel): void;
     dispararAcaoPopup(acaoId: string, elementoId: string | number, elemento?: any): void;
     toggleLayersPanel(): void;
     closeLayersPanel(): void;
@@ -69,6 +75,26 @@ 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);
+    /**
+     * Quem desenha as camadas de feições (atributo `renderizador`): `leaflet` (padrão; um objeto Leaflet por feição) ou
+     * `canvas` (motor sem DOM + Canvas 2D: um canvas por camada e um de sobreposição para seleção, formas minúsculas
+     * como marcas em lote, só um objeto Leaflet por marcador de ícone, texto, cluster e rótulo). Valor inválido usa
+     * `leaflet`. Ao mudar, as camadas de feições são recriadas; a API, os eventos e os dados não mudam.
+     */
+    get renderizador(): ModoRenderizador;
+    set renderizador(val: ModoRenderizador);
+    /**
+     * Contadores do desenho de uma camada de feições (`total`, `materializadas`, `desenhadas`, `marcasLOD`, `clusters`,
+     * `canvases`, `renderizador`...), para diagnóstico e benchmark. `null` se a camada não está desenhada.
+     */
+    estatisticasFeicoes(camadaId: string): EstatisticasFeicoes | null;
     get modoSequencial(): boolean;
     set modoSequencial(val: boolean);
     get chaveGrupo(): string | undefined;
@@ -79,6 +105,7 @@ 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)[];
@@ -203,6 +230,8 @@ 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-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-checkbox/ui-checkbox.d.ts

@@ -25,11 +25,14 @@ 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: any, _mode: 'restore' | 'autocomplete'): void;
+    formStateRestoreCallback(state: unknown, _mode: 'restore' | 'autocomplete'): void;
     private handleClick;
+    private handleHostClick;
     private handleKeyDown;
     private handleFocus;
     private handleBlur;

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

@@ -41,6 +41,8 @@ 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,11 +79,16 @@ 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). */
-    abrirSeletor(alvo?: AlvoCor): void;
-    /** Fecha o seletor aberto por este controle (confirmando, por padrão). */
+    /** 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.
+     */
     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' | 'aoAlterar' | 'aoConfirmar' | 'aoCancelar' | 'aoTrocarAlvo'>;
+export type ConfiguracaoSeletorCor = Omit<OpcoesSeletorCor, 'ancora' | 'focar' | '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,6 +51,8 @@ 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-linha/index.d.ts

@@ -0,0 +1 @@
+export * from './ui-linha';

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

@@ -0,0 +1,48 @@
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export type AlinhamentoLinha = 'inicio' | 'centro' | 'fim' | 'esticar';
+export type JustificacaoLinha = 'inicio' | 'centro' | 'fim' | 'entre' | 'ao-redor';
+export type EspacoLinha = 'nenhum' | 'xs' | 'sm' | 'md' | 'lg';
+/**
+ * Contêiner de controles na mesma linha: um único lugar define altura, alinhamento, espaço e quebra, e todos os
+ * filhos (`ui-botao`, `ui-campo-texto`, `ui-lista-flutuante`, `ui-segmented`, `ui-badge[controle]`...) se alinham sozinhos.
+ *
+ * A altura segue o contrato `--ui-campo-altura` (ver `core/altura-controle.ts`): `tamanho`/`altura` aqui valem para
+ * todos os filhos; um filho com `tamanho`/`altura` próprio vence só ele.
+ *
+ * @element ui-linha
+ *
+ * @attr {string} tamanho - Altura dos controles filhos: `sm` (26px), `md` (34px), `lg` (42px); aceita também `compacta`, `padrao`, `relaxada`.
+ * @attr {string} densidade - Sinônimo de `tamanho`.
+ * @attr {string} altura - Altura explícita dos controles filhos (px, rem ou em); vence `tamanho`.
+ * @attr {string} alinhar - Alinhamento vertical: `centro` (padrão), `inicio`, `fim`, `esticar`.
+ * @attr {string} justificar - Distribuição horizontal: `inicio` (padrão), `centro`, `fim`, `entre`, `ao-redor`.
+ * @attr {string} espaco - Espaço entre os filhos: `nenhum`, `xs`, `sm` (padrão), `md`, `lg`.
+ * @attr {boolean} sem-quebra - Não quebra para a linha de baixo (por padrão a linha quebra).
+ * @attr {boolean} inline - Ocupa só a largura do conteúdo (`inline-flex`).
+ *
+ * @slot - Os controles da linha. Qualquer filho com o atributo `expandir` ocupa o espaço restante.
+ *
+ * @cssprop --ui-linha-espaco - Espaço entre os filhos (substitui `espaco`).
+ * @cssprop --ui-linha-campo-base - Largura-base de campos e listas antes de quebrar (padrão `12rem`).
+ * @cssprop --ui-campo-altura - Altura dos controles filhos (definida por `tamanho`/`altura`).
+ */
+export declare class UILinha extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    attributeChangedCallback(_name: string, old: string | null, value: string | null): void;
+    private lerTexto;
+    private definirTexto;
+    get tamanho(): string | null;
+    set tamanho(v: string | null);
+    get altura(): string | null;
+    set altura(v: string | number | null);
+    get alinhar(): AlinhamentoLinha | null;
+    set alinhar(v: AlinhamentoLinha | null);
+    get justificar(): JustificacaoLinha | null;
+    set justificar(v: JustificacaoLinha | null);
+    get espaco(): EspacoLinha | null;
+    set espaco(v: EspacoLinha | null);
+    get semQuebra(): boolean;
+    set semQuebra(v: boolean);
+}

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

@@ -0,0 +1,14 @@
+import { VistaMapa } from './tipos';
+export declare const VISTA_PADRAO: VistaMapa;
+export declare const COR_MARCADOR_PADRAO = "#00f5a0";
+export declare const COR_LINHA_PADRAO = "#3388ff";
+export declare const ESPESSURA_PADRAO = 3;
+/** Lê lat/lng/zoom; cada campo inválido (ou fora de -90..90, -180..180, 0..22) cai no padrão. */
+export declare function lerVista(lat: string | null, lng: string | null, zoom: string | null): VistaMapa;
+export declare function lerInteiroPositivo(valor: string | null, padrao: number): number;
+/** Aceita só cores CSS conhecidas (hex, rgb/hsl, nome); qualquer outra coisa vira `padrao`. Impede injeção em estilo/atributo. */
+export declare function corSegura(cor: string | null | undefined, padrao: string): string;
+/** Lista de camadas base pedidas, filtrada pelas conhecidas; vazia → `['osm']`. */
+export declare function lerCamadas(texto: string | null, conhecidas: string[]): string[];
+/** Interpreta `pontos` (JSON `[[lat, lng], ...]`); descarta pares inválidos e devolve `[]` se o JSON não for um array. */
+export declare function lerPontos(texto: string | null): Array<[number, number]>;

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

@@ -0,0 +1,7 @@
+import { TileLayer } from 'leaflet';
+import { LeafletModulo } from './tipos';
+export interface Basemap {
+    nome: string;
+    layer: () => TileLayer;
+}
+export declare function obterBasemaps(L: LeafletModulo): Record<string, Basemap>;

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

@@ -0,0 +1,4 @@
+import { DivIcon } from 'leaflet';
+import { FormatoMarcador, LeafletModulo } from './tipos';
+/** `cor` já deve ter passado por `corSegura`. */
+export declare function criarIconeMarcador(L: LeafletModulo, cor: string, formato: FormatoMarcador): DivIcon;

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

@@ -0,0 +1,5 @@
+import { LeafletModulo } from './tipos';
+/** `L` se o Leaflet já estiver carregado (global ou importado), senão `null`. */
+export declare function obterLeaflet(): LeafletModulo | null;
+/** Carrega o Leaflet sob demanda; `null` se não estiver instalado. */
+export declare function carregarLeafletTipado(): Promise<LeafletModulo | null>;