@thibezer/ui-components-kit 2.8.2 → 2.10.0

package/dist/gerencigeo-canvas/motor/geometria-px.d.ts

@@ -0,0 +1,27 @@
+import { LatLonPar } from '../feature_types';
+/** Pixels de mundo da latitude/longitude no zoom, gravados em `saida[i]` (x) e `saida[i + 1]` (y). Não lança. */
+export declare function projetarEm(saida: Float64Array, i: number, lat: number, lon: number, escala: number): void;
+export declare const escalaDoZoom: (zoom: number) => number;
+/** Inverso de `projetarEm`: pixels de mundo no zoom → [lat, lon]. */
+export declare function latLonDoMundo(x: number, y: number, zoom: number): LatLonPar;
+/** Projeta uma lista de [lat, lon]. */
+export declare function projetarVertices(coords: ReadonlyArray<LatLonPar>, zoom: number): Float64Array;
+export declare function projetarCentro(lat: number, lon: number, zoom: number): Float64Array;
+/** Metros por pixel na latitude e no zoom. */
+export declare function metrosPorPixel(lat: number, zoom: number): number;
+/** Raio, em pixels, de um círculo de `raioMetros` com centro na latitude (raio por zoom e latitude). */
+export declare function raioCirculoPx(lat: number, raioMetros: number, zoom: number): number;
+export interface CaixaMundoPx {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+/** Envelope em px de vários arrays planos; `null` se não houver nenhum vértice finito. */
+export declare function caixaPx(partes: ReadonlyArray<Float64Array>): CaixaMundoPx | null;
+/**
+ * Douglas-Peucker iterativo em pixels (tolerância em px, sem cos(lat): as coordenadas já são de tela). `fechado`
+ * trata o anel como fechado (o corte não depende de onde ele "começa") e nunca devolve menos de 3 vértices (senão
+ * volta o original). Tolerância inválida (≤ 0, NaN) devolve a própria entrada.
+ */
+export declare function simplificarPx(pts: Float64Array, tolerancia: number, fechado: boolean): Float64Array;

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

@@ -0,0 +1,5 @@
+export * from './tipos';
+export * from './estilo';
+export * from './geometria-px';
+export { DadosCamada } from './dados-camada';
+export { MotorFormas } from './motor-formas';

package/dist/gerencigeo-canvas/motor/motor-formas.d.ts

@@ -0,0 +1,107 @@
+import { Feicao, LatLonPar } from '../feature_types';
+import { CaixaGeo } from '../feature_indice';
+import { CamadaDesenho, DefCamadaMotor, DeltaMotor, EstatisticasCamada, ListaDesenho, RegraVisivel, Vista } from './tipos';
+/** Que parte da lista o chamador quer: o que se pinta no canvas, os marcadores DOM, ou tudo. */
+export type ParteLista = 'tudo' | 'canvas' | 'dom';
+export declare class MotorFormas {
+    private camadas;
+    private regra;
+    /** Cria a camada ou atualiza a definição (estilo, zIndex, opacidade, visibilidade). */
+    definirCamada(def: DefCamadaMotor): void;
+    removerCamada(camadaId: string): void;
+    temCamada(camadaId: string): boolean;
+    definirRegra(regra: RegraVisivel | null): void;
+    /** A regra de versões mudou (prévias ligadas/desligadas): o conjunto desenhado e o agrupamento precisam ser refeitos. */
+    reavaliarVersoes(camadaId: string): void;
+    /** Troca total dos dados da camada (diferencia contra o que já existe). */
+    definirFeicoes(camadaId: string, lista: Feicao[]): void;
+    /**
+     * Mudança incremental: só vale se `delta.base` for a lista sincronizada por último; senão a camada é refeita
+     * por inteiro a partir de `lista`.
+     */
+    aplicarDelta(camadaId: string, lista: Feicao[], delta: DeltaMotor): void;
+    private pontoVisivel;
+    private aposMudanca;
+    /** O agrupador do zoom atual acompanha os pontos que mudaram (células afetadas, sem reagrupar a camada). */
+    private manterAgrupador;
+    /** Define a seleção da camada. Devolve quem entrou e quem saiu (só o que mudou). */
+    selecionar(camadaId: string, ids: Iterable<string>): {
+        entrou: string[];
+        saiu: string[];
+    };
+    selecionadas(camadaId: string): ReadonlySet<string>;
+    /** Geometria provisória (arrasto de vértice): o canvas base deixa de desenhar a feição e a sobreposição a mostra. */
+    previsualizar(camadaId: string, f: Feicao): void;
+    temPrevia(camadaId: string, id: string): boolean;
+    /** Realce temporário (hover): as feições entram na sobreposição com `destaque: true`. */
+    destacar(camadaId: string, ids: Iterable<string>): void;
+    feicao(camadaId: string, id: string): Feicao | undefined;
+    caixaDe(camadaId: string, id: string): CaixaGeo | undefined;
+    /** Feições cujo envelope toca `caixa`, sem as ocultas (snap, hit-test, seleção por caixa). Não passa pelo LOD. */
+    consultarCaixa(camadaId: string, caixa: CaixaGeo): Feicao[];
+    feicaoVisivel(camadaId: string, f: Feicao): boolean;
+    estatisticas(camadaId: string): EstatisticasCamada | null;
+    /** Entidades da camada com prévia e com oficial (pares em detalhe completo): para testes e diagnóstico. */
+    ehPar(camadaId: string, f: Feicao): boolean;
+    /**
+     * O que desenhar nesta vista, camada a camada, na ordem de empilhamento (a última fica por cima).
+     * `parte`: `'canvas'` só o que se pinta no canvas (marcas, formas, pontos sem ícone), `'dom'` só marcadores DOM e
+     * curvas (clusters, ícones, textos, rótulos), `'tudo'` (padrão) os dois. O pan incremental pede o canvas só das faixas
+     * expostas e o DOM da vista inteira (poucos itens, sem projetar nem simplificar formas).
+     */
+    listaDesenho(vista: Vista, opcoes?: {
+        camadas?: string[];
+        parte?: ParteLista;
+    }): ListaDesenho;
+    private origemDe;
+    private camadaVazia;
+    private prepararZoom;
+    private estiloDe;
+    private emPar;
+    /**
+     * Vira marca? Sempre em detalhe completo: com rótulo e em par oficial × prévia; ponto e texto nunca. A seleção NÃO
+     * entra aqui: o canvas base não depende dela (a sobreposição desenha a selecionada em detalhe completo por cima).
+     */
+    private comoMarca;
+    /** Geometria projetada e simplificada em px, em cache por (feição, revisão, zoom). `null` se não há o que desenhar. */
+    private geometriaProjetada;
+    private construirGeometria;
+    /** Marca de LOD: centro do envelope, lado de 1–2 px, cor do preenchimento/contorno. */
+    private marcaDe;
+    /**
+     * Item da marca, em cache junto com a geometria por (feição, zoom). Com 100 mil marcas na tela, montar o item e internar
+     * o estilo a cada vista custava a maior parte da lista; no pan agora só se confere se algo mudou, sem alocar.
+     */
+    private itemMarca;
+    private estiloMarca;
+    private agrupadorAtivo;
+    private itemBase;
+    /**
+     * A caixa da vista com uma folga de poucos px: o traço de uma feição com o envelope logo fora da vista ainda entra nela
+     * (o índice é por envelope). Sem isto, o pan incremental e o quadro completo divergem na borda do canvas.
+     */
+    private caixaComFolga;
+    private listarCamada;
+    /**
+     * Clusters da vista (marcadores DOM). Selecionado nunca entra em cluster; o cluster só aparece com o centro dentro da
+     * vista e com 2 ou mais restantes. Os pontos individuais que a seleção solta (o selecionado e o único restante de uma
+     * célula) são da sobreposição: o canvas base não depende da seleção.
+     */
+    private listarClusters;
+    /** O ponto está dentro de um cluster neste zoom (não é desenhado nem clicável individualmente)? */
+    pontoAgrupado(camadaId: string, id: string): boolean;
+    /** O ponto de uma célula de cluster aparece solto: está selecionado ou é o único restante não selecionado? */
+    private soltoDoCluster;
+    /** Membros (id e coordenada) da célula de cluster: o clique no cluster enquadra o grupo. */
+    membrosDoCluster(camadaId: string, chave: string): Array<{
+        id: string;
+        coordenada: LatLonPar;
+    }>;
+    /**
+     * Itens da sobreposição: feições selecionadas, em edição ou destacadas, sempre em detalhe completo e com o estilo
+     * de seleção. Custo O(selecionadas): selecionar não repinta o canvas base.
+     */
+    listaSobreposicao(camadaId: string, vista: Vista): CamadaDesenho | null;
+    /** A seleção da camada toca pontos sob agrupamento ativo? (então o conjunto de clusters muda e o base precisa refazer) */
+    selecaoAfetaAgrupamento(camadaId: string, ids: Iterable<string>): boolean;
+}

package/dist/gerencigeo-canvas/motor/tipos.d.ts

@@ -0,0 +1,100 @@
+import { CaixaGeo } from '../feature_indice';
+import { PontoMundo } from '../feature_lod';
+import { Feicao, LatLonPar } from '../feature_types';
+import { LayerStyleDef } from '../types';
+import { EstiloVetor } from './estilo';
+export type { PontoMundo };
+/**
+ * Janela que o motor desenha. `caixa` é o que cabe no canvas (geográfica); `origemPx` são os pixels de mundo, no
+ * zoom, do canto superior esquerdo do canvas: o pintor subtrai esse valor em dupla precisão (coordenadas de mundo em
+ * zoom alto não cabem em float32 do canvas). Sem `origemPx` ela é derivada de `caixa`.
+ */
+export interface Vista {
+    caixa: CaixaGeo;
+    zoom: number;
+    larguraPx: number;
+    alturaPx: number;
+    dpr: number;
+    origemPx?: PontoMundo;
+}
+/**
+ * Formas de desenho:
+ * - pintadas no canvas: `marca` (LOD), `poligono`, `circulo`, `linha`, `ponto` (sem ícone);
+ * - marcadores DOM (dependem de CSS e arraste, ficam no Leaflet): `icone`, `texto`, `cluster`, `rotulo`;
+ * - `curva` (linha/polígono Bézier): caminho Leaflet legado dentro do mesmo renderizador (pendência explícita).
+ */
+export type FormaDesenho = 'marca' | 'poligono' | 'circulo' | 'linha' | 'ponto' | 'icone' | 'texto' | 'cluster' | 'rotulo' | 'curva';
+export interface ItemDesenho {
+    camadaId: string;
+    /** Id da feição; no cluster, a chave da célula; no rótulo, `rotulo:<id>`. */
+    id: string;
+    forma: FormaDesenho;
+    /**
+     * Pixels de MUNDO no zoom da vista (subtraia `origem` ao pintar). Poligono/linha: um array `[x0, y0, x1, y1, ...]`
+     * por anel/parte. Círculo, ponto e marca: um array `[x, y]` com o centro. Marcadores DOM e curva: vazio.
+     */
+    geometriaEmPx: Float64Array[];
+    /** Círculo e ponto: raio em px (círculo em metros convertido por zoom e latitude). Marca: lado (1 ou 2). */
+    raioPx: number;
+    /** Estilo normal (sem seleção); o realce de seleção vem de `listaSelecao`. Interno: itens iguais compartilham o objeto. */
+    estilo: EstiloVetor;
+    /** A feição está selecionada? (marcadores DOM trocam de aparência; o canvas base não depende disto.) */
+    selecionada: boolean;
+    /** Realce temporário (hover/edição), pedido por `destacar`. */
+    destaque?: boolean;
+    /** Feição de origem (marcadores DOM, curva, clique). Ausente no cluster. */
+    feicao?: Feicao;
+    /** Icone, texto, rótulo e cluster: posição [lat, lon]. */
+    coordenada?: LatLonPar;
+    /** Cluster: quantos pontos há na célula e quantos aparecem no cluster (o resto está selecionado). */
+    total?: number;
+    restantes?: number;
+    /** Rótulo: texto a exibir. */
+    texto?: string;
+}
+export interface EstatisticasCamada {
+    /** Feições na camada. */
+    total: number;
+    /** Itens no canvas ou em marcadores DOM nesta vista (sem contar as marcas de LOD). */
+    desenhadas: number;
+    /** Feições pequenas pintadas como marca de 1–2 px. */
+    marcasLOD: number;
+    clusters: number;
+    /** Marcadores DOM pedidos (ícones, textos, clusters, rótulos). */
+    marcadoresDom: number;
+    /** Quantas vezes o LOD foi calculado (no pan puro não cresce). */
+    avaliacoesLOD: number;
+}
+export interface CamadaDesenho {
+    camadaId: string;
+    zIndex: number;
+    opacidade: number;
+    /** Pintar primeiro as marcas, depois polígonos/círculos, linhas e pontos; DOM e curvas vêm separados. */
+    itens: ItemDesenho[];
+    estatisticas: EstatisticasCamada;
+}
+/** Camadas visíveis, na ordem de empilhamento (zIndex crescente = a última fica por cima). */
+export interface ListaDesenho {
+    vista: Vista;
+    /** Pixels de mundo do canto superior esquerdo do canvas (a `origemPx` da vista, já resolvida). */
+    origem: PontoMundo;
+    camadas: CamadaDesenho[];
+}
+export interface DefCamadaMotor {
+    id: string;
+    zIndex: number;
+    opacidade: number;
+    visivel: boolean;
+    interativo: boolean;
+    bloqueada?: boolean;
+    estilo: LayerStyleDef;
+}
+/** Regra de visibilidade por versão (oficial × prévia): `RegraVersoes.visivel` serve direto. */
+export type RegraVisivel = (f: Feicao, comOficial: Set<string>) => boolean;
+/** Mudança incremental (a mesma que o gerenciador manda ao renderizador Leaflet). */
+export interface DeltaMotor {
+    /** A lista que o motor sincronizou por último; se não bater, o motor refaz a camada por inteiro. */
+    base: Feicao[];
+    mudadas: Feicao[];
+    removidas: string[];
+}

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

@@ -0,0 +1,30 @@
+import { default as L } from 'leaflet';
+export type ModoPopups = 'sob-demanda' | 'automatico' | 'desligado';
+export declare const MODO_POPUPS_PADRAO: ModoPopups;
+export declare function lerModoPopups(valor: string | null | undefined): ModoPopups;
+/** Executa `fn` com os popups do mapa liberados (pedido explícito do usuário). Sem portão, só executa. */
+export declare function liberarPopups<T>(map: object | null | undefined, fn: () => T): T;
+export declare function obterPortaoPopups(map: object | null | undefined): PortaoPopups | undefined;
+export declare class PortaoPopups {
+    private map;
+    private modoAtual;
+    private liberados;
+    /** Verdadeiro durante o despacho síncrono de um clique no mapa (o Leaflet abre popups dentro dele). */
+    private emClique;
+    private pendentes;
+    private instalado;
+    private readonly original;
+    constructor(map: L.Map, modoAtual?: ModoPopups);
+    private container;
+    /** Fase de captura: roda antes dos tratadores do Leaflet, que abrem o popup dentro do mesmo clique. */
+    private marcarClique;
+    get modo(): ModoPopups;
+    definirModo(modo: ModoPopups): void;
+    /** Abre o que `fn` abrir, independentemente do modo. Reentrante e sempre devolve o portão ao estado anterior. */
+    liberar<T>(fn: () => T): T;
+    destruir(): void;
+    private aoAbrir;
+    /** O clique foi barrado: se vier um duplo clique na mesma camada logo em seguida, abre. */
+    private aguardarDuploClique;
+    private cancelarPendentes;
+}

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

@@ -0,0 +1,5 @@
+import { default as L } from 'leaflet';
+/** Solta `map._popup` se ele ainda for o `popup` (já fechado). Devolve se soltou. */
+export declare function descartarPopupResidual(map: L.Map | null | undefined, popup: L.Popup | null | undefined): boolean;
+/** Liga a limpeza ao evento `popupclose` do mapa (o mapa descarta o ouvinte ao ser removido). */
+export declare function liberarEscDoPopup(map: L.Map): void;

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

@@ -0,0 +1,87 @@
+import { default as L } from 'leaflet';
+import { CaixaGeo } from '../feature_indice';
+import { PontoMundo } from '../motor/tipos';
+import { RegiaoPx } from './renderizador_formas';
+/** Tudo que o renderizador precisa para pintar um quadro. */
+export interface QuadroCanvas {
+    ctx: CanvasRenderingContext2D;
+    /** Multiplicador de retina do Leaflet (1 ou 2). */
+    dpr: number;
+    /** Tamanho do canvas em px CSS. */
+    larguraPx: number;
+    alturaPx: number;
+    /** Pixels de mundo, no zoom, do canto superior esquerdo do canvas. */
+    origemPx: PontoMundo;
+    /** O que cabe no canvas, em coordenadas geográficas. */
+    caixa: CaixaGeo;
+    zoom: number;
+    /**
+     * `null`: pintar o canvas inteiro. Lista: o bitmap já foi deslocado e só estas regiões (px CSS) estão vazias e
+     * precisam ser pintadas (vazia = nada novo ficou à mostra).
+     */
+    regioes: RegiaoPx[] | null;
+    /**
+     * O bitmap está em branco antes desta pintura? Quem pinta pode então não tocar no canvas quando não há o que desenhar:
+     * qualquer chamada de desenho (até um `clearRect`) faz o navegador reenviar o canvas inteiro ao compositor.
+     */
+    branco: boolean;
+}
+/**
+ * Devolve quantos itens de canvas a pintura deixou no bitmap (numa faixa do pan, quantos ACRESCENTOU), ou só se deixou
+ * algo (`true`/`void`: algo, quantidade desconhecida; `false`: nada).
+ */
+export type PintarQuadro = (quadro: QuadroCanvas) => number | boolean | void;
+export interface OpcoesCanvasFormas extends L.RendererOptions {
+    /** Pan incremental: desloca o bitmap e pinta só as faixas expostas (padrão: não; a sobreposição repinta inteira). */
+    incremental?: boolean;
+    /** Pan incremental com até tantos itens no bitmap: repinta inteiro em vez de deslocar (padrão: `CanvasFormas.limiteRepintar`). */
+    limiteRepintar?: number;
+}
+/** Regiões que ficam vazias quando o conteúdo se desloca de (`dx`, `dy`) px: a faixa vertical inteira e a horizontal sem a quina. */
+export declare function regioesExpostas(largura: number, altura: number, dx: number, dy: number): RegiaoPx[];
+export declare class CanvasFormas extends L.Canvas {
+    /**
+     * Com poucos itens no bitmap, repintar a vista inteira custa menos que deslocá-lo: o deslocamento copia o bitmap
+     * todo (3072×1920 com dpr 2), seja qual for o conteúdo. Medido (sem GPU): ~180 itens por camada repintam 3× mais
+     * rápido; ~650 empatam; ~1 500 já perdem. Ajustável (benchmark); ver docs/desempenho-feicoes.md.
+     */
+    static limiteRepintar: number;
+    private readonly aoPintar;
+    private readonly incremental;
+    private readonly limiteProprio;
+    /** Itens de canvas no bitmap (estimativa por cima entre repinturas completas: as faixas só somam). */
+    private itens;
+    /** O bitmap tem um quadro completo válido (deslocável)? Cai para falso ao redimensionar ou se a pintura falhar. */
+    private conteudoValido;
+    /**
+     * O bitmap está em branco? Canvas em branco não é deslocado no pan nem apagado de novo no `_update`: com várias
+     * camadas sem nada na vista (zoom alto, camada esparsa), o pan deixa de reenviar canvases vazios ao compositor.
+     */
+    private branco;
+    /** Canto superior esquerdo do bitmap em pixels de MUNDO no último `_update`: o deslocamento do conteúdo se mede aqui. */
+    private mundoMin;
+    /** Regiões a pintar no próximo quadro (calculadas no `_update`); `null` = canvas inteiro. */
+    private regioesDaVez;
+    /** Quantas pinturas falharam (e a última causa): diagnóstico, já que a falha é engolida. */
+    falhas: number;
+    ultimoErro: unknown;
+    constructor(opcoes: OpcoesCanvasFormas, aoPintar: PintarQuadro);
+    private get limiteRepintar();
+    /**
+     * O primeiro `update` do canvas acontece antes de o Leaflet ouvi-lo (e o `onAdd` do L.Canvas ainda limpa o canvas):
+     * por isso o primeiro quadro é pintado aqui.
+     */
+    onAdd(map: L.Map): this;
+    /**
+     * Reposiciona o canvas para a vista (moveend, zoomend, resize). Igual ao `L.Canvas._update`, exceto que o bitmap é
+     * preservado e deslocado quando só houve pan, em vez de ser sempre apagado pelo redimensionamento.
+     */
+    protected _update(): void;
+    /** O Leaflet chama isto depois de cada `update` do canvas (moveend, zoomend, resize); aqui vai a pintura. */
+    protected _updatePaths(): void;
+    /** Repinta o canvas INTEIRO agora (dados, estilo ou seleção que afeta o conjunto mudaram). */
+    pintar(): void;
+    private pintarQuadro;
+    /** O quadro com a vista atual do canvas, ou `null` se o canvas ainda não foi posicionado. */
+    quadroAtual(regioes?: RegiaoPx[] | null): QuadroCanvas | null;
+}

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

@@ -0,0 +1,58 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerDef, CanvasRenderContext } from '../types';
+import { Feicao } from '../feature_types';
+import { CaixaGeo } from '../feature_indice';
+import { EstatisticasFeicoes, IRenderizadorFeicoes } from './renderizador_feicoes_tipos';
+export declare class FeicoesCanvasRenderer implements IRenderizadorFeicoes {
+    private estados;
+    /** Por definição de camada, para a seleção sobreviver à recriação do grupo (ocultar e exibir a camada). */
+    private selecionadas;
+    render(layerDef: CanvasLayerDef, map: L.Map, context: CanvasRenderContext): L.LayerGroup;
+    update(layerDef: CanvasLayerDef, grupo: L.Layer | L.LayerGroup, changes: Partial<CanvasLayerDef>, context: CanvasRenderContext, _map: L.Map): void;
+    destroy(grupo: L.Layer | L.LayerGroup, map: L.Map): void;
+    reavaliarVersoes(grupo: L.LayerGroup): void;
+    feicaoVisivel(grupo: L.LayerGroup, f: Feicao): boolean;
+    consultarProximas(grupo: L.LayerGroup, caixa: CaixaGeo): Feicao[];
+    /** Geometria provisória (arrasto de vértice): a feição sai do base e a sobreposição a mostra com a geometria nova. */
+    previsualizar(grupo: L.LayerGroup, f: Feicao): void;
+    /**
+     * Marca como selecionadas as feições `ids` da camada. O custo é O(mudanças): a seleção só repinta a sobreposição e
+     * atualiza os marcadores DOM afetados; a base só é refeita se um ponto sob cluster entrou ou saiu da seleção.
+     */
+    aplicarSelecao(grupo: L.LayerGroup, ids: Set<string>): void;
+    estatisticas(grupo: L.LayerGroup): EstatisticasFeicoes | null;
+    /** Detalhe completo = formas, marcadores DOM e as selecionadas (a sobreposição as desenha inteiras); marca = LOD. */
+    idsDesenhados(grupo: L.LayerGroup): {
+        materializadas: string[];
+        marcas: string[];
+    } | null;
+    /** Repinta já (testes e benchmark; no uso normal o repaint é agendado por quadro). */
+    redesenharAgora(grupo: L.LayerGroup): void;
+    private defMotor;
+    private feicoesDe;
+    private pedirBase;
+    /** Sincroniza só os marcadores DOM com a vista atual (clusters, ícones, textos, rótulos), sem repintar o canvas. */
+    private pedirDom;
+    /** Lista do quadro atual da camada (sem pintar). */
+    private listaAtual;
+    /** A vista de uma faixa exposta no pan incremental (a origem continua sendo a do canvas inteiro). */
+    private vistaDaFaixa;
+    /**
+     * Pinta um quadro. Quadro completo: lista e pintura da vista inteira. Pan incremental (o bitmap já foi deslocado pelo
+     * host): só as faixas expostas são listadas e pintadas, recortadas na faixa; os marcadores DOM acompanham a vista
+     * inteira (são poucos e não custam projeção nem simplificação).
+     */
+    private pintarBase;
+    private acao;
+    private sincronizarDom;
+    private colocarDom;
+    private trocarIcone;
+    /** A seleção de UMA feição mudou: só o marcador DOM (ícone, texto) ou a curva dela precisa de aparência nova. */
+    private atualizarSelecaoDom;
+    /**
+     * Formas pintadas no canvas respondem ao clique pelo hit-test central do mapa, na geometria ORIGINAL (índice +
+     * `feicaoNoPonto`). Ícones, textos e curvas têm objetos Leaflet próprios e não entram aqui; pontos dentro de um
+     * cluster também não (o cluster é que responde).
+     */
+    private registrarHit;
+}

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

@@ -0,0 +1,31 @@
+import { default as L } from 'leaflet';
+import { CaixaGeo } from '../feature_indice';
+import { Feicao } from '../feature_types';
+import { CanvasLayerDef, CanvasRenderContext } from '../types';
+import { EstatisticasFeicoes, IRenderizadorFeicoes } from './renderizador_feicoes_tipos';
+export type ModoRenderizador = 'leaflet' | 'canvas';
+/** `renderizador` inválido ou ausente cai em `leaflet` (padrão até a Fase 4 do motor de formas). */
+export declare function lerModoRenderizador(valor: string | null | undefined): ModoRenderizador;
+export declare class DespachanteFeicoes implements IRenderizadorFeicoes {
+    readonly leaflet: IRenderizadorFeicoes;
+    readonly canvas: IRenderizadorFeicoes;
+    private roteamento;
+    constructor(leaflet?: IRenderizadorFeicoes, canvas?: IRenderizadorFeicoes);
+    private modo;
+    private de;
+    /** Qual caminho desenha este grupo? */
+    modoDe(grupo: object): ModoRenderizador;
+    render(layerDef: CanvasLayerDef, map: L.Map, context: CanvasRenderContext): L.Layer | L.LayerGroup | null;
+    update(layerDef: CanvasLayerDef, grupo: L.Layer | L.LayerGroup, changes: Partial<CanvasLayerDef>, context: CanvasRenderContext, map: L.Map): void;
+    destroy(grupo: L.Layer | L.LayerGroup, map: L.Map): void;
+    reavaliarVersoes(grupo: L.LayerGroup): void;
+    feicaoVisivel(grupo: L.LayerGroup, f: Feicao): boolean;
+    consultarProximas(grupo: L.LayerGroup, caixa: CaixaGeo): Feicao[];
+    previsualizar(grupo: L.LayerGroup, f: Feicao): void;
+    estatisticas(grupo: L.LayerGroup): EstatisticasFeicoes | null;
+    idsDesenhados(grupo: L.LayerGroup): {
+        materializadas: string[];
+        marcas: string[];
+    } | null;
+    aplicarSelecao(grupo: L.LayerGroup, ids: Set<string>): void;
+}

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

@@ -3,9 +3,10 @@ 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;
+import { ICONES_FEICAO } from './marcadores_feicoes';
+import { COR_SELECAO, corSegura } from '../motor/estilo';
+export { ICONES_FEICAO };
+export { corSegura, COR_SELECAO };
 /**
  * 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.
@@ -17,7 +18,6 @@ export interface DeltaFeicoes {
     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 {
@@ -36,11 +36,21 @@ export declare class FeicoesLayerRenderer implements ILayerRenderer {
     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. */
+    /**
+     * Para testes, benchmark e diagnóstico: `total` (na camada), `materializadas` (objetos Leaflet), `marcasLOD` (feições
+     * pequenas pintadas em lote), `clusters` e `avaliacoesLOD` (quantas vezes o LOD foi calculado; no pan puro não cresce).
+     */
     estatisticas(group: Grupo): {
         total: number;
         materializadas: number;
+        marcasLOD: number;
         clusters: number;
+        avaliacoesLOD: number;
+    } | null;
+    /** Ids desenhados, separados por forma (Leaflet × marca de LOD). Base da comparação "incremental = completo". */
+    idsDesenhados(group: Grupo): {
+        materializadas: string[];
+        marcas: string[];
     } | null;
     private feicoesDe;
     private obterEstado;
@@ -55,8 +65,34 @@ export declare class FeicoesLayerRenderer implements ILayerRenderer {
     private desenhavel;
     private estaCarregado;
     private caixaDe;
-    /** Cria a camada Leaflet da feição ou remenda a que existe (e só se algo mudou). */
+    /**
+     * Decide como a feição é desenhada: marca de LOD (menor que ~3 px) ou camada Leaflet. Sempre em detalhe completo:
+     * selecionada (inclui a em edição, que é sempre selecionada), com rótulo e em par oficial × prévia. Pontos e textos
+     * nunca viram marca (já têm a regra de cluster). `zoomLod < 0` = mapa sem vista: sem LOD.
+     * O resultado é guardado por (feição, zoom): no pan só se consulta; muda ao trocar de zoom ou de geometria.
+     */
+    private comoMarca;
+    private novaMarca;
+    /** Desenha a feição como marca ou camada Leaflet, trocando de uma forma para a outra quando preciso. */
+    private colocarFeicao;
+    /**
+     * Cria a camada das marcas na primeira necessidade e pede o redesenho. Sem marcas ela é desfeita: um canvas vazio por
+     * camada ainda custaria limpeza e rasterização a cada vista. O clique nas marcas entra no hit-test central do mapa
+     * (`layer_hit_test`), que escolhe UMA feição entre todas as camadas e dispara `click` na camada das marcas.
+     */
+    private sincronizarMarcas;
+    /**
+     * Hit-test das marcas na geometria ORIGINAL (índice + `feicaoNoPonto`): uma feição de 1 px continua clicável.
+     * Devolve as feições sob o ponto, da melhor para a pior, para a alternância de cliques empilhados do clique central.
+     */
+    private fonteDeMarcas;
+    private descartarMarcas;
+    /**
+     * Cria a camada Leaflet da feição ou remenda a que existe (e só se algo mudou). `'estilo'` só troca o estilo.
+     * Uma feição que o Leaflet recusa (coordenada NaN, por exemplo) fica sem desenho em vez de derrubar a camada inteira.
+     */
     private materializar;
+    private materializarFeicao;
     private tirarEntrada;
     private colocarCluster;
     private tirarCluster;
@@ -69,11 +105,13 @@ export declare class FeicoesLayerRenderer implements ILayerRenderer {
      * o estado de conjunto muda: regra oficial × prévia, entrada/saída do corte por viewport ou do agrupamento.
      */
     private reconciliarParcial;
+    private reconciliarParcialInterno;
     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.
+     * Só as que mudaram são tocadas, e só no estilo: o custo é O(mudanças), não O(visíveis). A camada inteira só é
+     * reconciliada quando a mudança pode alterar o CONJUNTO desenhado, ou seja, quando há ponto sob agrupamento
+     * (selecionado sai do cluster, desmarcado volta a ele). Mudanças grandes são aplicadas em blocos, as visíveis primeiro.
      */
     aplicarSelecao(group: Grupo, ids: Set<string>): void;
     private formaDe;
@@ -81,9 +119,10 @@ export declare class FeicoesLayerRenderer implements ILayerRenderer {
     private estiloVetor;
     private criar;
     private remendar;
+    /** Só o estilo (seleção): sem `setLatLngs`, que reprojetaria e recalcularia limites da forma. */
+    private restilizar;
     private iconeSvg;
     private iconeTexto;
     private aplicarRotulo;
     private ligarEventos;
 }
-export {};

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

@@ -0,0 +1,11 @@
+import { default as L } from 'leaflet';
+import { Feicao } from '../feature_types';
+import { LayerStyleDef } from '../types';
+import { EstiloVetor } from '../motor/estilo';
+export declare const ICONES_FEICAO: Record<string, string>;
+export declare function iconeSvg(f: Feicao, estiloCamada: LayerStyleDef, selecionada?: boolean): L.DivIcon;
+export declare function iconeTexto(f: Feicao, estiloCamada: LayerStyleDef, selecionada?: boolean): L.DivIcon;
+/** Bolinha numerada do agrupamento de pontos. */
+export declare function iconeCluster(n: number, estiloCamada: LayerStyleDef): L.DivIcon;
+/** Opções de `L.Path` a partir do estilo resolvido pelo motor (mesma tradução nos dois renderizadores). */
+export declare function opcoesPath(e: EstiloVetor, interativo: boolean): L.PathOptions;

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

@@ -0,0 +1,19 @@
+import { default as L } from 'leaflet';
+import { MarcaLOD } from '../feature_lod';
+export declare class CamadaMarcasLOD extends L.Layer {
+    private canvas;
+    private agendado;
+    private vivo;
+    private readonly nomePane;
+    private readonly obterMarcas;
+    /** Quantas marcas caíram dentro do canvas na última pintura (diagnóstico e testes). */
+    ultimaPintura: number;
+    constructor(nomePane: string, obterMarcas: () => Iterable<MarcaLOD>);
+    onAdd(map: L.Map): this;
+    onRemove(map: L.Map): this;
+    /** Pede um redesenho no próximo quadro (vários pedidos viram um só). */
+    solicitarRedesenho(): void;
+    private esconder;
+    /** Posiciona o canvas sobre a vista atual e pinta as marcas. Nunca lança: mapa sem vista ou sem Canvas 2D só não pinta. */
+    redesenhar(): void;
+}

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

@@ -0,0 +1,44 @@
+import { default as L } from 'leaflet';
+import { CaixaGeo } from '../feature_indice';
+import { Feicao } from '../feature_types';
+import { ILayerRenderer } from '../layer_renderer_factory';
+/**
+ * Contrato comum dos renderizadores de camadas de feições (`leaflet` e `canvas`): o gerenciador de feições fala só
+ * com isto e não sabe qual dos dois está desenhando.
+ */
+export interface EstatisticasFeicoes {
+    /** Feições na camada. */
+    total: number;
+    /** Desenhadas com detalhe completo: objetos Leaflet (caminho `leaflet`) ou formas no canvas e marcadores DOM (`canvas`). */
+    materializadas: number;
+    /** Feições pequenas pintadas como marca de 1–2 px (LOD). */
+    marcasLOD: number;
+    clusters: number;
+    /** Quantas vezes o LOD foi calculado (no pan puro não cresce). */
+    avaliacoesLOD: number;
+    /** Caminho `canvas`: itens pintados no canvas (sem as marcas). */
+    desenhadas?: number;
+    /** Caminho `canvas`: marcadores DOM (ícones, textos, clusters, rótulos). */
+    marcadoresDom?: number;
+    /** Canvases usados pela camada (o canvas dela + a sobreposição compartilhada, no caminho `canvas`). */
+    canvases?: number;
+    renderizador?: 'leaflet' | 'canvas';
+}
+export interface IRenderizadorFeicoes extends ILayerRenderer {
+    /** A regra de versões mudou (prévias ligadas/desligadas): recalcula o que aparece. */
+    reavaliarVersoes(grupo: L.LayerGroup): void;
+    /** A feição aparece segundo a regra de oficial × prévia? */
+    feicaoVisivel(grupo: L.LayerGroup, f: Feicao): boolean;
+    /** Feições da camada cujo envelope toca `caixa` (snap e consultas espaciais), sem as ocultas. */
+    consultarProximas(grupo: L.LayerGroup, caixa: CaixaGeo): Feicao[];
+    /** Mostra uma geometria provisória (arrasto de vértice) sem tocar nos dados nem no índice. */
+    previsualizar(grupo: L.LayerGroup, f: Feicao): void;
+    estatisticas(grupo: L.LayerGroup): EstatisticasFeicoes | null;
+    /** Ids desenhados em detalhe completo e ids desenhados como marca de LOD (comparação entre renderizadores). */
+    idsDesenhados(grupo: L.LayerGroup): {
+        materializadas: string[];
+        marcas: string[];
+    } | null;
+    /** Marca como selecionadas as feições `ids` da camada (as demais voltam ao estilo normal). */
+    aplicarSelecao(grupo: L.LayerGroup, ids: Set<string>): void;
+}