@thibezer/ui-components-kit 2.0.0 → 2.1.0

package/dist/data.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const r=require("./ui-tabela-propriedades-D3pyQvyy.cjs"),a=require("./ui-badge-BxT-sDmV.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.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.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.localizarIndiceItem=r.localizarIndiceItem;exports.montarEstruturaDOM=r.montarEstruturaDOM;exports.orquestrarEstruturaInicial=r.orquestrarEstruturaInicial;exports.proximaDensidade=r.proximaDensidade;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.tratarMudancaAtributoTabela=r.tratarMudancaAtributoTabela;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-BBr5sqki.cjs"),a=require("./ui-badge-BxT-sDmV.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.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.localizarIndiceItem=r.localizarIndiceItem;exports.montarEstruturaDOM=r.montarEstruturaDOM;exports.orquestrarEstruturaInicial=r.orquestrarEstruturaInicial;exports.proximaDensidade=r.proximaDensidade;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,63 +1,68 @@
 /* empty css               */
-import { G as o, T as i, a as s, b as t, U as n, c as l, d as c, e as d, 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 I, p as z, q as P, r as U, s as R, t as S, u as h, v as A, w as O, x as f, y as q, z as D, A as M, B as V, C as v, D as w, E as H, F as L, 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 } from "./ui-tabela-propriedades-BNcE6VLX.js";
-import { U as ea, a as oa, b as ia, c as sa, d as ta, e as na } from "./ui-badge-C0eKBI8E.js";
+import { G as o, T as i, a as s, b as t, U as n, c as l, d as c, e as d, f as u, g as p, h as m, i as C, j as E, k as T, l as b, m as g, n as I, o as x, p as z, q as P, r as U, s as S, t as h, u as A, v as R, w as O, x as f, y as q, z as v, A as D, B as L, 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 } from "./ui-tabela-propriedades-Boy7I5yW.js";
+import { U as na, a as la, b as ca, c as da, d as ua, e as pa } from "./ui-badge-C0eKBI8E.js";
 export {
   o as GerenciadorValoresPropriedades,
   i as TabelaOrquestradorDados,
   s as TabelaRemotaController,
   t as TabelaSelecaoController,
-  ea as UIBadge,
-  oa as UIChip,
-  ia as UIKpi,
-  sa as UIMetrica,
-  ta as UIStat,
+  na as UIBadge,
+  la as UIChip,
+  ca as UIKpi,
+  da as UIMetrica,
+  ua as UIStat,
   n as UITabela,
   l as UITabelaPropriedades,
-  na as UITag,
+  pa as UITag,
   c as abrirPopoverRedimensionamento,
   d as alternarCategoria,
   u as alternarDirecaoOrdenacao,
-  m as alternarPosicionamentoFlutuante,
-  p as aplicarOrdenacaoTabela,
+  p as alternarPosicionamentoFlutuante,
+  m as aplicarOrdenacaoTabela,
   C as atualizarCampoVisual,
-  T as avaliarExpressaoMatematica,
-  E as colapsarTodasCategorias,
-  b as conectarArrastoFlutuante,
-  g as conectarPainelControles,
+  E as avaliarExpressaoMatematica,
+  T as buscarLinhaPropriedade,
+  b as colapsarTodasCategorias,
+  g as conectarArrastoFlutuante,
+  I as conectarPainelControles,
   x as criarControladorSplitter,
-  I as criarEditorAcao,
-  z as criarEditorBooleano,
-  P as criarEditorCorCad,
-  U as criarEditorCorSwatch,
-  R as criarEditorLinetype,
-  S as criarEditorLineweight,
-  h as criarEditorNumero,
-  A as criarEditorReadonly,
-  O as criarEditorSelecao,
-  f as criarEditorTexto,
-  q as criarEditorValor,
+  z as criarEditorAcao,
+  P as criarEditorBooleano,
+  U as criarEditorCorCad,
+  S as criarEditorCorSwatch,
+  h as criarEditorLinetype,
+  A as criarEditorLineweight,
+  R as criarEditorNumero,
+  O as criarEditorReadonly,
+  f as criarEditorSelecao,
+  q as criarEditorTexto,
+  v as criarEditorValor,
   D as criarLinhaPropriedade,
-  M as executarOrquestracaoCorpo,
-  V as executarOrquestracaoHeader,
-  v as executarRedimensionamentoColuna,
+  L as executarOrquestracaoCorpo,
+  M as executarOrquestracaoHeader,
+  V as executarRedimensionamentoColuna,
   w as exibirPromptPopoverRedimensionamento,
   H as expandirTodasCategorias,
-  L as focarProximoEditor,
-  y as formatWidth,
-  B as getAlignmentClass,
-  F as getRowHeight,
-  G as getTextAlign,
-  K as inicializarScrollVirtualizacao,
-  N as iniciarRedimensionamentoColuna,
-  W as localizarIndiceItem,
-  j as montarEstruturaDOM,
-  k as orquestrarEstruturaInicial,
-  J as proximaDensidade,
-  Q as renderizarCategoriasETree,
-  X as renderizarCorpoTabela,
-  Y as renderizarHeaderTabela,
-  Z as renderizarSeletorTipos,
-  _ as sincronizarAtributosTabela,
-  $ as sincronizarPainelControles,
-  aa as tratarMudancaAtributoTabela
+  y as focarProximoEditor,
+  B as formatWidth,
+  F as getAlignmentClass,
+  G as getRowHeight,
+  K as getTextAlign,
+  N as inicializarScrollVirtualizacao,
+  W as iniciarRedimensionamentoColuna,
+  j as interpretarIndice,
+  k as localizarIndiceItem,
+  J as montarEstruturaDOM,
+  Q as orquestrarEstruturaInicial,
+  X as proximaDensidade,
+  Y as registrarAtualizadorEditor,
+  Z as renderizarCategoriasETree,
+  _ as renderizarCorpoTabela,
+  $ as renderizarHeaderTabela,
+  aa as renderizarSeletorTipos,
+  ra as sincronizarAtributosTabela,
+  ea as sincronizarPainelControles,
+  oa as sincronizarSelect,
+  ia as tratarMudancaAtributoTabela,
+  sa as valoresIguais
 };

package/dist/forms.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const a=require("./ui-campo-texto-Cnn2UAkS.cjs"),e=require("./ui-switch-yZIn3IW0.cjs");exports.ATRIBUTOS_OBSERVADOS_CAMPO_TEXTO=a.ATRIBUTOS_OBSERVADOS_CAMPO_TEXTO;exports.UICampoTexto=a.UICampoTexto;exports.UIInput=a.UIInput;exports.criarTemplateCampoTexto=a.criarTemplateCampoTexto;exports.sincronizarFeedbackErro=a.sincronizarFeedbackErro;exports.sincronizarIconeSenha=a.sincronizarIconeSenha;exports.sincronizarLabelEPlaceholder=a.sincronizarLabelEPlaceholder;exports.ATRIBUTOS_OBSERVADOS_LISTA_FLUTUANTE=e.ATRIBUTOS_OBSERVADOS_LISTA_FLUTUANTE;exports.ListaFlutuantePosicionamento=e.ListaFlutuantePosicionamento;exports.ListaFlutuanteTeclado=e.ListaFlutuanteTeclado;exports.RadioGrupoRegistry=e.RadioGrupoRegistry;exports.UICheckbox=e.UICheckbox;exports.UIListaFlutuante=e.UIListaFlutuante;exports.UIRadio=e.UIRadio;exports.UISelect=e.UISelect;exports.UISwitch=e.UISwitch;exports.UIToggle=e.UIToggle;exports.atualizarEstadoSelecaoLista=e.atualizarEstadoSelecaoLista;exports.criarTemplateListaFlutuante=e.criarTemplateListaFlutuante;exports.renderizarItensLista=e.renderizarItensLista;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const a=require("./ui-campo-texto-Cnn2UAkS.cjs"),e=require("./ui-switch-D7iPKDj-.cjs");exports.ATRIBUTOS_OBSERVADOS_CAMPO_TEXTO=a.ATRIBUTOS_OBSERVADOS_CAMPO_TEXTO;exports.UICampoTexto=a.UICampoTexto;exports.UIInput=a.UIInput;exports.criarTemplateCampoTexto=a.criarTemplateCampoTexto;exports.sincronizarFeedbackErro=a.sincronizarFeedbackErro;exports.sincronizarIconeSenha=a.sincronizarIconeSenha;exports.sincronizarLabelEPlaceholder=a.sincronizarLabelEPlaceholder;exports.ATRIBUTOS_OBSERVADOS_LISTA_FLUTUANTE=e.ATRIBUTOS_OBSERVADOS_LISTA_FLUTUANTE;exports.ListaFlutuantePosicionamento=e.ListaFlutuantePosicionamento;exports.ListaFlutuanteTeclado=e.ListaFlutuanteTeclado;exports.RadioGrupoRegistry=e.RadioGrupoRegistry;exports.UICheckbox=e.UICheckbox;exports.UIListaFlutuante=e.UIListaFlutuante;exports.UIRadio=e.UIRadio;exports.UISelect=e.UISelect;exports.UISwitch=e.UISwitch;exports.UIToggle=e.UIToggle;exports.atualizarEstadoSelecaoLista=e.atualizarEstadoSelecaoLista;exports.criarTemplateListaFlutuante=e.criarTemplateListaFlutuante;exports.renderizarItensLista=e.renderizarItensLista;

package/dist/forms.js

@@ -1,6 +1,6 @@
 /* empty css               */
 import { A as t, U as o, a as r, c as i, s as n, b as c, d as T } from "./ui-campo-texto-Uu2dJE_0.js";
-import { A as I, L as U, a as u, R as S, U as L, b as d, c as p, d as A, e as m, f as O, g as R, h as E, r as F } from "./ui-switch-DWLgVVnT.js";
+import { A as I, L as U, a as u, R as S, U as L, b as d, c as p, d as A, e as m, f as O, g as R, h as E, r as F } from "./ui-switch-BcOqOkiV.js";
 export {
   t as ATRIBUTOS_OBSERVADOS_CAMPO_TEXTO,
   I as ATRIBUTOS_OBSERVADOS_LISTA_FLUTUANTE,

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

@@ -12,6 +12,19 @@ export interface CanvasInteracaoContext {
     containerHost?: HTMLElement | ShadowRoot;
     atualizarDestaqueLinhasTabela?: () => void;
     onSelectionChange?: (selectedIds: number[], selectedVizinhoIds: number[]) => void;
+    /** Chamado ao limpar a seleção (Esc, clique no vazio) para limpar também as feições genéricas. */
+    aoLimparSelecao?: () => void;
+    /** Há uma ferramenta de desenho ativa: cliques e arrastos do mouse são dela, não da seleção. */
+    ferramentaAtiva?: () => boolean;
+    /** Botão direito sobre o mapa (o menu nativo é sempre suprimido). */
+    aoMenuContexto?: (e: MouseEvent) => void;
+    /** Seleção por caixa sobre feições genéricas; `aditivo` = Ctrl/Cmd. */
+    selecionarFeicoesNaCaixa?: (caixa: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    }, modo: 'window' | 'crossing', aditivo: boolean) => void;
 }
 /**
  * Controlador de Interações do Canvas AutoCAD-like para o Leaflet
@@ -36,6 +49,7 @@ export declare class CanvasInteracao {
     private touchStartPos;
     private touchStartDist;
     private isTouchPanning;
+    private removerSupressao;
     selectionHappened: boolean;
     panHappened: boolean;
     constructor(ctx?: Partial<CanvasInteracaoContext>);
@@ -45,6 +59,10 @@ export declare class CanvasInteracao {
     private handleTouchMove;
     private handleTouchEnd;
     private handleContextMenu;
+    private handleClick;
+    /** Engole o `click` que o navegador dispara logo após soltar o botão de uma seleção por caixa. */
+    private suprimirProximoClique;
+    private cancelarSupressaoClique;
     private handleMouseDown;
     private handleMouseMove;
     private handleMouseUp;

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

@@ -0,0 +1,35 @@
+import { Ponto, Segmento, Confrontante } from './types';
+import { Feicao, LatLonPar } from './feature_types';
+/** Opções da normalização de entrada. */
+export interface OpcoesNormalizacao {
+    /**
+     * Aceita a coordenada (0, 0) exata. Por padrão ela é rejeitada, pois costuma ser um placeholder de erro
+     * ("Null Island"); ligue quando houver dados reais ali.
+     */
+    aceitarOrigem?: boolean;
+}
+/**
+ * Aceita [lat,lon], {lat,lng|lon}, {latitude,longitude}. Descarta NaN/Infinity.
+ * Rejeita (0, 0) exato, a menos que `opcoes.aceitarOrigem` (ver `normalizarFeicaoEntrada`).
+ */
+export declare function normalizarCoordenada(bruta: unknown, opcoes?: OpcoesNormalizacao): LatLonPar | null;
+/** Normaliza um anel; abre o anel fechado duplicado. Exige ≥3 vértices. */
+export declare function normalizarAnel(bruto: unknown[], opcoes?: OpcoesNormalizacao): LatLonPar[] | null;
+/** Normaliza uma linha; exige ≥2 vértices. */
+export declare function normalizarLinha(bruta: unknown[], opcoes?: OpcoesNormalizacao): LatLonPar[] | null;
+/** Aceita anel simples ou multianel. */
+export declare function normalizarPoligono(bruto: unknown[], opcoes?: OpcoesNormalizacao): LatLonPar[][] | null;
+export declare function pontoParaFeicao(p: Ponto, camadaId: string): Feicao | null;
+/** Segmentos referenciam pontos por id; segmentos com ponta ausente são descartados. */
+export declare function segmentoParaFeicao(s: Segmento, pontos: Map<string, Ponto>, camadaId: string): Feicao | null;
+/** Converte o POLYGON((x y, ...)) do vizinho (ordem WKT: lon lat). */
+export declare function confrontanteParaFeicao(c: Confrontante, camadaId: string): Feicao | null;
+/**
+ * Porta de entrada das feições vindas do consumidor: aceita coordenadas em qualquer formato
+ * suportado por `normalizarCoordenada` e devolve a `Feicao` normalizada, ou `null` se inválida.
+ *
+ * Por padrão rejeita a coordenada (0, 0) exata (placeholder de erro, "Null Island"): uma feição com um
+ * vértice ali é descartada. Quem tem dados reais nesse ponto liga `opcoes.aceitarOrigem` (no componente,
+ * o atributo `aceitar-origem`).
+ */
+export declare function normalizarFeicaoEntrada(bruta: unknown, camadaId: string, opcoes?: OpcoesNormalizacao): Feicao | null;

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

@@ -0,0 +1,45 @@
+import { Feicao, GeometriaFeicao, LatLonPar } from './feature_types';
+/** Ponto dentro do anel externo e fora dos furos. */
+export declare function pontoNoPoligono(p: LatLonPar, aneis: LatLonPar[][]): boolean;
+/**
+ * Divide um polígono simples (um anel, sem furos) por uma linha de corte.
+ * A linha pode atravessar o polígono várias vezes; cada travessia (entrada → saída) vira um corte.
+ * Devolve os anéis resultantes (≥ 2), ou `null` se a linha não corta o polígono.
+ * Limitações: não trata furos; cruzamentos exatamente sobre um vértice podem ser ignorados;
+ * linhas que se cruzam entre si dentro do polígono dão resultado indefinido.
+ */
+export declare function dividirPoligonoComLinha(anel: LatLonPar[], linha: LatLonPar[]): LatLonPar[][] | null;
+/**
+ * Encadeia linhas cujas pontas estejam a no máximo `toleranciaM` uma da outra, invertendo as que
+ * precisarem. Lacunas dentro da tolerância viram uma "ponte" (segmento reto). Devolve `null` se
+ * alguma linha não se liga à cadeia.
+ */
+export declare function juntarLinhas(linhas: LatLonPar[][], toleranciaM?: number): LatLonPar[] | null;
+/**
+ * Junta dois polígonos simples por uma "ponte": o anel é aberto nos vértices mais próximos de cada
+ * um e os dois são costurados num anel só (a ponte tem largura zero). Serve para polígonos separados
+ * por até `toleranciaM` ou que dividem uma divisa. Recusa polígonos cujas bordas se cruzam
+ * (`null`): união booleana de áreas sobrepostas não é suportada.
+ */
+export declare function juntarPoligonos(a: LatLonPar[], b: LatLonPar[], toleranciaM?: number): LatLonPar[] | null;
+/**
+ * Buffer de uma feição como polígono. Ponto/círculo: círculo de 64 lados. Linha: contorno com pontas
+ * arredondadas. Polígono: offset do anel externo (distância negativa encolhe). Aproximação por
+ * meia-esquadria: boa para distâncias pequenas frente ao tamanho da feição; pode se auto-intersectar
+ * em polígonos côncavos com distâncias grandes.
+ */
+export declare function gerarBuffer(g: GeometriaFeicao, distanciaM: number): LatLonPar[] | null;
+/** Copia a geometria deslocada `leste` m para leste e `norte` m para norte. */
+export declare function deslocarGeometria(g: GeometriaFeicao, lesteM: number, norteM: number): GeometriaFeicao;
+export type UnidadeComprimento = 'm' | 'km' | 'ft' | 'mi';
+export type UnidadeArea = 'm2' | 'ha' | 'km2' | 'ac' | 'alqueire';
+export declare function converterComprimento(valor: number, de: UnidadeComprimento, para: UnidadeComprimento): number;
+export declare function converterArea(valor: number, de: UnidadeArea, para: UnidadeArea): number;
+/** `-23.5` -> `23°30'00.00"S`. `eixo` escolhe N/S ou L/O (leste/oeste). */
+export declare function ddParaDms(valor: number, eixo: 'lat' | 'lon', casas?: number): string;
+/** Aceita `23°30'00.00"S`, `23 30 0 S`, `-23°30'`, vírgula decimal. Devolve `null` se não entender. */
+export declare function dmsParaDd(texto: string): number | null;
+/** Distância em metros de um ponto até o vértice/segmento mais próximo; útil para testes e ferramentas. */
+export declare function distanciaEntre(a: LatLonPar, b: LatLonPar): number;
+/** Cópia profunda de uma feição com novo id (para duplicar/dividir). */
+export declare function clonarFeicao(f: Feicao, novoId: string, geometria?: GeometriaFeicao): Feicao;

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

@@ -0,0 +1,4 @@
+import { Feicao } from './feature_types';
+import { PontoPx, Projetor } from './feature_caixa';
+export declare const TOLERANCIA_AMOSTRA_PX = 6;
+export declare function feicaoNoPonto(cursor: PontoPx, candidatas: Feicao[], projetar: Projetor, tolerancia?: number): Feicao | null;

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

@@ -0,0 +1,19 @@
+import { Feicao, LatLonPar } from './feature_types';
+export interface CaixaPx {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+export interface PontoPx {
+    x: number;
+    y: number;
+}
+export type Projetor = (p: LatLonPar) => PontoPx;
+export type ModoCaixa = 'window' | 'crossing';
+export declare function feicaoNaCaixa(f: Feicao, caixa: CaixaPx, projetar: Projetor, modo: ModoCaixa): boolean;
+/**
+ * Seleção por laço (polígono em coordenadas geográficas). Ponto, texto e círculo entram se o ponto de
+ * referência está dentro; linha, se algum vértice está; polígono, se algum vértice ou o centróide está.
+ */
+export declare function feicaoNoLaco(f: Feicao, laco: LatLonPar[]): boolean;

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

@@ -0,0 +1,61 @@
+import { LatLonPar } from './feature_types';
+/** Lado da célula da grade, em px. */
+export declare const CELULA_CLUSTER_PX = 55;
+/** A partir deste zoom os pontos se desmembram. */
+export declare const ZOOM_DESMEMBRAR = 17;
+/** Com no máximo isto de pontos na camada, nunca agrupa. */
+export declare const MAX_PONTOS_SEM_CLUSTER = 8;
+export interface PontoCluster {
+    id: string;
+    coordenada: LatLonPar;
+}
+export interface Cluster {
+    chave: string;
+    coordenada: LatLonPar;
+    membros: PontoCluster[];
+}
+export interface ResultadoCluster {
+    clusters: Cluster[];
+    /** Pontos que ficaram sozinhos na célula (desenhados individualmente). */
+    isolados: PontoCluster[];
+}
+/** `projetar` leva [lat, lon] a pixels de mundo no zoom em questão. */
+export type ProjetorMundo = (p: LatLonPar) => {
+    x: number;
+    y: number;
+};
+export declare function deveAgrupar(totalPontos: number, zoom: number): boolean;
+export declare function centroDe(membros: PontoCluster[]): LatLonPar;
+export declare function agruparPontos(pontos: PontoCluster[], zoom: number, projetar: ProjetorMundo): ResultadoCluster;
+/** Uma célula da grade: seus membros e a soma das coordenadas (centro em O(1)). */
+export interface CelulaCluster {
+    membros: Map<string, PontoCluster>;
+    somaLat: number;
+    somaLon: number;
+}
+/**
+ * Mesma grade de `agruparPontos`, porém mantida em memória: entrar, sair ou mover um ponto custa O(1)
+ * e a célula afetada é reavaliada sozinha, sem reagrupar a camada inteira. Vale para um único zoom.
+ */
+export declare class AgrupadorCluster {
+    readonly zoom: number;
+    private projetar;
+    private celulas;
+    private celulaDe;
+    /** Chaves das células com 2 ou mais pontos (as únicas que viram cluster). */
+    private multiplas;
+    constructor(zoom: number, projetar: ProjetorMundo);
+    /** Pontos agrupáveis na grade. */
+    get total(): number;
+    /** Chave da célula do ponto, ou `undefined` se ele não está na grade. */
+    chaveDoPonto(id: string): string | undefined;
+    celula(chave: string): CelulaCluster | undefined;
+    /** Só as células que viram cluster (2+ pontos). */
+    celulasAgrupadas(): IterableIterator<[string, CelulaCluster]>;
+    /** Está numa célula com 2 ou mais pontos (ou seja, dentro de um cluster)? */
+    emCluster(id: string): boolean;
+    /** Insere (ou move) o ponto; devolve a chave da célula nova. */
+    inserir(p: PontoCluster): string;
+    /** Tira o ponto da grade; devolve a chave da célula de onde saiu. */
+    remover(id: string): string | undefined;
+}

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

@@ -0,0 +1,17 @@
+import { default as L } from 'leaflet';
+import { LatLonPar } from './feature_types';
+export interface UsuarioRemoto {
+    id: string;
+    nome?: string;
+    cor?: string;
+}
+export declare function corHexSegura(cor: unknown): string;
+export declare class CursoresRemotos {
+    private obterMapa;
+    private marcadores;
+    constructor(obterMapa: () => L.Map | null);
+    get quantidade(): number;
+    atualizar(usuario: UsuarioRemoto, coord: LatLonPar): boolean;
+    remover(id: string): boolean;
+    limpar(): void;
+}

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

@@ -0,0 +1,53 @@
+import { GeometriaFeicao, LatLonPar } from './feature_types';
+export declare const FERRAMENTAS: readonly ["ponto", "linha", "poligono", "retangulo", "elipse", "poligono-regular", "estrela", "circulo", "texto", "caneta", "medir-distancia", "medir-area", "dividir", "selecao-laco", "conta-gotas"];
+export type Ferramenta = (typeof FERRAMENTAS)[number];
+/** Raio mínimo (m) da ferramenta círculo; abaixo disso o clique é ignorado (como no motor antigo). */
+export declare const RAIO_MINIMO_CIRCULO_M = 2;
+export declare function ehFerramenta(v: unknown): v is Ferramenta;
+/** Resultado de um clique: se a ferramenta fecha sozinha (ponto, retângulo, círculo...), vem a geometria. */
+export interface ResultadoClique {
+    concluida?: GeometriaFeicao;
+}
+/** Âncora da caneta Bézier; a alça de saída é uma coordenada absoluta (a de entrada é o espelho). */
+export interface AncoraBezier {
+    ponto: LatLonPar;
+    alca?: LatLonPar;
+}
+/** Amostra a curva cúbica que passa pelas âncoras (sem alça = reta). */
+export declare function amostrarBezier(ancoras: AncoraBezier[]): LatLonPar[];
+export declare class SessaoDesenho {
+    readonly ferramenta: Ferramenta;
+    private fechar;
+    readonly pontos: LatLonPar[];
+    cursor: LatLonPar | null;
+    readonly ancoras: AncoraBezier[];
+    constructor(ferramenta: Ferramenta, fechar?: boolean);
+    /** Quantos vértices/âncoras já foram colocados. */
+    get nos(): number;
+    /** A ferramenta aceita vários cliques e termina com Enter/duplo clique? */
+    get ehSequencial(): boolean;
+    private get ehArea();
+    /** Um clique perto do primeiro vértice fecha a figura? (polígono, laço, medir área e caneta com 3+ vértices) */
+    get fechaNoPrimeiro(): boolean;
+    /** Posição do primeiro vértice/âncora (alvo do fechamento), se houver. */
+    get primeiro(): LatLonPar | null;
+    get minimo(): number;
+    get podeConcluir(): boolean;
+    mover(c: LatLonPar): void;
+    clicar(c: LatLonPar): ResultadoClique;
+    /** Caneta: arrastar logo após colocar a âncora define a alça de saída (a de entrada é o espelho). */
+    definirAlca(c: LatLonPar): void;
+    /** Desfaz o último vértice/âncora (Backspace). Devolve se algo foi desfeito. */
+    desfazer(): boolean;
+    /** Vértices da linha/anel em construção, incluindo a curva da caneta. */
+    private vertices;
+    private retangulo;
+    /** Geometria provisória para desenhar enquanto o mouse se move (inclui o cursor). */
+    previa(): GeometriaFeicao | null;
+    /** Fecha uma ferramenta sequencial (Enter ou duplo clique). `null` se ainda não há vértices suficientes. */
+    concluir(): GeometriaFeicao | null;
+    /** Fecha em polígono (clique no primeiro vértice). Na caneta vale mesmo sem a opção `fechar`. */
+    concluirFechando(): GeometriaFeicao | null;
+    /** Medida em andamento: comprimento (linha) ou comprimento do contorno (área), em metros. */
+    comprimentoMetros(): number;
+}

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

@@ -0,0 +1,91 @@
+import { default as L } from 'leaflet';
+import { GeometriaFeicao, LatLonPar } from './feature_types';
+import { Ferramenta } from './feature_desenho';
+import { ResultadoSnap } from './feature_snap';
+export declare const ID_HUD_DESENHO = "cm-draw-hud";
+export declare const CLASSE_FERRAMENTA_ATIVA = "cad-ferramenta-ativa";
+export interface InfoMedicao {
+    tipo: 'distancia' | 'area';
+    pontos: LatLonPar[];
+    comprimentoM: number;
+    areaM2?: number;
+    perimetroM?: number;
+}
+export interface DependenciasDesenho {
+    map: L.Map;
+    buscarSnap: (coord: LatLonPar) => ResultadoSnap | null;
+    snapAtivo: () => boolean;
+    /** Geometria pronta de uma ferramenta de criação/divisão (`texto` vem do campo de entrada). */
+    aoGeometria: (ferramenta: Ferramenta, geometria: GeometriaFeicao) => void;
+    aoMedir: (info: InfoMedicao) => void;
+    /** Clique do conta-gotas, na coordenada (já com snap, se ligado). */
+    aoAmostrar: (coord: LatLonPar, evento: MouseEvent | undefined) => void;
+    /** Ferramenta desativada (Esc sem nada em andamento, troca de ferramenta ou `desativar`). */
+    aoDesativar: (ferramenta: Ferramenta) => void;
+    /**
+     * Clique da ferramenta texto, antes do campo inline. Devolver `true` significa que o consumidor assumiu a entrada
+     * do texto (ex.: abriu um modal) e o campo inline não deve aparecer.
+     */
+    aoSolicitarTexto?: (coord: LatLonPar) => boolean;
+}
+export declare class ControleDesenho {
+    private dep;
+    private sessao;
+    private fechar;
+    private grupo;
+    private previa;
+    private marcas;
+    private medicao;
+    private marcadorSnap;
+    private hud;
+    private campoTexto;
+    private arrastando;
+    private ultimoClique;
+    constructor(dep: DependenciasDesenho);
+    get ferramenta(): Ferramenta | null;
+    get ativo(): boolean;
+    /** Vértices/âncoras já colocados na figura em andamento. */
+    get nos(): number;
+    /** Desfaz o último vértice (mesmo que Backspace/Ctrl+Z). */
+    desfazerVertice(): boolean;
+    /** Liga uma ferramenta (troca a anterior). `fechar` faz a caneta gerar polígono em vez de linha. */
+    ativar(ferramenta: Ferramenta, opcoes?: {
+        fechar?: boolean;
+    }): void;
+    /** Desliga a ferramenta ativa (idempotente). A medição pronta continua na tela. */
+    desativar(): void;
+    limparMedicao(): void;
+    private desligar;
+    private coordenada;
+    private repetido;
+    private aoClicar;
+    /** Com 3+ vértices, um clique perto do primeiro fecha a figura em polígono. */
+    private fechaNoPrimeiroVertice;
+    private aoPressionar;
+    private aoSoltar;
+    private aoMover;
+    private aoDuploClique;
+    private aoTecla;
+    /** Fecha a ferramenta sequencial em andamento (Enter, duplo clique ou botão Concluir). */
+    concluir(): void;
+    /**
+     * Botão direito com a ferramenta ativa: conclui se já dá figura; senão desfaz o último vértice;
+     * sem nada em andamento, desliga a ferramenta (mesmo roteiro do antigo MapEngine).
+     */
+    botaoDireito(): void;
+    private reiniciar;
+    private finalizar;
+    private pedirTexto;
+    private cancelarTexto;
+    private atualizar;
+    private desenharGeometria;
+    /** Desenha a medição pronta e devolve o resumo; quem chama avisa o consumidor (depois de a sessão estar estável). */
+    private mostrarMedicao;
+    private mostrarSnap;
+    private esconderSnap;
+    private montarHud;
+    private atualizarHud;
+    /** Para os testes: simula um clique na coordenada, sem passar pelo mapa. */
+    clicarEm(coord: LatLonPar): void;
+    moverPara(coord: LatLonPar): void;
+}

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

@@ -0,0 +1,19 @@
+import { Feicao, GeometriaFeicao, LatLonPar } from './feature_types';
+export type MotivoRecusaEdicao = 'bloqueada' | 'tipo-nao-suportado' | 'poligono-com-furos' | 'multiparte' | 'muitos-vertices';
+/** Acima disto cada vértice seria uma alça no DOM: recusa em vez de travar a página. */
+export declare const MAX_VERTICES_EDICAO = 5000;
+/** Linha precisa de 2 vértices; polígono, de 3. */
+export declare function minimoVertices(g: GeometriaFeicao): number;
+/** `null` quando pode editar; senão, o motivo da recusa. Polígono com furos/multipartes vai para a tabela de vértices. */
+export declare function verificarEditavel(f: Feicao, camadaBloqueada?: boolean): MotivoRecusaEdicao | null;
+export declare function verticesDe(g: GeometriaFeicao): LatLonPar[];
+/** Nova geometria do mesmo tipo com estes vértices (não altera a original). */
+export declare function comVertices(g: GeometriaFeicao, pts: LatLonPar[]): GeometriaFeicao;
+export declare function moverVertice(g: GeometriaFeicao, indice: number, coord: LatLonPar): GeometriaFeicao;
+/** Insere `coord` logo depois do vértice `depoisDe` (no polígono, `depoisDe` = último vale entre o último e o primeiro). */
+export declare function inserirVertice(g: GeometriaFeicao, depoisDe: number, coord: LatLonPar): GeometriaFeicao;
+/** `null` quando o vértice não pode sair (mínimo de 3 no polígono, 2 na linha, ponto não perde o único). */
+export declare function removerVertice(g: GeometriaFeicao, indice: number): GeometriaFeicao | null;
+export declare function pontoMedio(a: LatLonPar, b: LatLonPar): LatLonPar;
+/** Pares de índices dos segmentos (o polígono inclui o que fecha o último no primeiro). */
+export declare function segmentosDe(g: GeometriaFeicao): Array<[number, number]>;

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

@@ -0,0 +1,62 @@
+import { default as L } from 'leaflet';
+import { Feicao, LatLonPar } from './feature_types';
+import { ResultadoSnap } from './feature_snap';
+export declare const ID_HUD_EDICAO = "cm-vertex-edit-hud";
+export interface DependenciasEditor {
+    map: L.Map;
+    /** Snap para a posição do cursor, ignorando o vértice em arrasto. Já considera se o snap está ligado. */
+    buscarSnap: (coord: LatLonPar, excluir: {
+        feicaoId: string;
+        camadaId: string;
+        vertice?: number;
+    }) => ResultadoSnap | null;
+    snapLigado: () => boolean;
+    alternarSnap: () => void;
+    /** Mostra a geometria nova no mapa sem gravar (durante o arrasto). */
+    previsualizar: (f: Feicao) => void;
+    /** Fim de cada gesto (soltar alça, inserir, excluir): grava a feição. */
+    aoGesto: (f: Feicao) => void;
+    /** A edição terminou (Concluir, Esc, ou chamada de `parar`). */
+    aoEncerrar: (f: Feicao) => void;
+}
+export declare class EditorVertices {
+    private dep;
+    private feicaoAtual;
+    private pts;
+    private alcas;
+    private fantasmas;
+    private marcadorSnap;
+    private hud;
+    private grupo;
+    constructor(dep: DependenciasEditor);
+    get ativo(): boolean;
+    get feicao(): Feicao | null;
+    iniciar(f: Feicao): void;
+    /** Encerra a edição (idempotente). */
+    parar(): void;
+    /** A feição foi alterada por fora (API): refaz as alças com a geometria nova. */
+    sincronizar(f: Feicao): void;
+    /** Atualiza o texto "Snap" do HUD quando o snap é ligado/desligado. */
+    atualizarSnapNoHud(): void;
+    private geometriaAtual;
+    private feicaoComPontos;
+    private reconstruir;
+    private icone;
+    private criarAlca;
+    private criarFantasma;
+    private aoArrastar;
+    private inserir;
+    private confirmar;
+    private excluir;
+    /** Atalho para testes/API: mesma operação do botão direito. */
+    excluirVertice(indice: number): boolean;
+    inserirVerticeApos(indice: number): void;
+    private mostrarSnap;
+    private esconderSnap;
+    private montarHud;
+    private atualizarHud;
+    /** Para os testes: posição atual dos vértices. */
+    vertices(): LatLonPar[];
+    /** Para os testes: move um vértice como se a alça tivesse sido arrastada até `coord`. */
+    arrastarPara(indice: number, coord: LatLonPar): void;
+}

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

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

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

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