@thibezer/ui-components-kit 2.0.0 → 2.2.0

package/dist/gerencigeo-canvas/feature_editor_vertices.d.ts

@@ -0,0 +1,80 @@
+import { default as L } from 'leaflet';
+import { Feicao, LatLonPar } from './feature_types';
+import { QualAlca } from './feature_edicao_ops';
+import { ResultadoSnap } from './feature_snap';
+export declare const ID_HUD_EDICAO = "cm-vertex-edit-hud";
+export interface DependenciasEditor {
+    map: L.Map;
+    /** Snap para a posição do cursor, ignorando o vértice em arrasto. Já considera se o snap está ligado. */
+    buscarSnap: (coord: LatLonPar, excluir: {
+        feicaoId: string;
+        camadaId: string;
+        vertice?: number;
+    }) => ResultadoSnap | null;
+    snapLigado: () => boolean;
+    alternarSnap: () => void;
+    /** Mostra a geometria nova no mapa sem gravar (durante o arrasto). */
+    previsualizar: (f: Feicao) => void;
+    /** Fim de cada gesto (soltar alça, inserir, excluir): grava a feição. */
+    aoGesto: (f: Feicao) => void;
+    /** A edição terminou (Concluir, Esc, ou chamada de `parar`). */
+    aoEncerrar: (f: Feicao) => void;
+}
+export declare class EditorVertices {
+    private dep;
+    private feicaoAtual;
+    private pts;
+    private alcas;
+    private fantasmas;
+    /** Alças de Bézier (só em feição com curva): marcador + haste até o nó. */
+    private alcasBezier;
+    private marcadorSnap;
+    private hud;
+    private grupo;
+    constructor(dep: DependenciasEditor);
+    get ativo(): boolean;
+    get feicao(): Feicao | null;
+    iniciar(f: Feicao): void;
+    /** Encerra a edição (idempotente). */
+    parar(): void;
+    /** A feição foi alterada por fora (API): refaz as alças com a geometria nova. */
+    sincronizar(f: Feicao): void;
+    /** Atualiza o texto "Snap" do HUD quando o snap é ligado/desligado. */
+    atualizarSnapNoHud(): void;
+    private geometriaAtual;
+    private feicaoComPontos;
+    private reconstruir;
+    private icone;
+    private criarAlca;
+    private criarAlcasBezier;
+    /** Cria os marcadores das alças do nó que ainda não têm (ex.: a oposta que nasceu ao arrastar com simetria). */
+    private completarAlcasDoNo;
+    /** Reposiciona marcadores e hastes de todas as alças conforme a geometria atual. */
+    private sincronizarAlcasBezier;
+    private aoArrastarAlca;
+    private alternarSuave;
+    private criarFantasma;
+    private aoArrastar;
+    /** Durante o arrasto de um nó, as alças dele acompanham (a geometria só é gravada no fim do gesto). */
+    private atualizarAlcasDoNo;
+    private inserir;
+    private confirmar;
+    private excluir;
+    /** Atalho para testes/API: mesma operação do botão direito. */
+    excluirVertice(indice: number): boolean;
+    inserirVerticeApos(indice: number): void;
+    private mostrarSnap;
+    private esconderSnap;
+    private montarHud;
+    private atualizarHud;
+    /** Para os testes: posição atual dos vértices. */
+    vertices(): LatLonPar[];
+    /** Para os testes: quantas alças de Bézier estão na tela. */
+    get totalAlcasBezier(): number;
+    /** Para os testes/API: arrasta uma alça do nó `indice` até `coord` (`independente` = Shift). */
+    arrastarAlcaPara(indice: number, qual: QualAlca, coord: LatLonPar, independente?: boolean): void;
+    /** Para os testes/API: mesma operação do duplo clique no nó. */
+    alternarSuavidadeDoNo(indice: number): void;
+    /** Para os testes: move um vértice como se a alça tivesse sido arrastada até `coord`. */
+    arrastarPara(indice: number, coord: LatLonPar): void;
+}

package/dist/gerencigeo-canvas/feature_formas.d.ts

@@ -0,0 +1,7 @@
+import { LatLonPar } from './feature_types';
+/** Elipse inscrita na caixa definida pelo centro e pelo canto; vazia se os dois raios são zero. */
+export declare function gerarElipse(centro: LatLonPar, borda: LatLonPar): LatLonPar[] | null;
+/** Polígono regular (padrão: hexágono) com um vértice em `borda`. */
+export declare function gerarPoligonoRegular(centro: LatLonPar, borda: LatLonPar, lados?: number): LatLonPar[] | null;
+/** Estrela (padrão: 5 pontas); `borda` define o raio externo e a rotação. */
+export declare function gerarEstrela(centro: LatLonPar, borda: LatLonPar, pontas?: number): LatLonPar[] | null;

package/dist/gerencigeo-canvas/feature_hud.d.ts

@@ -0,0 +1,23 @@
+export interface MargensHud {
+    topo: number;
+    base: number;
+    esquerda: number;
+    direita: number;
+}
+export declare const MARGEM_HUD_PADRAO: MargensHud;
+/** Folga mínima entre o HUD e as bordas da área visível (px). */
+export declare const FOLGA_HUD = 16;
+/** Parte da largura do mapa que o HUD pode ocupar, no máximo. */
+export declare const FRACAO_LARGURA_HUD = 0.92;
+export declare const PROPRIEDADES_HUD: Record<keyof MargensHud, string>;
+/** Posicionamento comum aos dois HUDs. Equivale a `posicaoHud`. */
+export declare const CSS_POSICAO_HUD: string;
+/** Mesma conta do CSS, em número: serve de referência para os testes e para quem posiciona algo junto do HUD. */
+export declare function posicaoHud(largura: number, altura: number, margens?: Partial<MargensHud>): {
+    centroX: number;
+    base: number;
+    larguraMax: number;
+    alturaMax: number;
+};
+/** Grava (ou, para chaves ausentes/inválidas, remove) as margens no conteiner do mapa. */
+export declare function aplicarMargensHud(conteiner: HTMLElement, margens: Partial<MargensHud>): void;

package/dist/gerencigeo-canvas/feature_indice.d.ts

@@ -0,0 +1,36 @@
+import { Feicao } from './feature_types';
+/** Envelope em graus: [oeste, sul, leste, norte] (x = lon, y = lat). */
+export interface CaixaGeo {
+    minLon: number;
+    minLat: number;
+    maxLon: number;
+    maxLat: number;
+}
+export interface ItemIndice extends CaixaGeo {
+    id: string;
+}
+export declare function caixaDaFeicao(f: Feicao): CaixaGeo;
+export declare function caixasSeTocam(a: CaixaGeo, b: CaixaGeo): boolean;
+export declare class IndiceEspacial {
+    private raiz;
+    /** Itens vivos: a fonte da verdade (a árvore pode conter itens já removidos/atualizados). */
+    private itens;
+    /** Itens que entraram ou mudaram depois da última montagem. */
+    private delta;
+    /** Ids que estão na árvore mas foram removidos ou substituídos. */
+    private obsoletos;
+    get tamanho(): number;
+    construir(feicoes: Feicao[]): void;
+    inserir(f: Feicao): void;
+    /** Insere ou substitui; feição `excluida` sai do índice. */
+    atualizar(f: Feicao): void;
+    remover(id: string): void;
+    limpar(): void;
+    /** Ids das feições cujo envelope toca `caixa`. */
+    consultar(caixa: CaixaGeo): string[];
+    intersecta(caixa: CaixaGeo): boolean;
+    /** Envelope da feição indexada, se houver. */
+    caixaDe(id: string): CaixaGeo | undefined;
+    private compactarSeNecessario;
+    private remontar;
+}

package/dist/gerencigeo-canvas/feature_metricas.d.ts

@@ -0,0 +1,16 @@
+import { Feicao, GeometriaFeicao, LatLonPar } from './feature_types';
+export declare function distanciaMetros(a: LatLonPar, b: LatLonPar): number;
+export declare function comprimentoMetros(pts: LatLonPar[], fechado?: boolean): number;
+/** Área (m²) do polígono, descontando os furos. */
+export declare function areaMetros2(aneis: LatLonPar[][]): number;
+export declare function formatarArea(m2: number): string;
+export declare function formatarExtensao(m: number): string;
+export declare function areaDaGeometria(g: GeometriaFeicao): number | null;
+export declare function extensaoDaGeometria(g: GeometriaFeicao): number | null;
+/**
+ * Texto do rótulo permanente. `campo` pode ser `area`, `extensao`, `id` ou qualquer chave de
+ * `propriedades` (name, category, description...). Sem campo: nome, senão id.
+ */
+export declare function textoRotulo(f: Feicao, campo?: string): string;
+/** Envelope [[sul, oeste], [norte, leste]] da geometria. */
+export declare function limitesDaGeometria(g: GeometriaFeicao): [LatLonPar, LatLonPar];

package/dist/gerencigeo-canvas/feature_popup.d.ts

@@ -0,0 +1,31 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerDef } from './types';
+import { Feicao, LatLonPar } from './feature_types';
+export type AcaoFeicao = 'inspecionar' | 'zoom' | 'vertices' | 'copiar';
+export interface MargensPopup {
+    topo: number;
+    base: number;
+    esquerda: number;
+    direita: number;
+}
+export declare function coordenadaDeReferencia(f: Feicao): LatLonPar;
+export interface DependenciasPopup {
+    obterMapa: () => L.Map | null;
+    obterCamada: (camadaId: string) => CanvasLayerDef | undefined;
+    aoAcao: (acao: AcaoFeicao, feicao: Feicao) => void;
+}
+export declare class FeicaoPopup {
+    private dep;
+    private popup;
+    private feicaoAtual;
+    private margens;
+    constructor(dep: DependenciasPopup);
+    /** Afasta o auto-pan de barras, tabelas e painéis laterais sobrepostos ao mapa. */
+    definirMargens(m: Partial<MargensPopup>): void;
+    get aberto(): Feicao | null;
+    abrir(f: Feicao): void;
+    /** Reconstrói o conteúdo se a feição aberta mudou (estilo, propriedades, geometria). */
+    atualizar(f: Feicao): void;
+    fechar(): void;
+    private montar;
+}

package/dist/gerencigeo-canvas/feature_selecao.d.ts

@@ -0,0 +1,38 @@
+import { Feicao } from './feature_types';
+export interface RefFeicao {
+    camadaId: string;
+    id: string;
+}
+interface Dependencias {
+    obterFeicao: (ref: RefFeicao) => Feicao | undefined;
+    /** Aplica o visual: `ids` são todas as feições selecionadas daquela camada (vazio = nenhuma). */
+    aplicarVisual: (camadaId: string, ids: Set<string>) => void;
+    aoSelecionar: (feicoes: Feicao[]) => void;
+    aoSelecionarUma: (feicao: Feicao | null) => void;
+    /** Feição escondida (ex.: prévia oculta) deixa de poder ficar selecionada. */
+    visivel?: (feicao: Feicao) => boolean;
+    /** Feição que nunca pode ser selecionada (ex.: oculta), nem por referência explícita. */
+    selecionavel?: (feicao: Feicao) => boolean;
+}
+export declare class SelecaoFeicoes {
+    private dep;
+    private itens;
+    constructor(dep: Dependencias);
+    get quantidade(): number;
+    contem(ref: RefFeicao): boolean;
+    obter(): Feicao[];
+    /** Seleciona as feições; sem `aditivo`, substitui a seleção atual. */
+    selecionar(refs: RefFeicao[], aditivo?: boolean): void;
+    /** Alterna uma feição na seleção (Ctrl/Shift+clique). */
+    alternar(ref: RefFeicao): void;
+    /** Alterna várias de uma vez (caixa de seleção com Ctrl). */
+    alternarVarias(refs: RefFeicao[]): void;
+    /** A feição existe e pode ser selecionada? */
+    private alcancavel;
+    limpar(): void;
+    /** Descarta da seleção o que deixou de existir (removida, excluída, camada sumiu). */
+    reconciliar(): void;
+    private assinatura;
+    private finalizar;
+}
+export {};

package/dist/gerencigeo-canvas/feature_simplificacao.d.ts

@@ -0,0 +1,15 @@
+import { GeometriaFeicao, LatLonPar } from './feature_types';
+/** A partir deste zoom a geometria é desenhada completa. */
+export declare const ZOOM_SEM_SIMPLIFICACAO = 12;
+/** Geometrias com menos vértices que isto não valem o custo. */
+export declare const MIN_VERTICES_SIMPLIFICAR = 40;
+/** Tolerância em graus para o zoom; 0 = sem simplificar. */
+export declare function toleranciaPorZoom(zoom: number): number;
+/** Douglas-Peucker iterativo (sem recursão: linhas com centenas de milhares de vértices). */
+export declare function simplificarLinha(pts: LatLonPar[], tolerancia: number): LatLonPar[];
+/** Anel aberto: mantém pelo menos 3 vértices (senão volta o original). */
+export declare function simplificarAnel(anel: LatLonPar[], tolerancia: number): LatLonPar[];
+/** Curvas não se simplificam: os vértices de apoio só medem, o desenho é calculado a partir dos nós. */
+export declare function vertices(g: GeometriaFeicao): number;
+/** Geometria para desenho no zoom dado; devolve a própria `g` quando não há o que simplificar. */
+export declare function simplificarGeometria(g: GeometriaFeicao, zoom: number): GeometriaFeicao;

package/dist/gerencigeo-canvas/feature_snap.d.ts

@@ -0,0 +1,25 @@
+import { Feicao, LatLonPar } from './feature_types';
+import { PontoPx, Projetor } from './feature_caixa';
+export type TipoSnap = 'vertice' | 'meio' | 'aresta';
+export interface ResultadoSnap {
+    tipo: TipoSnap;
+    coordenada: LatLonPar;
+    feicaoId: string;
+    camadaId: string;
+    /** Distância (px) entre o cursor e o ponto de snap. */
+    distanciaPx: number;
+}
+export interface OpcoesSnap {
+    toleranciaPx?: number;
+    vertice?: boolean;
+    meio?: boolean;
+    aresta?: boolean;
+}
+export interface ExcluirSnap {
+    feicaoId: string;
+    camadaId?: string;
+    /** Vértice em arrasto: ele e os segmentos que o tocam não atraem. */
+    vertice?: number;
+}
+export declare const TOLERANCIA_SNAP_PX = 10;
+export declare function buscarSnap(cursor: PontoPx, candidatas: Feicao[], projetar: Projetor, opcoes?: OpcoesSnap, excluir?: ExcluirSnap): ResultadoSnap | null;

package/dist/gerencigeo-canvas/feature_types.d.ts

@@ -0,0 +1,101 @@
+export type TipoFeicao = 'Point' | 'LineString' | 'Polygon' | 'Circle' | 'Text';
+export type StatusGeometria = 'oficial' | 'previa';
+/** [lat, lon] */
+export type LatLonPar = [number, number];
+/**
+ * Nó de uma curva de Bézier cúbica; `entrada`/`saida` são as alças em coordenadas absolutas (sem alça = canto).
+ * Na linha e no polígono, `curva` é a fonte do desenho e `coordenadas`/`aneis` guardam os vértices amostrados
+ * sobre ela, que alimentam métricas, snap e seleção. Veja `feature_curvas.ts`.
+ */
+export interface NoCurva {
+    ponto: LatLonPar;
+    entrada?: LatLonPar;
+    saida?: LatLonPar;
+}
+export type GeometriaFeicao = {
+    tipo: 'Point';
+    coordenada: LatLonPar;
+}
+/**
+ * Linha. Multiparte (MultiLineString): `partes` traz todas (2 ou mais) e `coordenadas` repete a primeira, de modo que
+ * quem só conhece `coordenadas` continua vendo uma linha válida. Use `partesDaLinha` para ler sempre todas as partes.
+ */
+ | {
+    tipo: 'LineString';
+    coordenadas: LatLonPar[];
+    partes?: LatLonPar[][];
+    curva?: NoCurva[];
+}
+/**
+ * O primeiro anel é o externo; os demais são furos. Anéis ficam abertos (sem repetir o primeiro vértice).
+ * `curva` (só com um anel) descreve o contorno como Bézier fechada; `aneis[0]` guarda os vértices de apoio.
+ */
+ | {
+    tipo: 'Polygon';
+    aneis: LatLonPar[][];
+    curva?: NoCurva[];
+} | {
+    tipo: 'Circle';
+    centro: LatLonPar;
+    raioMetros: number;
+} | {
+    tipo: 'Text';
+    coordenada: LatLonPar;
+    texto: string;
+};
+export type GeometriaLinha = Extract<GeometriaFeicao, {
+    tipo: 'LineString';
+}>;
+/** Todas as partes da linha (uma só quando é simples). */
+export declare function partesDaLinha(g: GeometriaLinha): LatLonPar[][];
+export declare function ehMultilinha(g: GeometriaFeicao): boolean;
+/** Monta a linha a partir das partes já válidas: uma parte vira linha simples; duas ou mais, multiparte. */
+export declare function criarLinha(partes: LatLonPar[][]): GeometriaLinha;
+export interface EstiloFeicao {
+    corPreenchimento?: string;
+    opacidadePreenchimento?: number;
+    corTraco?: string;
+    espessuraTraco?: number;
+    dashArray?: string;
+    icone?: string;
+    tamanhoIcone?: number;
+    rotacaoIcone?: number;
+    mostrarRotulo?: boolean;
+    campoRotulo?: string;
+    /** Texto: contorno claro/escuro em volta para legibilidade sobre o satélite. */
+    halo?: boolean;
+    /** Texto: tamanho da fonte em px. */
+    tamanhoFonte?: number;
+    /** Texto: cor do fundo do selo (etiqueta). Com ela, o selo substitui o `halo`. Só hex, rgb/hsl ou nome de cor. */
+    corFundo?: string;
+    /** Texto: cor da borda do selo (1 px). */
+    corBorda?: string;
+    /** Texto: opacidade do fundo do selo, de 0 a 1 (padrão 0,85); a borda e o texto ficam opacos. */
+    opacidadeFundo?: number;
+    /** Texto: raio dos cantos do selo em px (padrão 4). */
+    raioBorda?: number;
+    /** Ponto sem ícone: cor do contorno, separada do preenchimento (`corPreenchimento`) e de `corTraco`. */
+    corContorno?: string;
+    /** Ponto sem ícone: espessura do contorno em px (0 = sem contorno). */
+    espessuraContorno?: number;
+}
+export interface Feicao {
+    id: string;
+    camadaId: string;
+    geometria: GeometriaFeicao;
+    estilo?: EstiloFeicao;
+    propriedades: Record<string, unknown>;
+    bloqueada?: boolean;
+    /** Oficial ou prévia; ver `feature_versoes.ts` (também lido de `propriedades.status`/`tipo_geometria`). */
+    status?: StatusGeometria;
+    /** Agrupa a geometria oficial e as prévias da mesma coisa. Sem isto, a feição é a própria entidade. */
+    entidadeId?: string;
+    /** Foi removida: some de tudo (desenho, seleção, snap, versões) e encerra edição/popup. */
+    excluida?: boolean;
+    /**
+     * Oculta, mas existe: não é desenhada nem selecionada (clique, caixa, laço, hit-test, hover) e não atrai snap,
+     * não entra em `ajustarTudo`; segue nos dados (`obterFeicoes`, atualizações), não encerra edição e conta na
+     * regra oficial × prévia como qualquer outra.
+     */
+    oculta?: boolean;
+}

package/dist/gerencigeo-canvas/feature_versoes.d.ts

@@ -0,0 +1,19 @@
+import { Feicao, StatusGeometria } from './feature_types';
+/** Status da feição: o campo `status`; senão `propriedades.status` ou `propriedades.tipo_geometria`; senão oficial. */
+export declare function statusDe(f: Feicao): StatusGeometria;
+/** Identificador da entidade a que a geometria pertence. */
+export declare function entidadeDe(f: Feicao): string;
+export declare class RegraVersoes {
+    /** Mostra as prévias de todas as entidades. */
+    global: boolean;
+    private individuais;
+    alternarIndividual(camadaId: string, entidade: string): boolean;
+    definirIndividual(camadaId: string, entidade: string, ativa: boolean): void;
+    individualAtiva(camadaId: string, entidade: string): boolean;
+    /** Entidades da camada que têm geometria oficial. */
+    static oficiais(feicoes: Iterable<Feicao>): Set<string>;
+    /** A feição aparece? `comOficial` = entidades da camada com geometria oficial (ver `oficiais`). */
+    visivel(f: Feicao, comOficial: Set<string>): boolean;
+    /** A prévia está sendo mostrada por pedido (global ou individual), e não só por falta de oficial? */
+    previaSolicitada(f: Feicao): boolean;
+}

package/dist/gerencigeo-canvas/index.d.ts

@@ -9,9 +9,30 @@ export * from './renderers/vector_lines_renderer';
 export * from './renderers/vector_points_renderer';
 export * from './renderers/vector_polygons_renderer';
 export * from './renderers/grid_renderer';
+export * from './renderers/feicoes_renderer';
+export * from './feature_metricas';
+export * from './layer_hit_test';
+export * from './feature_caixa';
+export * from './feature_selecao';
+export * from './feature_popup';
+export * from './feature_indice';
+export * from './feature_simplificacao';
+export * from './feature_cluster';
+export * from './feature_edicao_ops';
+export * from './feature_snap';
+export * from './feature_editor_vertices';
+export * from './feature_algoritmos';
+export * from './feature_desenho';
+export * from './feature_desenho_controle';
+export * from './feature_amostra';
+export * from './feature_versoes';
+export * from './feature_cursores';
+export * from './feature_hud';
 export * from './layer_manager';
 export * from './mapa_core';
 export * from './mapa_linhas';
 export * from './mapa_marcadores';
 export * from './canvas_interacao';
 export * from './mapa_controller';
+export * from './feature_types';
+export * from './feature_adapters';

package/dist/gerencigeo-canvas/layer_hit_test.d.ts

@@ -0,0 +1,30 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerDef } from './types';
+import { TipoGeometriaPane } from './layer_pane_ops';
+/** Tolerância (px) somada à espessura do traço. */
+export declare const TOLERANCIA_LINHA_PX = 6;
+export declare const TOLERANCIA_PONTO_PX = 4;
+/** Desliga o pointer-events dos canvases de pane (markers DOM e popups não são afetados). */
+export declare function garantirCanvasSemEventos(container: HTMLElement): void;
+/** Feição candidata sob o cursor, já ordenada por prioridade. */
+export interface CandidatoHit {
+    camada: CanvasLayerDef;
+    tipo: TipoGeometriaPane;
+    alvo: L.Layer;
+    /** Distância (px) ao traço/centro; 0 quando o ponto cai dentro de uma área. */
+    distancia: number;
+    /** Área do envelope em px²; só usada para desempatar áreas. */
+    area: number;
+}
+/**
+ * Todas as feições sob o ponto, na ordem em que um clique deve escolhê-las
+ * (a primeira é a que o clique simples seleciona). Serve também para hover, menu de contexto e conta-gotas.
+ */
+export declare function consultarFeicoesNoPonto(map: L.Map, camadas: CanvasLayerDef[], ponto: L.Point): CandidatoHit[];
+/**
+ * Resolve o clique entre todas as camadas, da mais alta para a mais baixa.
+ * Dispara o evento só na feição vencedora e devolve `true` se houve acerto.
+ */
+export declare function resolverCliqueCentral(map: L.Map, camadas: CanvasLayerDef[], e: MouseEvent): boolean;
+/** Feição do topo sob o evento (sem alternar): hover, menu de contexto, conta-gotas. */
+export declare function feicaoNoTopo(map: L.Map, camadas: CanvasLayerDef[], e: MouseEvent): CandidatoHit | null;

package/dist/gerencigeo-canvas/layer_manager.d.ts

@@ -1,17 +1,25 @@
 import { default as L } from 'leaflet';
 import { CanvasLayerDef, CanvasLayerState, CanvasRenderContext, CanvasGraphicScale } from './types';
-import { DEFAULT_LAYERS } from './layer_defaults';
-export { DEFAULT_LAYERS };
+export declare const DEFAULT_LAYERS: CanvasLayerDef[];
 export declare class CanvasLayerManager {
     private layers;
     private layerInstances;
     private map;
     private context;
     private listeners;
+    private renderPendente;
     constructor(initialLayers?: CanvasLayerDef[]);
+    /**
+     * Remove as camadas que o kit traz de fábrica (satélite, SIGEF, homologados, perímetro, vizinhos, vértices, grade).
+     * Só vale antes de o mapa ser anexado: depois disso as instâncias já existem. Camadas criadas pelo consumidor ficam.
+     */
+    descartarCamadasPadrao(): void;
     attachMap(map: L.Map, context: CanvasRenderContext): void;
     ensurePanes(): void;
-    renderAllLayers(): void;
+    renderAllLayers(apenasDependentesDoContexto?: boolean): void;
+    /** Executa agora o render agendado por updateContext/setGraphicScale, se houver. */
+    flushRender(): void;
+    private agendarRender;
     setLayerVisibility(id: string, visivel: boolean): void;
     setLayerOpacity(id: string, opacidade: number): void;
     setLayerZIndex(id: string, zIndex: number): void;

package/dist/gerencigeo-canvas/layer_pane_ops.d.ts

@@ -1,6 +1,15 @@
 import { default as L } from 'leaflet';
 import { CanvasLayerDef } from './types';
 export declare function nomePane(layerId: string): string;
+/**
+ * Tipos de geometria de uma camada, do fundo para o topo. Cada um vira um sub-pane aninhado no
+ * pane da camada, para polígonos não cobrirem linhas/pontos da mesma camada.
+ */
+export type TipoGeometriaPane = 'poligono' | 'linha' | 'ponto' | 'texto';
+export declare const ORDEM_GEOMETRIA: TipoGeometriaPane[];
+export declare function nomeSubPane(layerId: string, tipo: TipoGeometriaPane): string;
+/** Garante (e devolve o nome de) o sub-pane de um tipo de geometria dentro do pane da camada. */
+export declare function garantirSubPane(map: L.Map, layerId: string, tipo: TipoGeometriaPane): string;
 export declare function garantirPanes(map: L.Map, layers: CanvasLayerDef[]): void;
 export declare function aplicarVisibilidadePane(map: L.Map, layer: CanvasLayerDef): void;
 export declare function aplicarOpacidadePane(map: L.Map, layer: CanvasLayerDef): void;

package/dist/gerencigeo-canvas/mapa_controller.d.ts

@@ -40,6 +40,7 @@ export declare class GerenciGeoMapaController {
     importState(state: CanvasLayerState[]): void;
     selectPonto(pId: string | number, zoomLevel?: number): void;
     atualizarDestaqueMarcadores(): void;
+    selectSegmento(segmentoId: string | number | null): void;
     fitBounds(pontos?: Ponto[], padding?: [number, number], incluirVizinhos?: boolean): void;
     getMarkers(): L.Marker[];
     getVizinhosMarkers(): L.Marker[];

package/dist/gerencigeo-canvas/mapa_pontos_shapes.d.ts

@@ -1,8 +1,27 @@
 /**
- * Helper para renderizar elementos HTML/SVG de marcadores no Leaflet Canvas/DOM.
- * Estilos inline 100% autônomos (independentes de Tailwind) e suporte completo a
- * formas geométricas topográficas (circle, circle-dot, square, diamond, cross, x, triangle)
- * com suporte nativo a seleção e destaque visual.
+ * Helper para renderizar marcadores (SVG inline, sem dependência de Tailwind) no Leaflet.
+ *
+ * Princípios visuais:
+ *  - Formas nítidas: preenchimento levemente translúcido + contorno escuro fino + aro claro interno,
+ *    legíveis tanto sobre satélite quanto sobre fundo escuro. Traços com `non-scaling-stroke`
+ *    (espessura constante em px, independente do tamanho do marcador).
+ *  - Sem blur/glow: `drop-shadow` e `box-shadow` borrados eram caros em alta densidade e passavam
+ *    aparência "esfumaçada". O destaque de seleção, como no CAD, escurece o símbolo (cor da camada
+ *    misturada com preto) e o recorta com contorno claro, sem anéis ao redor.
+ *  - Alta densidade: modo `compacta` reduz contorno e opacidade, de modo que sobreposições
+ *    fiquem legíveis (a cor "acumula") em vez de virar uma mancha de contornos escuros.
  */
+export type DensidadeMarcador = 'normal' | 'compacta';
+export interface OpcoesPontoShape {
+    densidade?: DensidadeMarcador;
+}
+/** Acima deste total de pontos na camada, os marcadores passam a usar o modo compacto. */
+export declare const LIMIAR_DENSIDADE_ALTA = 300;
+export declare function modoDensidade(total: number): DensidadeMarcador;
+/**
+ * Fator de escala (0.6–1) aplicado ao tamanho dos marcadores em camadas densas.
+ * Diminui com o nº de pontos (log) e com o afastamento do zoom, onde os pontos mais se sobrepõem.
+ */
+export declare function fatorDensidade(total: number, zoom: number): number;
 export declare function extrairCorPonto(bgClassOuCor: string): string;
-export declare function getPointShapeHtml(shapeStyle: string, size: number, bgClass: string, extraClasses?: string, id?: string, selecionado?: boolean): string;
+export declare function getPointShapeHtml(shapeStyle: string, size: number, bgClass: string, extraClasses?: string, id?: string, selecionado?: boolean, opcoes?: OpcoesPontoShape): string;

package/dist/gerencigeo-canvas/renderers/feicoes_renderer.d.ts

@@ -0,0 +1,89 @@
+import { default as L } from 'leaflet';
+import { ILayerRenderer } from '../layer_renderer_factory';
+import { CanvasLayerDef, CanvasRenderContext } from '../types';
+import { Feicao } from '../feature_types';
+import { CaixaGeo } from '../feature_indice';
+export declare const ICONES_FEICAO: Record<string, string>;
+/** Cores vão para atributos style; só passam formatos conhecidos (hex, rgb/hsl, nome). */
+export declare function corSegura(cor: string | undefined, padrao: string): string;
+/**
+ * Mudança incremental enviada pelo gerenciador junto com os dados (`dados.delta`). Só vale se `base` for a lista que
+ * este renderizador sincronizou por último; senão a camada é reconciliada por inteiro.
+ */
+export interface DeltaFeicoes {
+    base: Feicao[];
+    /** Feições novas ou trocadas (as `excluida` saem da camada). */
+    mudadas: Feicao[];
+    removidas: string[];
+}
+type Grupo = L.LayerGroup;
+export declare const COR_SELECAO = "#38bdf8";
+/** Até aqui mantém tudo carregado (sem pop-in); acima, só o que está perto da tela. */
+export declare const LIMITE_CULLING = 300;
+export declare class FeicoesLayerRenderer implements ILayerRenderer {
+    private estados;
+    /** Por definição de camada (uma por componente), para a seleção sobreviver à recriação do grupo. */
+    private selecionadas;
+    private tokenLote;
+    render(layerDef: CanvasLayerDef, map: L.Map, context: CanvasRenderContext): L.LayerGroup;
+    update(layerDef: CanvasLayerDef, layerInstance: L.LayerGroup, changes: Partial<CanvasLayerDef>, context: CanvasRenderContext, map: L.Map): void;
+    destroy(layerInstance: L.LayerGroup, map: L.Map): void;
+    /** A regra de versões mudou (prévias ligadas/desligadas): recalcula o que aparece. */
+    reavaliarVersoes(group: Grupo): void;
+    /** A feição aparece segundo a regra de oficial × prévia? */
+    feicaoVisivel(group: Grupo, f: Feicao): boolean;
+    /** Feições da camada cujo envelope toca `caixa` (para snap e consultas espaciais). */
+    consultarProximas(group: Grupo, caixa: CaixaGeo): Feicao[];
+    /** Mostra uma geometria provisória (durante um arrasto) sem tocar nos dados nem no índice. */
+    previsualizar(group: Grupo, f: Feicao): void;
+    /** Para testes e diagnóstico: quantas feições estão materializadas e quantos clusters desenhados. */
+    estatisticas(group: Grupo): {
+        total: number;
+        materializadas: number;
+        clusters: number;
+    } | null;
+    private feicoesDe;
+    private obterEstado;
+    private sincronizar;
+    private recontarOficiais;
+    /** Aplica só a diferença. Devolve `false` se o delta não parte da lista sincronizada (então o caminho completo roda). */
+    private aplicarDelta;
+    /** Há geometria grande demais para o zoom atual? Só então vale redesenhar ao mudar de zoom. */
+    private ressimplificar;
+    private paraDesenho;
+    /** Vai para a tela? Não oculta e visível pela regra oficial × prévia. */
+    private desenhavel;
+    private estaCarregado;
+    private caixaDe;
+    /** Cria a camada Leaflet da feição ou remenda a que existe (e só se algo mudou). */
+    private materializar;
+    private tirarEntrada;
+    private colocarCluster;
+    private tirarCluster;
+    /** O agrupador do zoom atual (reconstruído se os dados-base ou o zoom mudaram) ou `null` se não há agrupamento. */
+    private agrupadorAtivo;
+    /** Calcula o que deve estar desenhado e ajusta as camadas Leaflet (cria, remenda, remove). */
+    private reconciliar;
+    /**
+     * Reconcilia só o que o delta tocou (o custo não depende do tamanho da camada). Cai no reconcile completo quando
+     * o estado de conjunto muda: regra oficial × prévia, entrada/saída do corte por viewport ou do agrupamento.
+     */
+    private reconciliarParcial;
+    private criarMarcadorCluster;
+    /**
+     * Marca como selecionadas as feições `ids` deste grupo (as demais voltam ao estilo normal).
+     * Só as que mudaram são tocadas; mudanças grandes são aplicadas em blocos, as visíveis primeiro.
+     * Pontos selecionados saem dos clusters; ao desmarcar, voltam a ser agrupados.
+     */
+    aplicarSelecao(group: Grupo, ids: Set<string>): void;
+    private formaDe;
+    private paneDe;
+    private estiloVetor;
+    private criar;
+    private remendar;
+    private iconeSvg;
+    private iconeTexto;
+    private aplicarRotulo;
+    private ligarEventos;
+}
+export {};

package/dist/gerencigeo-canvas/renderers/vector_points_renderer.d.ts

@@ -4,6 +4,7 @@ import { CanvasLayerDef, CanvasRenderContext } from '../types';
 export declare class VectorPointsLayerRenderer implements ILayerRenderer {
     private zoomListenerMap;
     render(layerDef: CanvasLayerDef, map: L.Map, context: CanvasRenderContext): L.LayerGroup;
+    private criarIcone;
     private calculateSize;
     private rebuildPoints;
     update(layerDef: CanvasLayerDef, layerInstance: L.LayerGroup, changes: Partial<CanvasLayerDef>, context: CanvasRenderContext, map: L.Map): void;