@thibezer/ui-components-kit 2.8.1 → 2.9.0

package/dist/data.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const r=require("./ui-tabela-propriedades-DzZlyNZ_.cjs"),a=require("./ui-badge-SIR81R9l.cjs");exports.GerenciadorValoresPropriedades=r.GerenciadorValoresPropriedades;exports.TabelaOrquestradorDados=r.TabelaOrquestradorDados;exports.TabelaRemotaController=r.TabelaRemotaController;exports.TabelaSelecaoController=r.TabelaSelecaoController;exports.UITabela=r.UITabela;exports.UITabelaPropriedades=r.UITabelaPropriedades;exports.abrirPopoverRedimensionamento=r.abrirPopoverRedimensionamento;exports.alternarCategoria=r.alternarCategoria;exports.alternarDirecaoOrdenacao=r.alternarDirecaoOrdenacao;exports.alternarPosicionamentoFlutuante=r.alternarPosicionamentoFlutuante;exports.aplicarOrdenacaoTabela=r.aplicarOrdenacaoTabela;exports.atualizarCampoVisual=r.atualizarCampoVisual;exports.avaliarExpressaoMatematica=r.avaliarExpressaoMatematica;exports.buscarLinhaPropriedade=r.buscarLinhaPropriedade;exports.colapsarTodasCategorias=r.colapsarTodasCategorias;exports.conectarArrastoFlutuante=r.conectarArrastoFlutuante;exports.conectarPainelControles=r.conectarPainelControles;exports.criarControladorSplitter=r.criarControladorSplitter;exports.criarEditorAcao=r.criarEditorAcao;exports.criarEditorBooleano=r.criarEditorBooleano;exports.criarEditorCorCad=r.criarEditorCorCad;exports.criarEditorCorSwatch=r.criarEditorCorSwatch;exports.criarEditorLinetype=r.criarEditorLinetype;exports.criarEditorLineweight=r.criarEditorLineweight;exports.criarEditorNumero=r.criarEditorNumero;exports.criarEditorReadonly=r.criarEditorReadonly;exports.criarEditorSelecao=r.criarEditorSelecao;exports.criarEditorTexto=r.criarEditorTexto;exports.criarEditorValor=r.criarEditorValor;exports.criarLinhaPropriedade=r.criarLinhaPropriedade;exports.executarOrquestracaoCorpo=r.executarOrquestracaoCorpo;exports.executarOrquestracaoHeader=r.executarOrquestracaoHeader;exports.executarRedimensionamentoColuna=r.executarRedimensionamentoColuna;exports.executarRedimensionamentoTeclado=r.executarRedimensionamentoTeclado;exports.exibirPromptPopoverRedimensionamento=r.exibirPromptPopoverRedimensionamento;exports.expandirTodasCategorias=r.expandirTodasCategorias;exports.focarProximoEditor=r.focarProximoEditor;exports.formatWidth=r.formatWidth;exports.getAlignmentClass=r.getAlignmentClass;exports.getRowHeight=r.getRowHeight;exports.getTextAlign=r.getTextAlign;exports.inicializarScrollVirtualizacao=r.inicializarScrollVirtualizacao;exports.iniciarRedimensionamentoColuna=r.iniciarRedimensionamentoColuna;exports.interpretarIndice=r.interpretarIndice;exports.limitarLarguraColuna=r.limitarLarguraColuna;exports.localizarIndiceItem=r.localizarIndiceItem;exports.montarEstruturaDOM=r.montarEstruturaDOM;exports.normalizarTexto=r.normalizarTexto;exports.orquestrarEstruturaInicial=r.orquestrarEstruturaInicial;exports.proximaDensidade=r.proximaDensidade;exports.redimensionarColunaPorDelta=r.redimensionarColunaPorDelta;exports.registrarAtualizadorEditor=r.registrarAtualizadorEditor;exports.renderizarCategoriasETree=r.renderizarCategoriasETree;exports.renderizarCorpoTabela=r.renderizarCorpoTabela;exports.renderizarHeaderTabela=r.renderizarHeaderTabela;exports.renderizarSeletorTipos=r.renderizarSeletorTipos;exports.sincronizarAtributosTabela=r.sincronizarAtributosTabela;exports.sincronizarPainelControles=r.sincronizarPainelControles;exports.sincronizarSelect=r.sincronizarSelect;exports.tratarMudancaAtributoTabela=r.tratarMudancaAtributoTabela;exports.valoresIguais=r.valoresIguais;exports.UIBadge=a.UIBadge;exports.UIChip=a.UIChip;exports.UIKpi=a.UIKpi;exports.UIMetrica=a.UIMetrica;exports.UIStat=a.UIStat;exports.UITag=a.UITag;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const r=require("./ui-tabela-propriedades-CjK2gG14.cjs"),a=require("./ui-badge-SIR81R9l.cjs");exports.GerenciadorValoresPropriedades=r.GerenciadorValoresPropriedades;exports.TabelaOrquestradorDados=r.TabelaOrquestradorDados;exports.TabelaRemotaController=r.TabelaRemotaController;exports.TabelaSelecaoController=r.TabelaSelecaoController;exports.UITabela=r.UITabela;exports.UITabelaPropriedades=r.UITabelaPropriedades;exports.abrirPopoverRedimensionamento=r.abrirPopoverRedimensionamento;exports.alternarCategoria=r.alternarCategoria;exports.alternarDirecaoOrdenacao=r.alternarDirecaoOrdenacao;exports.alternarPosicionamentoFlutuante=r.alternarPosicionamentoFlutuante;exports.aplicarOrdenacaoTabela=r.aplicarOrdenacaoTabela;exports.atualizarCampoVisual=r.atualizarCampoVisual;exports.avaliarExpressaoMatematica=r.avaliarExpressaoMatematica;exports.buscarLinhaPropriedade=r.buscarLinhaPropriedade;exports.colapsarTodasCategorias=r.colapsarTodasCategorias;exports.conectarArrastoFlutuante=r.conectarArrastoFlutuante;exports.conectarPainelControles=r.conectarPainelControles;exports.criarControladorSplitter=r.criarControladorSplitter;exports.criarEditorAcao=r.criarEditorAcao;exports.criarEditorBooleano=r.criarEditorBooleano;exports.criarEditorCorCad=r.criarEditorCorCad;exports.criarEditorCorSwatch=r.criarEditorCorSwatch;exports.criarEditorLinetype=r.criarEditorLinetype;exports.criarEditorLineweight=r.criarEditorLineweight;exports.criarEditorNumero=r.criarEditorNumero;exports.criarEditorReadonly=r.criarEditorReadonly;exports.criarEditorSelecao=r.criarEditorSelecao;exports.criarEditorTexto=r.criarEditorTexto;exports.criarEditorValor=r.criarEditorValor;exports.criarLinhaPropriedade=r.criarLinhaPropriedade;exports.executarOrquestracaoCorpo=r.executarOrquestracaoCorpo;exports.executarOrquestracaoHeader=r.executarOrquestracaoHeader;exports.executarRedimensionamentoColuna=r.executarRedimensionamentoColuna;exports.executarRedimensionamentoTeclado=r.executarRedimensionamentoTeclado;exports.exibirPromptPopoverRedimensionamento=r.exibirPromptPopoverRedimensionamento;exports.expandirTodasCategorias=r.expandirTodasCategorias;exports.focarProximoEditor=r.focarProximoEditor;exports.formatWidth=r.formatWidth;exports.getAlignmentClass=r.getAlignmentClass;exports.getRowHeight=r.getRowHeight;exports.getTextAlign=r.getTextAlign;exports.inicializarScrollVirtualizacao=r.inicializarScrollVirtualizacao;exports.iniciarRedimensionamentoColuna=r.iniciarRedimensionamentoColuna;exports.interpretarIndice=r.interpretarIndice;exports.limitarLarguraColuna=r.limitarLarguraColuna;exports.localizarIndiceItem=r.localizarIndiceItem;exports.montarEstruturaDOM=r.montarEstruturaDOM;exports.normalizarTexto=r.normalizarTexto;exports.orquestrarEstruturaInicial=r.orquestrarEstruturaInicial;exports.proximaDensidade=r.proximaDensidade;exports.redimensionarColunaPorDelta=r.redimensionarColunaPorDelta;exports.registrarAtualizadorEditor=r.registrarAtualizadorEditor;exports.renderizarCategoriasETree=r.renderizarCategoriasETree;exports.renderizarCorpoTabela=r.renderizarCorpoTabela;exports.renderizarHeaderTabela=r.renderizarHeaderTabela;exports.renderizarSeletorTipos=r.renderizarSeletorTipos;exports.sincronizarAtributosTabela=r.sincronizarAtributosTabela;exports.sincronizarPainelControles=r.sincronizarPainelControles;exports.sincronizarSelect=r.sincronizarSelect;exports.tratarMudancaAtributoTabela=r.tratarMudancaAtributoTabela;exports.valoresIguais=r.valoresIguais;exports.UIBadge=a.UIBadge;exports.UIChip=a.UIChip;exports.UIKpi=a.UIKpi;exports.UIMetrica=a.UIMetrica;exports.UIStat=a.UIStat;exports.UITag=a.UITag;

package/dist/data.js

@@ -1,5 +1,5 @@
 /* empty css               */
-import { G as o, T as i, a as s, b as t, U as n, c as l, d, e as c, f as u, g as m, h as p, i as C, j as T, k as E, l as b, m as g, n as x, o as z, p as I, q as P, r as U, s as R, t as S, u as h, v as A, w as O, x as D, y as L, z as f, A as q, B as v, C as M, D as V, E as w, F as H, H as y, I as B, J as F, K as G, L as K, M as N, N as W, O as j, P as k, Q as J, R as Q, S as X, V as Y, W as Z, X as _, Y as $, Z as aa, _ as ra, $ as ea, a0 as oa, a1 as ia, a2 as sa, a3 as ta, a4 as na, a5 as la, a6 as da } from "./ui-tabela-propriedades-D9Echt2X.js";
+import { G as o, T as i, a as s, b as t, U as n, c as l, d, e as c, f as u, g as m, h as p, i as C, j as T, k as E, l as b, m as g, n as x, o as z, p as I, q as P, r as U, s as R, t as S, u as h, v as A, w as O, x as D, y as L, z as f, A as q, B as v, C as M, D as V, E as w, F as H, H as y, I as B, J as F, K as G, L as K, M as N, N as W, O as j, P as k, Q as J, R as Q, S as X, V as Y, W as Z, X as _, Y as $, Z as aa, _ as ra, $ as ea, a0 as oa, a1 as ia, a2 as sa, a3 as ta, a4 as na, a5 as la, a6 as da } from "./ui-tabela-propriedades-DoL4SE0r.js";
 import { U as ua, a as ma, b as pa, c as Ca, d as Ta, e as Ea } from "./ui-badge-BWhoGgo9.js";
 export {
   o as GerenciadorValoresPropriedades,

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

@@ -1,4 +1,5 @@
 import { default as L } from 'leaflet';
+import { nosDaGeometria } from './feature_curvas';
 import { GeometriaFeicao, NoCurva } from './feature_types';
 /** Linha cujo traçado é a curva `nos`. */
 export declare class LinhaCurva extends L.Polyline {
@@ -13,8 +14,7 @@ export declare class PoligonoCurvo extends L.Polygon {
     definirCurva(nos: NoCurva[] | null): void;
     protected _updatePath(): void;
 }
-/** A geometria deve ser desenhada como curva? Linha simples ou polígono de um anel, com `curva`. */
-export declare function nosDaGeometria(g: GeometriaFeicao): NoCurva[] | null;
+export { nosDaGeometria };
 /** Cria a camada Leaflet de uma linha/polígono com `curva`, ou `null` se a geometria não é curva. */
 export declare function criarCamadaCurva(g: GeometriaFeicao, opcoes: L.PolylineOptions): LinhaCurva | PoligonoCurvo | null;
 /** Atualiza uma camada criada por `criarCamadaCurva` (curva primeiro, depois os vértices, que redesenham). */

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

@@ -1,4 +1,4 @@
-import { LatLonPar, NoCurva } from './feature_types';
+import { GeometriaFeicao, LatLonPar, NoCurva } from './feature_types';
 export type { NoCurva };
 /** Subdivisões por segmento ao gerar os vértices de apoio (métricas, snap, seleção). */
 export declare const PASSOS_CURVA = 24;
@@ -41,3 +41,5 @@ export declare function caminhoSvg(nos: readonly NoCurva[], fechada: boolean, pr
 export declare function normalizarNos(bruto: unknown, minimo?: number): NoCurva[] | null;
 /** Cópia dos nós com todos os pontos deslocados (usado ao mover/copiar a feição). */
 export declare function moverNos(nos: readonly NoCurva[], mover: (p: LatLonPar) => LatLonPar): NoCurva[];
+/** A geometria deve ser desenhada como curva? Linha simples ou polígono de um anel, com `curva`. */
+export declare function nosDaGeometria(g: GeometriaFeicao): NoCurva[] | null;

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

@@ -0,0 +1,38 @@
+import { CaixaGeo } from './feature_indice';
+/** Abaixo desta diagonal (px) a feição é desenhada como marca. */
+export declare const LIMITE_MARCA_PX = 3;
+/** Opacidade da marca (preenchimentos de 0,2 sumiriam em 1–2 px). */
+export declare const OPACIDADE_MARCA = 0.75;
+export interface PontoMundo {
+    x: number;
+    y: number;
+}
+/** Web Mercator (EPSG:3857, tiles de 256 px) em pixels do mundo no zoom. Não lança: entradas inválidas dão NaN. */
+export declare function projetarMercator(lat: number, lon: number, zoom: number): PontoMundo;
+/** Diagonal da caixa em pixels no zoom; NaN se a caixa ou o zoom forem inválidos. */
+export declare function diagonalPx(c: CaixaGeo, zoom: number): number;
+/** Vira marca? Caixa ausente ou inválida nunca vira (a feição segue o caminho normal). */
+export declare function ehMarca(c: CaixaGeo | undefined, zoom: number, limite?: number): boolean;
+/** Lado da marca em px: 1 para diagonais minúsculas, 2 para as demais. */
+export declare function ladoMarca(diagonal: number): 1 | 2;
+export interface MarcaLOD {
+    id: string;
+    lat: number;
+    lon: number;
+    cor: string;
+    lado: 1 | 2;
+    /** Quem gerou a marca (identidade da feição): o renderizador só a refaz quando a feição troca. */
+    fonte: unknown;
+}
+/** Parte do Canvas 2D que a pintura usa (permite testar com um contexto falso). */
+export interface ContextoMarcas {
+    fillStyle: string | CanvasGradient | CanvasPattern;
+    globalAlpha: number;
+    fillRect(x: number, y: number, w: number, h: number): void;
+}
+export declare function agruparMarcasPorCor(marcas: Iterable<MarcaLOD>): Map<string, MarcaLOD[]>;
+/**
+ * Pinta as marcas em lote por cor (um `fillStyle` por grupo). `origemX/origemY` são os pixels do mundo, no zoom,
+ * do canto superior esquerdo do canvas. Devolve quantas marcas caíram dentro do canvas.
+ */
+export declare function pintarMarcas(ctx: ContextoMarcas, marcas: Iterable<MarcaLOD>, zoom: number, origemX: number, origemY: number, largura: number, altura: number): number;

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

@@ -1,4 +1,13 @@
 import { Feicao, GeometriaFeicao, LatLonPar } from './feature_types';
+/** Metros por grau de latitude e de longitude na latitude dada (escala local do elipsoide). */
+export declare function metrosPorGrau(latGraus: number): {
+    lat: number;
+    lng: number;
+};
+/**
+ * Distância em metros no elipsoide. Até ~11 km (0,1°) usa a escala local do elipsoide (M e N na
+ * latitude média, erro < 2e-7); acima disso, Vincenty. Rápida o bastante para laços de arraste/encaixe.
+ */
 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. */

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

@@ -1,14 +1,22 @@
 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. */
+/** A partir deste zoom a geometria é desenhada completa (a tolerância de 1,2 px já é menor que 1,5 m). */
+export declare const ZOOM_SEM_SIMPLIFICACAO = 17;
+/** Só se simplifica feição com MAIS de 8 vértices; abaixo disso o ganho não paga a alocação. */
+export declare const MIN_VERTICES_SIMPLIFICAR = 9;
+/** Tolerância em graus de LONGITUDE para o zoom (1 px = 360 / (256·2^z) graus); 0 = sem simplificar ou zoom inválido. */
 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[];
+/**
+ * Em Web Mercator 1 px de latitude vale cos(lat) grau de latitude por grau de longitude: sem este fator a tolerância
+ * vertical em graus ficaria 1/cos(lat) vezes maior que a pretendida (2× a 60°). Latitude inválida → 1.
+ */
+export declare function escalaLatitude(lat: number): number;
+/**
+ * Douglas-Peucker iterativo (sem recursão: linhas com centenas de milhares de vértices). `escalaLat` multiplica as
+ * diferenças de latitude antes de medir (ver `escalaLatitude`); 1 mede em graus puros.
+ */
+export declare function simplificarLinha(pts: LatLonPar[], tolerancia: number, escalaLat?: 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[];
+export declare function simplificarAnel(anel: LatLonPar[], tolerancia: number, escalaLat?: 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. */

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

@@ -10,6 +10,13 @@ export * from './renderers/vector_points_renderer';
 export * from './renderers/vector_polygons_renderer';
 export * from './renderers/grid_renderer';
 export * from './renderers/feicoes_renderer';
+export * from './renderers/feicoes_canvas_renderer';
+export * from './renderers/feicoes_despachante';
+export * from './renderers/renderizador_feicoes_tipos';
+export * from './renderers/renderizador_formas';
+export * from './renderers/canvas_formas_leaflet';
+export * from './feature_lod';
+export * from './motor';
 export * from './feature_metricas';
 export * from './layer_hit_test';
 export * from './feature_caixa';

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

@@ -15,7 +15,29 @@ export interface CandidatoHit {
     distancia: number;
     /** Área do envelope em px²; só usada para desempatar áreas. */
     area: number;
+    /** Só nas feições vindas de uma `FonteHit` (marcas de LOD, que não são objetos Leaflet): a feição e a chave dela. */
+    feicao?: unknown;
+    chave?: string;
 }
+/**
+ * Candidatos que não são objetos Leaflet (as marcas de LOD do renderizador de feições). A camada registra a fonte e o
+ * clique central as inclui no mesmo empilhamento (prioridade, camada do topo, menor área, alternância de cliques).
+ * O evento `click` é disparado em `alvo`, com a feição em `feicaoHit`.
+ */
+export interface FonteHit {
+    alvo: L.Layer;
+    /** Feições sob `ponto` (ponto de camada do mapa), da melhor para a pior. Não pode lançar. */
+    consultar(ponto: L.Point): Array<{
+        feicao: unknown;
+        chave: string;
+        tipo: TipoGeometriaPane;
+        distancia: number;
+        area: number;
+    }>;
+}
+export declare function registrarFonteHit(map: L.Map, camadaId: string, fonte: FonteHit): void;
+/** Remove a fonte da camada (só se ainda for `fonte`, para uma camada recriada não perder a nova). */
+export declare function removerFonteHit(map: L.Map, camadaId: string, fonte: FonteHit): void;
 /**
  * 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.

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

@@ -17,6 +17,11 @@ export declare class CanvasLayerManager {
     attachMap(map: L.Map, context: CanvasRenderContext): void;
     ensurePanes(): void;
     renderAllLayers(apenasDependentesDoContexto?: boolean): void;
+    /**
+     * Destrói e recria as instâncias das camadas visíveis de um tipo (ex.: troca do renderizador das camadas de
+     * feições). Os dados, a seleção e as definições ficam: só o desenho é refeito, as demais camadas não são tocadas.
+     */
+    recriarCamadasDoTipo(tipo: string): void;
     /** Executa agora o render agendado por updateContext/setGraphicScale, se houver. */
     flushRender(): void;
     private agendarRender;

package/dist/gerencigeo-canvas/motor/dados-camada.d.ts

@@ -0,0 +1,39 @@
+import { Feicao } from '../feature_types';
+import { IndiceEspacial } from '../feature_indice';
+import { DeltaMotor, RegraVisivel } from './tipos';
+export interface ResultadoMudanca {
+    mudadas: string[];
+    removidas: string[];
+    /** O conjunto de entidades com oficial mudou (com prévias na camada): a visibilidade de outras feições pode mudar. */
+    oficiaisMudou: boolean;
+}
+export declare class DadosCamada {
+    readonly loja: Map<string, Feicao>;
+    readonly indice: IndiceEspacial;
+    /** Muda a cada alteração dos dados (invalida cache de geometria por feição). */
+    revisao: number;
+    /** Muda quando o agrupamento e a contagem de pontos precisam ser refeitos do zero. */
+    revisaoBase: number;
+    listaSincronizada: Feicao[] | null;
+    /** Entidades com geometria oficial, e quantas oficiais cada uma tem. */
+    oficiais: Set<string>;
+    private contOficiais;
+    /** Entidade -> quantas prévias (entidade com oficial E prévia forma um par: sempre em detalhe completo). */
+    contPrevias: Map<string, number>;
+    nPrevias: number;
+    readonly selecionadas: Set<string>;
+    regra: RegraVisivel | null;
+    /** Revisão por feição (id → número crescente): chave do cache de geometria projetada. */
+    private revisaoDe;
+    private contador;
+    revisaoDaFeicao(id: string): number;
+    /** Aparece segundo a regra (não oculta e visível por versão)? */
+    desenhavel(f: Feicao): boolean;
+    /** Visível pela regra de versões (ignora `oculta`: o hit-test e a seleção seguem regras próprias). */
+    visivelPorVersao(f: Feicao): boolean;
+    /** Troca total: diferencia contra a loja, mantém o índice e a contabilidade de versões. */
+    sincronizar(lista: Feicao[]): ResultadoMudanca;
+    private recontarOficiais;
+    /** Aplica só a diferença. Devolve `null` se o delta não parte da lista sincronizada (então use `sincronizar`). */
+    aplicarDelta(lista: Feicao[], delta: DeltaMotor): ResultadoMudanca | null;
+}

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

@@ -0,0 +1,28 @@
+import { Feicao } from '../feature_types';
+import { LayerStyleDef } from '../types';
+export declare const COR_PADRAO = "#38bdf8";
+export declare const COR_SELECAO = "#38bdf8";
+/** Cores vão para atributos style/canvas; só passam formatos conhecidos (hex, rgb/hsl, nome). */
+export declare function corSegura(cor: string | undefined, padrao: string): string;
+export interface EstiloVetor {
+    /** Cor do traço (contorno). */
+    cor: string;
+    /** Desenha o traço? (`espessuraContorno: 0` em ponto o desliga). */
+    traco: boolean;
+    peso: number;
+    /** `dashArray` do Leaflet/SVG ("6 4"), ou `undefined` para linha contínua. */
+    dash: string | undefined;
+    preencher: boolean;
+    corPreenchimento: string;
+    opacidadePreenchimento: number;
+}
+/** Estilo de uma feição vetorial (polígono, círculo, linha ou ponto sem ícone). */
+export declare function estiloVetorDe(f: Feicao, camada: LayerStyleDef, selecionada?: boolean): EstiloVetor;
+/** Raio, em px, do círculo de um ponto sem ícone. */
+export declare function raioPontoPx(f: Feicao, camada: LayerStyleDef): number;
+/** Interna estilos iguais: o renderizador agrupa por identidade do objeto (um fill/stroke por estilo). */
+export declare class InternadorEstilos {
+    private porChave;
+    interno(e: EstiloVetor): EstiloVetor;
+    limpar(): void;
+}

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