@thibezer/ui-components-kit 2.8.2 → 2.9.0

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/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;
+}

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

@@ -0,0 +1,95 @@
+import { CamadaDesenho, ListaDesenho, Vista } from '../motor/tipos';
+/** O que a pintura usa do Canvas 2D (permite testar com um contexto falso que grava as chamadas). */
+export interface ContextoFormas2D {
+    fillStyle: string | CanvasGradient | CanvasPattern;
+    strokeStyle: string | CanvasGradient | CanvasPattern;
+    lineWidth: number;
+    lineJoin: CanvasLineJoin;
+    lineCap: CanvasLineCap;
+    globalAlpha: number;
+    setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+    clearRect(x: number, y: number, w: number, h: number): void;
+    save(): void;
+    restore(): void;
+    rect(x: number, y: number, w: number, h: number): void;
+    clip(): void;
+    beginPath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    closePath(): void;
+    arc(x: number, y: number, r: number, a0: number, a1: number): void;
+    fill(): void;
+    stroke(): void;
+    fillRect(x: number, y: number, w: number, h: number): void;
+    setLineDash(segmentos: number[]): void;
+}
+/** Superfície de pintura de uma camada (ou da sobreposição): o contexto e o tamanho do canvas em px CSS. */
+export interface SuperficiePintura {
+    ctx: ContextoFormas2D;
+    largura: number;
+    altura: number;
+    dpr: number;
+}
+export interface AlvosPintura {
+    camada(camadaId: string): SuperficiePintura | null;
+    sobreposicao(): SuperficiePintura | null;
+}
+/** Região do canvas, em px CSS a partir do canto superior esquerdo. */
+export interface RegiaoPx {
+    x: number;
+    y: number;
+    largura: number;
+    altura: number;
+}
+export interface OpcoesDesenho {
+    /** `'base'` (padrão): um canvas por camada. `'sobreposicao'`: seleção, destaque e edição, todas as camadas no mesmo canvas. */
+    alvo?: 'base' | 'sobreposicao';
+    /** Limpa antes de pintar (padrão: sim). A sobreposição é limpa uma vez, antes de todas as camadas. */
+    limpar?: boolean;
+    /** Pinta só nesta região (nada fora dela é tocado). Use com `limpar: false` sobre um bitmap já deslocado. */
+    recorte?: RegiaoPx;
+}
+export interface EstatisticasPintura {
+    itens: number;
+    marcas: number;
+    preenchimentos: number;
+    tracos: number;
+    chamadas: number;
+}
+/** Contrato pequeno do renderizador das formas. */
+export interface RenderizadorFormas {
+    desenhar(lista: ListaDesenho, vista: Vista, opcoes?: OpcoesDesenho): EstatisticasPintura;
+    destacar(ids: Iterable<string>): void;
+    limpar(): void;
+    destruir(): void;
+}
+/** `dashArray` do SVG/Leaflet ("6 4", "6,4") em segmentos; inválido ou vazio = linha contínua. */
+export declare function parseDash(dash: string | undefined): number[];
+/** Quantos itens da camada o pintor desenha no canvas (os demais são marcadores DOM e curvas). */
+export declare function contarItensCanvas(camada: CamadaDesenho | null | undefined): number;
+export declare class PintorCanvas2D implements RenderizadorFormas {
+    private readonly alvos;
+    private destaques;
+    private destruido;
+    /** Estatística da última pintura (diagnóstico e testes). */
+    ultima: EstatisticasPintura;
+    constructor(alvos: AlvosPintura);
+    destacar(ids: Iterable<string>): void;
+    limpar(): void;
+    destruir(): void;
+    desenhar(lista: ListaDesenho, vista: Vista, opcoes?: OpcoesDesenho): EstatisticasPintura;
+    private limparSuperficie;
+    private pintarCamada;
+    private agrupar;
+    /** Marcas de LOD: `fillRect` por marca, a cor definida uma vez por grupo. */
+    private pintarMarcas;
+    /** Caminho de um item: anéis/partes (polígono e linha), círculo ou ponto. */
+    private caminho;
+    /**
+     * Polígonos, círculos, linhas e pontos: o estilo do grupo é definido uma vez; cada forma é um caminho próprio com
+     * preenchimento (se o estilo preenche) e traço. `areas` = tipos que podem ser preenchidos.
+     */
+    private pintarGrupos;
+    /** Halo de destaque (hover): traço claro, mais grosso, por baixo do desenho normal. */
+    private halo;
+}

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

@@ -0,0 +1,6 @@
+import { CanvasLayerDef } from '../types';
+/**
+ * Seleção visual por definição de camada, compartilhada pelos renderizadores de feições (`leaflet` e `canvas`): ela
+ * sobrevive à recriação do grupo (ocultar e exibir a camada) e à troca de renderizador.
+ */
+export declare const selecaoVisual: WeakMap<CanvasLayerDef, Set<string>>;

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

@@ -178,4 +178,6 @@ export interface CanvasRenderContext {
     onPopupAcao?: (acaoId: string, elementoId: string | number, elemento: any) => void;
     /** Regra de oficial × prévia das camadas de feições (uma por componente). */
     regraVersoes?: import('./feature_versoes').RegraVersoes;
+    /** Qual renderizador desenha as camadas de feições (atributo `renderizador` do componente). Ausente = `leaflet`. */
+    renderizador?: () => 'leaflet' | 'canvas';
 }

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

@@ -0,0 +1,10 @@
+/**
+ * Zoom em passos finos (como CAD/GIS). O padrão do Leaflet (`zoomSnap: 1`) arredonda cada giro da roda para um nível
+ * inteiro, e um nível dobra a escala: o mapa "pula". Com 0,25 de passo, cada giro da roda anda cerca de meio nível (medido no Chrome/Windows) e as teclas +/- andam 0,5.
+ * Funções que dependem do zoom (simplificação, clusters, densidade, pré-carga de tiles) aceitam valores fracionários.
+ */
+export declare const OPCOES_ZOOM_FINO: {
+    readonly zoomSnap: 0.25;
+    readonly zoomDelta: 0.5;
+    readonly wheelPxPerZoomLevel: 90;
+};