@thibezer/ui-components-kit 2.8.2 → 2.10.0

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

@@ -1,6 +1,7 @@
 import { SafeHTMLElement } from '../../core/ssr-safe';
 import { CamadaItem, FeicaoItem, MapaBaseItem, AbaPainelCamadas } from './tipos';
 import { CamadasHostCompleto } from './camadas-host';
+import { LembrancaCamadas } from './camadas-lembranca';
 export declare class UICamadas extends SafeHTMLElement implements CamadasHostCompleto {
     static get observedAttributes(): string[];
     private shadow;
@@ -11,11 +12,10 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     private conectado;
     private profundidadeLote;
     private renderPendente;
-    private camadasRemovidas;
     /** Painéis conectados sem `id` nem `storage-key`: dividem a mesma chave de persistência. */
     private static instanciasChavePadrao;
-    private origensCamadas;
-    private salvarLembrancaDebounced;
+    /** @internal */
+    readonly lembranca: LembrancaCamadas;
     camadas: CamadaItem[];
     feicoes: FeicaoItem[];
     mapasBase: MapaBaseItem[];
@@ -40,6 +40,11 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     set mapaBaseAtivo(valor: string);
     selecionarMapaBase(id: string, emitirEvento?: boolean): void;
     private marcarMapaBaseAtivoNoDOM;
+    /** Seção "Mapa Base" recolhida (só o cabeçalho com o mapa ativo). Atributo `mapas-base-recolhido`. */
+    get mapasBaseRecolhido(): boolean;
+    set mapasBaseRecolhido(valor: boolean);
+    /** Alterna a seção de mapas base; com `emitirEvento`, dispara `ui-mapas-base-recolhimento`. */
+    alternarMapasBaseRecolhido(emitirEvento?: boolean): void;
     get abaAtiva(): AbaPainelCamadas;
     set abaAtiva(aba: AbaPainelCamadas);
     get colapsado(): boolean;
@@ -79,7 +84,6 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     /** Atalho reativo para `definirMapasBase()` — não dispara eventos. */
     get basemaps(): MapaBaseItem[];
     set basemaps(mapas: MapaBaseItem[]);
-    private achatarCamadas;
     definirCamadas(camadas: CamadaItem[], feicoes?: FeicaoItem[]): void;
     definirFeicoes(feicoes: FeicaoItem[]): void;
     definirMapasBase(mapas: MapaBaseItem[]): void;
@@ -114,7 +118,6 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     private conectarEventosGerais;
     private sincronizarCamadaAtivaDOM;
     sincronizarSelecaoDOM(): void;
-    private sincronizarSelecoesComFeicoesValidas;
     notificarMudancaSelecao(): void;
 }
 export declare class UIPainelCamadas extends UICamadas {

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

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

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * Acessibilidade do <ui-canvas-cad>.
+ * Responsabilidade única: nomes acessíveis dos botões da barra rápida, estado `aria-pressed` do snap e anúncios
+ * (região viva) de seleção e ferramenta para leitores de tela.
+ */
+/** Botões só com ícone ganham `aria-label` igual ao `title`; `aria-label` já definido é respeitado. */
+export declare function nomearBotoesDaBarra(shadow: ShadowRoot): void;
+/** Reflete o snap ligado/desligado no botão da barra. */
+export declare function marcarSnap(shadow: ShadowRoot, ligado: boolean): void;
+export declare function textoSelecao(quantidade: number): string;
+export declare function textoFerramenta(ferramenta: string | null): string;
+/** Escreve na região viva (`#cad-status`); trocar o texto é o que dispara o anúncio. */
+export declare function anunciar(shadow: ShadowRoot, texto: string): void;
+/** Tempo (ms) que o aviso visível de uma recusa fica na tela. */
+export declare const TEMPO_AVISO_MS = 5000;
+/**
+ * Liga os anúncios aos eventos que o próprio componente emite; devolve a função que desliga.
+ * Recusas de desenho e de edição viram aviso visível e anúncio, a menos que o host tenha o atributo `sem-avisos`
+ * (o consumidor mostra o próprio aviso a partir de `cad-desenho-recusado` / `cad-edicao-recusada`).
+ */
+export declare function conectarAnuncios(host: HTMLElement, shadow: ShadowRoot): () => void;

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

@@ -1,3 +1,4 @@
+import { ScaleMode } from '../../gerencigeo-canvas/types';
 import { UICanvasCAD } from './ui-canvas-cad';
 import { GerenciadorBroadcastConfig } from './cad-broadcast';
 import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
@@ -7,7 +8,7 @@ export interface ContextoAtributosCAD {
     mapContainer: HTMLDivElement | null;
     broadcastConfig: GerenciadorBroadcastConfig;
     setLayerOpacity: (id: string, op: number) => void;
-    setLayerScaleMode: (id: string, mode: any) => void;
+    setLayerScaleMode: (id: string, mode: ScaleMode) => void;
     atualizarZonaProjecao: (zona: number) => void;
 }
 export declare function sincronizarAtributoCAD(ctx: ContextoAtributosCAD, name: string, oldVal: string, newVal: string): void;

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

@@ -14,6 +14,6 @@ export declare class GerenciadorBroadcastConfig {
     private contexto;
     constructor(contexto: ContextoBroadcastCAD);
     conectar(canalNome?: string | null): void;
-    processarMensagem(data: any): void;
+    processarMensagem(entrada: unknown): void;
     desconectar(): void;
 }

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

@@ -0,0 +1,22 @@
+import { EventoMapaCad, LatLngEvento } from './tipos';
+export interface PontoPixel {
+    x: number;
+    y: number;
+}
+/** Evento "de baixo": o `originalEvent` do Leaflet quando existe, senão o próprio evento. */
+export declare function eventoOriginalDe(e: unknown): EventoMapaCad;
+/** Primeiro alvo do evento: `composedPath()[0]` (atravessa o shadow DOM) ou `target`. */
+export declare function alvoDoEvento(e: unknown): HTMLElement | null;
+/**
+ * Ponto em pixels relativo ao contêiner: o parâmetro explícito, depois `containerPoint`/`layerPoint` do evento
+ * e, por fim, `clientX/clientY` descontando o retângulo do contêiner.
+ */
+export declare function pontoPixelDe(e: unknown, explicito: PontoPixel | undefined, retanguloContainer: {
+    left: number;
+    top: number;
+}): PontoPixel;
+/** Latitude/longitude do parâmetro explícito ou do evento (aceita `lon` no lugar de `lng`); `null` se não houver número em `lat`. */
+export declare function latLngDe(e: unknown, explicito?: LatLngEvento): {
+    lat: number;
+    lng: number;
+} | null;

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

@@ -1,4 +1,6 @@
 import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
+import { EventoMapaCad, LatLngEvento } from './tipos';
+import { PontoPixel } from './cad-evento-coordenadas';
 export interface ContextoEventosCanvas {
     host: HTMLElement;
     controller: GerenciGeoMapaController;
@@ -8,14 +10,7 @@ export interface ContextoEventosCanvas {
     obterElementoPorId: (id: string | number) => any;
     fecharPopup: () => void;
 }
-export declare function processarCliqueLivreCanvas(ctx: ContextoEventosCanvas, e: MouseEvent | any, latLngParam?: {
-    lat: number;
-    lng?: number;
-    lon?: number;
-}, containerPointParam?: {
-    x: number;
-    y: number;
-}): boolean;
+export declare function processarCliqueLivreCanvas(ctx: ContextoEventosCanvas, e: MouseEvent | EventoMapaCad, latLngParam?: LatLngEvento, containerPointParam?: PontoPixel): boolean;
 export declare function processarAcaoPopup(ctx: ContextoEventosCanvas, acaoId: string, elementoId: string | number, elemento?: any): void;
 export declare function tratarCliqueMarcador(ctx: ContextoEventosCanvas, pId: string | number, isVizinho: boolean | undefined, elemento: any, coords: {
     lat: number;

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

@@ -0,0 +1,26 @@
+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';
+export interface PortasCamera {
+    obterMapa: () => L.Map | null;
+    obterLayerManager: () => CanvasLayerManager;
+    buscar: (camadaId: string, id: string) => Feicao | undefined;
+    lista: (camadaId: string) => Feicao[];
+    desenhada: (f: Feicao) => boolean;
+    /** Liga a camada e a prévia da feição, se estiverem escondidas. */
+    garantirVisivel: (f: Feicao) => void;
+}
+export declare class CameraFeicoes {
+    private p;
+    constructor(p: PortasCamera);
+    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;
+    /** Enquadra todas as feições das camadas de feições visíveis (que aparecem pela regra de versões). */
+    ajustarTudo(): boolean;
+    /** Enquadra a camada inteira; se estava oculta, torna-a visível. */
+    ajustarCamada(camadaId: string): boolean;
+}

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

@@ -0,0 +1,21 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { Feicao, LatLonPar } from '../../gerencigeo-canvas/feature_types';
+import { ExcluirSnap } from '../../gerencigeo-canvas/feature_snap';
+export interface PortasConsulta {
+    obterMapa: () => L.Map | null;
+    obterLayerManager: () => CanvasLayerManager;
+    desenhada: (f: Feicao) => boolean;
+}
+export declare class ConsultaEspacialFeicoes {
+    private p;
+    constructor(p: PortasConsulta);
+    /** Feições visíveis das camadas de feições cujo envelope toca um quadrado de `tolPx` px em volta de `coord`. */
+    candidatasEm(coord: LatLonPar, tolPx: number): Feicao[];
+    /** 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;
+    feicaoSob(clientX: number, clientY: number): {
+        feicao: Feicao | null;
+        coordenada: LatLonPar;
+    } | null;
+}

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

@@ -0,0 +1,39 @@
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { Feicao } from '../../gerencigeo-canvas/feature_types';
+import { OpcoesCamadaFeicoes, OpcoesLote, LoteFeicoes, ResultadoLote, ResultadoFeicoes } from './cad-feicoes-tipos';
+export interface PortasRepositorio {
+    obterLayerManager: () => CanvasLayerManager;
+    opcoesNormalizacao: () => {
+        aceitarOrigem: boolean;
+    };
+    /** Chamado depois de cada mudança nos dados, para reconciliar seleção, edição e popup. */
+    aposDados: () => void;
+}
+export declare class RepositorioFeicoes {
+    private p;
+    /** id -> posição na lista da camada (válido enquanto `lista` for a lista atual); evita varrer a camada a cada consulta. */
+    private posicoes;
+    constructor(p: PortasRepositorio);
+    lista(camadaId: string): Feicao[];
+    private posicaoDe;
+    /** Feição da camada pelo id (O(1)); `undefined` se não existe. */
+    buscar(camadaId: string, id: string): Feicao | undefined;
+    private garantirCamada;
+    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).
+     */
+    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).
+     */
+    aplicarLote(camadaId: string, lote: LoteFeicoes, opcoes?: OpcoesLote): ResultadoLote;
+    private mesclar;
+    private aplicar;
+}

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,28 @@
+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;
+    /** Pedido explícito de informações: abre o popup da feição. */
+    abrirPopup?: (feicao: Feicao) => void;
+}
+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;
+    /** Duplo clique sobre uma feição: pedido de informações (popup). Ignorado durante desenho ou edição de vértices. */
+    duploClique(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;
+}