@thibezer/ui-components-kit 2.6.1 → 2.7.0

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

@@ -0,0 +1,68 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { Feicao, EstiloFeicao, LatLonPar } from '../../gerencigeo-canvas/feature_types';
+import { ControleDesenho } from '../../gerencigeo-canvas/feature_desenho_controle';
+import { Ferramenta } from '../../gerencigeo-canvas/feature_desenho';
+import { buscarSnap } from '../../gerencigeo-canvas/feature_snap';
+import { ResultadoFerramenta } from './cad-feicoes-tipos';
+export interface PortasDesenho {
+    obterMapa: () => L.Map | null;
+    obterLayerManager: () => CanvasLayerManager;
+    emitir: (evento: string, detalhe: unknown, cancelavel?: boolean) => unknown;
+    /** A ferramenta ativa mudou (`null` = nenhuma). */
+    aoFerramenta?: (ferramenta: Ferramenta | null) => void;
+    lista: (camadaId: string) => Feicao[];
+    adicionarFeicao: (camadaId: string, bruta: unknown) => Feicao | null;
+    buscarSnapEm: (coord: [number, number]) => ReturnType<typeof buscarSnap>;
+    snapAtivo: () => boolean;
+    /** Antes de ativar uma ferramenta: encerra a edição de vértices, fecha o popup e ajusta as margens do HUD. */
+    prepararDesenho: () => void;
+    normalizarCoordenada: (bruta: unknown) => LatLonPar | null;
+    dividirComLinha: (linha: LatLonPar[]) => boolean;
+    selecionarNoLaco: (laco: LatLonPar[]) => void;
+    candidatasEm: (coord: LatLonPar, tolPx: number) => Feicao[];
+}
+export declare class FerramentasDesenho {
+    private p;
+    private desenho;
+    private camadaDesenho;
+    private estiloDesenho;
+    private sequenciaId;
+    constructor(p: PortasDesenho);
+    /** Controle de desenho da camada L2 (nasce na primeira ativação; `null` antes ou após `destruir`). */
+    get controle(): ControleDesenho | null;
+    /** Há uma ferramenta ativa? (o clique e o botão direito são dela) */
+    get ativo(): boolean;
+    /** Botão direito com ferramenta ativa: conclui, desfaz o último vértice ou sai. */
+    botaoDireito(): void;
+    /** Encerra a ferramenta e solta o controle (que guarda o mapa; após reconectar o mapa é outro). */
+    destruir(): 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;
+    get camadaDeDesenho(): string | null;
+    /** Estilo aplicado às feições desenhadas daqui para frente (o conta-gotas também o altera). */
+    definirEstiloDesenho(estilo: EstiloFeicao): void;
+    obterEstiloDesenho(): EstiloFeicao;
+    alternarFerramenta(nome: string): ResultadoFerramenta;
+    ativarFerramenta(nome: string, opcoes?: {
+        fechar?: boolean;
+        iniciarEm?: LatLonPar;
+    }): ResultadoFerramenta;
+    desativarFerramenta(): void;
+    limparMedicao(): void;
+    /** Vértices já colocados na figura em andamento (0 sem ferramenta ou sem figura). */
+    get nosDesenho(): number;
+    desfazerVerticeDesenho(): boolean;
+    private motivoCamadaDesenhoInvalida;
+    private novoId;
+    /**
+     * 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. */
+    amostrarEstilo(coord: LatLonPar): void;
+}

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

@@ -0,0 +1,37 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { Feicao } from '../../gerencigeo-canvas/feature_types';
+import { RefFeicao } from '../../gerencigeo-canvas/feature_selecao';
+import { EditorVertices } from '../../gerencigeo-canvas/feature_editor_vertices';
+import { ExcluirSnap } from '../../gerencigeo-canvas/feature_snap';
+import { ResultadoEdicao } from './cad-feicoes-tipos';
+export interface PortasEdicao {
+    obterMapa: () => L.Map | null;
+    obterLayerManager: () => CanvasLayerManager;
+    emitir: (evento: string, detalhe: unknown) => unknown;
+    buscar: (camadaId: string, id: string) => Feicao | undefined;
+    substituir: (camadaId: string, feicao: Feicao) => void;
+    desativarFerramenta: () => void;
+    aplicarMargensHud: () => void;
+    selecionarUma: (ref: RefFeicao) => void;
+    fecharPopup: () => void;
+    /** Depois da edição: o popup volta se a seleção tem exatamente uma feição. */
+    reabrirPopupDaSelecao: () => void;
+    snapAtivo: () => boolean;
+    alternarSnap: () => void;
+    buscarSnapEm: (coord: [number, number], excluir?: ExcluirSnap) => ReturnType<typeof import('../../gerencigeo-canvas/feature_snap').buscarSnap>;
+}
+export declare class EdicaoFeicoes {
+    private p;
+    private editor;
+    constructor(p: PortasEdicao);
+    get editando(): boolean;
+    /** @internal Editor de vértices da camada L2 (`null` fora da edição). */
+    get editorAtual(): EditorVertices | null;
+    /** Feição em edição (`null` fora da edição). */
+    get feicao(): Feicao | null;
+    sincronizar(feicao: Feicao): void;
+    atualizarSnapNoHud(): void;
+    iniciarEdicao(camadaId: string, id: string): ResultadoEdicao;
+    parar(): void;
+}

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

@@ -0,0 +1,48 @@
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { Feicao, LatLonPar } from '../../gerencigeo-canvas/feature_types';
+import { RefFeicao } from '../../gerencigeo-canvas/feature_selecao';
+export interface PortasOperacoes {
+    emitir: (evento: string, detalhe: unknown) => unknown;
+    obterLayerManager: () => CanvasLayerManager;
+    buscar: (camadaId: string, id: string) => Feicao | undefined;
+    lista: (camadaId: string) => Feicao[];
+    desenhada: (f: Feicao) => boolean;
+    idLivre: (camadaId: string, base: string) => string;
+    adicionarFeicao: (camadaId: string, bruta: unknown) => Feicao | null;
+    removerFeicao: (camadaId: string, id: string) => boolean;
+    selecionadas: () => Feicao[];
+    estaSelecionada: (ref: RefFeicao) => boolean;
+    /** `true` enquanto a ferramenta "dividir" está ativa. */
+    divisaoAtiva: () => boolean;
+    encerrarDesenho: () => void;
+}
+export declare class OperacoesFeicoes {
+    private p;
+    constructor(p: PortasOperacoes);
+    /**
+     * 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?: {
+        camadaDestino?: string;
+        id?: string;
+    }): Feicao | null;
+    /** Copia a feição deslocada (em metros para leste/norte). */
+    duplicarFeicao(camadaId: string, id: string, deslocamento?: {
+        lesteM?: number;
+        norteM?: number;
+    }, 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.
+     */
+    juntarFeicoes(camadaId: string, ids: string[], opcoes?: {
+        toleranciaM?: number;
+        id?: string;
+    }): Feicao | null;
+}

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

@@ -0,0 +1,24 @@
+import { Feicao, LatLonPar } from '../../gerencigeo-canvas/feature_types';
+export interface PortasPonteiro {
+    emitir: (evento: string, detalhe: unknown) => unknown;
+    feicaoSob: (clientX: number, clientY: number) => {
+        feicao: Feicao | null;
+        coordenada: LatLonPar;
+    } | null;
+    /** Mouse parado para o hover: uma ferramenta de desenho ou a edição de vértices está ativa. */
+    interacaoAtiva: () => boolean;
+    /** Se há ferramenta ativa, entrega a ela o botão direito e devolve `true` (não abre menu). */
+    botaoDireitoDaFerramenta: () => boolean;
+}
+export declare class PonteiroFeicoes {
+    private p;
+    private hoverId;
+    private hoverAgendado;
+    constructor(p: PortasPonteiro);
+    /** 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. */
+    menuContexto(e: MouseEvent): void;
+    /** Esquece a feição sob o cursor (ao destruir o componente). */
+    limpar(): void;
+}

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

@@ -0,0 +1,22 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { Feicao, LatLonPar } from '../../gerencigeo-canvas/feature_types';
+import { RefFeicao } from '../../gerencigeo-canvas/feature_selecao';
+import { CaixaPx, ModoCaixa } from '../../gerencigeo-canvas/feature_caixa';
+export interface PortasSelecaoRegiao {
+    obterMapa: () => L.Map | null;
+    obterLayerManager: () => CanvasLayerManager;
+    lista: (camadaId: string) => Feicao[];
+    desenhada: (f: Feicao) => boolean;
+    desativarFerramenta: () => void;
+    selecionar: (refs: RefFeicao[]) => void;
+    alternarVarias: (refs: RefFeicao[]) => void;
+}
+export declare class SelecaoPorRegiao {
+    private p;
+    constructor(p: PortasSelecaoRegiao);
+    /** Laço: seleciona (substituindo) as feições de camadas selecionáveis tocadas pelo polígono; a ferramenta encerra. */
+    selecionarNoLaco(laco: LatLonPar[]): void;
+    /** 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;
+}

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

@@ -0,0 +1,53 @@
+import { LayerStyleDef } from '../../gerencigeo-canvas/types';
+import { MotivoRecusaEdicao } from '../../gerencigeo-canvas/feature_edicao_ops';
+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[];
+}
+/** 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';
+}

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

@@ -0,0 +1,33 @@
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { Feicao } from '../../gerencigeo-canvas/feature_types';
+import { RegraVersoes } from '../../gerencigeo-canvas/feature_versoes';
+export interface PortasVersoes {
+    obterLayerManager: () => CanvasLayerManager;
+    emitir: (evento: string, detalhe: unknown) => unknown;
+    buscar: (camadaId: string, id: string) => Feicao | undefined;
+    lista: (camadaId: string) => Feicao[];
+    /** Chamado depois que a regra muda, para reconciliar seleção, edição e popup. */
+    aposDados: () => void;
+}
+export declare class VersoesFeicoes {
+    private p;
+    readonly regra: RegraVersoes;
+    private cacheOficiais;
+    constructor(p: PortasVersoes, regra: 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;
+    aplicarVersoes(): void;
+    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;
+    alternarPreviasGlobais(): void;
+    /** Liga/desliga a prévia da entidade a que a feição pertence. Devolve o novo estado, ou `null` se a feição não existe. */
+    alternarPrevia(camadaId: string, id: string): boolean | null;
+    /** A prévia da feição está sendo mostrada por pedido (global ou individual)? */
+    previaSolicitada(camadaId: string, id: string): boolean;
+    /** Mostra o que estava escondido (camada oculta, prévia não solicitada) para a feição poder ser vista. */
+    garantirVisivel(f: Feicao): void;
+}

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,14 @@ 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 { 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;
@@ -61,36 +26,21 @@ interface Contexto {
     /** 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';
-}
 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 +49,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,7 +74,7 @@ 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;
@@ -150,14 +90,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 +108,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 +115,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 +127,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 +159,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 +174,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-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

@@ -3,6 +3,8 @@ import { Ponto, Segmento, BancoPonto, Confrontante, CanvasLayerState, CanvasGrap
 import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
 import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
 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 +22,7 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     private feicoes;
     private barraFerramentas;
     private hoverListeners;
+    private desligarAnuncios;
     private layerItemListeners;
     private initTimeout?;
     private estilosExternos;
@@ -46,7 +49,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;

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;