@thibezer/ui-components-kit 1.0.0

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

@@ -0,0 +1,56 @@
+import { Ponto } from './types';
+import { CanvasLayerManager } from './layer_manager';
+import { CAD_INTERACTIVE_PANES } from './canvas_selecao_box';
+export { CAD_INTERACTIVE_PANES };
+export interface CanvasInteracaoContext {
+    mapaController?: any;
+    layerManager?: CanvasLayerManager;
+    selectedPontoIds: number[];
+    selectedVizinhoPontoIds: number[];
+    lastSelectedPontoId: number | null;
+    pontosList?: Ponto[];
+    containerHost?: HTMLElement | ShadowRoot;
+    atualizarDestaqueLinhasTabela?: () => void;
+    onSelectionChange?: (selectedIds: number[], selectedVizinhoIds: number[]) => void;
+}
+/**
+ * Controlador de Interações do Canvas AutoCAD-like para o Leaflet
+ *
+ * Funcionalidades CAD:
+ *  - Pan Dinâmico: Botão do Meio (Scroll Wheel Drag) com cursor grabbing
+ *  - Zoom Extents: Duplo clique na rodinha do mouse (<300ms)
+ *  - Janelas de Seleção:
+ *      * Window Selection (Esquerda -> Direita, Azul #06b6d4): seleciona 100% contidos
+ *      * Crossing Selection (Direita -> Esquerda, Verde #10b981): seleciona interceptados
+ *  - Snapping e Seleção Filtrada: Apenas camadas ativas, visíveis e desbloqueadas
+ *  - Teclado: Tecla ESC limpa a seleção; tecla Ctrl/Cmd ativa seleção aditiva múltipla
+ */
+export declare class CanvasInteracao {
+    ctx: CanvasInteracaoContext;
+    private map;
+    private mapContainer;
+    private selecaoBox;
+    private isPanning;
+    private lastMousePos;
+    private lastMiddleClickTime;
+    private touchStartPos;
+    private touchStartDist;
+    private isTouchPanning;
+    selectionHappened: boolean;
+    panHappened: boolean;
+    constructor(ctx?: Partial<CanvasInteracaoContext>);
+    ativar(mapaController: any, containerHost?: HTMLElement | ShadowRoot): void;
+    desativar(): void;
+    private handleTouchStart;
+    private handleTouchMove;
+    private handleTouchEnd;
+    private handleContextMenu;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleKeyDown;
+    limparSelecao(): void;
+    private notificarSelecao;
+    zoomExtents(): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,23 @@
+import { default as L } from 'leaflet';
+import { CanvasInteracaoContext } from './canvas_interacao';
+export declare const CAD_INTERACTIVE_PANES: string[];
+export declare class CanvasSelecaoBox {
+    private map;
+    private mapContainer;
+    private ctx;
+    private selectionDiv;
+    isSelecting: boolean;
+    selectStartPos: {
+        x: number;
+        y: number;
+    };
+    selectStartPoint: L.Point | null;
+    constructor(map: L.Map, mapContainer: HTMLElement, ctx: CanvasInteracaoContext);
+    private criarDivSelecao;
+    setPanesPointerEvents(value: 'auto' | 'none'): void;
+    iniciarSelecao(e: MouseEvent): void;
+    atualizarSelecao(e: MouseEvent): void;
+    finalizarSelecao(e: MouseEvent, onNotificar: () => void, onLimpar: () => void): boolean;
+    cancelarSelecao(): void;
+    destruir(): void;
+}

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

@@ -0,0 +1,15 @@
+import { default as L } from 'leaflet';
+import { Ponto, Confrontante } from './types';
+export declare function processarPontosVizinhos(pontos: Ponto[], confrontantesAtuais: Confrontante[]): Confrontante[];
+export declare function processarPoligonosVizinhos(confrontantes: Confrontante[], confrontantesAtuais: Confrontante[]): Confrontante[];
+export declare function calcularBoundsGeometrias(pontos: Ponto[], confrontantes?: Confrontante[], incluirVizinhos?: boolean): {
+    single?: L.LatLng;
+    bounds?: L.LatLngBounds;
+} | null;
+export declare function coletarMarcadoresLeaflet(map: L.Map | null, layerManager: any): L.Marker[];
+export declare function executarPlotarPontos(controller: any, pontos?: any[] | null, camadaId?: string, onClique?: (ponto: any) => void): void;
+export declare function executarPlotarConexoes(controller: any, conexoes?: any[] | null, camadaId?: string): void;
+export declare function executarPlotarPolilinha(controller: any, pontos?: any[] | null, fechar?: boolean, camadaId?: string, chaveGrupo?: string): void;
+export declare function executarPlotarPoligonos(controller: any, poligonos?: any[] | null, camadaId?: string): void;
+export declare function executarPlotSegmentos(controller: any, segmentos?: any[] | null, pontos?: any[] | null): void;
+export declare function executarClearOverlays(controller: any, manterBanco?: boolean): void;

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

@@ -0,0 +1,17 @@
+export * from './types';
+export * from './utils';
+export * from './mapa_config';
+export * from './mapa_pontos_shapes';
+export * from './layer_renderer_factory';
+export * from './renderers/tile_renderer';
+export * from './renderers/wms_renderer';
+export * from './renderers/vector_lines_renderer';
+export * from './renderers/vector_points_renderer';
+export * from './renderers/vector_polygons_renderer';
+export * from './renderers/grid_renderer';
+export * from './layer_manager';
+export * from './mapa_core';
+export * from './mapa_linhas';
+export * from './mapa_marcadores';
+export * from './canvas_interacao';
+export * from './mapa_controller';

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

@@ -0,0 +1,3 @@
+import { CanvasLayerDef } from './types';
+export declare function registrarRenderizadoresPadrao(): void;
+export declare const DEFAULT_LAYERS: CanvasLayerDef[];

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

@@ -0,0 +1,6 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerDef, CanvasRenderContext } from './types';
+export type MapaInstancias = Map<string, L.Layer | L.LayerGroup>;
+export declare function montarInstancia(layer: CanvasLayerDef, map: L.Map, context: CanvasRenderContext, instances: MapaInstancias): void;
+export declare function destruirInstancia(layer: CanvasLayerDef, map: L.Map, instances: MapaInstancias): void;
+export declare function atualizarInstancia(layer: CanvasLayerDef, patch: Partial<CanvasLayerDef>, map: L.Map, context: CanvasRenderContext, instances: MapaInstancias): void;

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

@@ -0,0 +1,37 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerDef, CanvasLayerState, CanvasRenderContext, CanvasGraphicScale } from './types';
+import { DEFAULT_LAYERS } from './layer_defaults';
+export { DEFAULT_LAYERS };
+export declare class CanvasLayerManager {
+    private layers;
+    private layerInstances;
+    private map;
+    private context;
+    private listeners;
+    constructor(initialLayers?: CanvasLayerDef[]);
+    attachMap(map: L.Map, context: CanvasRenderContext): void;
+    ensurePanes(): void;
+    renderAllLayers(): void;
+    setLayerVisibility(id: string, visivel: boolean): void;
+    setLayerOpacity(id: string, opacidade: number): void;
+    setLayerZIndex(id: string, zIndex: number): void;
+    setLayerBlocked(id: string, bloqueada: boolean): void;
+    setLayerScaleMode(id: string, mode: 'screen' | 'world'): void;
+    setGraphicScale(scale: Partial<CanvasGraphicScale>): void;
+    updateContext(newContext: Partial<CanvasRenderContext>): void;
+    getLayers(): CanvasLayerDef[];
+    getActiveSelectableLayers(): CanvasLayerDef[];
+    isLayerActiveAndSelectable(layerId: string): boolean;
+    exportState(): CanvasLayerState[];
+    importState(state: CanvasLayerState[]): void;
+    onChange(callback: (layers: CanvasLayerDef[]) => void): () => void;
+    private notifyChange;
+    getAllLayerInstances(): (L.Layer | L.LayerGroup)[];
+    getLayerInstance(id: string): L.Layer | L.LayerGroup | undefined;
+    getLayer(id: string): CanvasLayerDef | undefined;
+    getLayerDef(id: string): CanvasLayerDef | undefined;
+    getOrCreateLayer(id: string, tipo: string, nome: string): CanvasLayerDef;
+    setLayerData(id: string, dados: any): void;
+    clearLayers(ids?: string[]): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,8 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerDef } from './types';
+export declare function nomePane(layerId: string): string;
+export declare function garantirPanes(map: L.Map, layers: CanvasLayerDef[]): void;
+export declare function aplicarVisibilidadePane(map: L.Map, layer: CanvasLayerDef): void;
+export declare function aplicarOpacidadePane(map: L.Map, layer: CanvasLayerDef): void;
+export declare function aplicarZIndexPane(map: L.Map, layer: CanvasLayerDef): void;
+export declare function aplicarBloqueioPane(map: L.Map, layer: CanvasLayerDef): void;

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

@@ -0,0 +1,14 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerDef, CanvasRenderContext } from './types';
+export interface ILayerRenderer {
+    render(layerDef: CanvasLayerDef, map: L.Map, context: CanvasRenderContext): L.Layer | L.LayerGroup | null;
+    update(layerDef: CanvasLayerDef, layerInstance: L.Layer | L.LayerGroup, changes: Partial<CanvasLayerDef>, context: CanvasRenderContext, map: L.Map): void;
+    destroy(layerInstance: L.Layer | L.LayerGroup, map: L.Map): void;
+}
+export declare class LayerRendererFactory {
+    private static renderers;
+    static register(tipo: string, renderer: ILayerRenderer): void;
+    static get(tipo: string): ILayerRenderer | undefined;
+    static has(tipo: string): boolean;
+    static getRegisteredTypes(): string[];
+}

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

@@ -0,0 +1,6 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerDef, CanvasLayerState, CanvasRenderContext } from './types';
+export declare function exportarEstadoCamadas(layers: CanvasLayerDef[]): CanvasLayerState[];
+export declare function importarEstadoCamadas(layers: CanvasLayerDef[], state: CanvasLayerState[]): void;
+export declare function limparDadosCamadas(layers: CanvasLayerDef[], layerInstances: Map<string, L.Layer | L.LayerGroup>, context: CanvasRenderContext | null, idsCamadas?: string[]): void;
+export declare function aplicarDadosCamada(layer: CanvasLayerDef, dados: any, map: L.Map | null, context: CanvasRenderContext | null, layerInstances: Map<string, L.Layer | L.LayerGroup>): void;

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

@@ -0,0 +1,11 @@
+import { MapaConfiguracoes } from './types';
+export declare const DEFAULT_CONFIG: MapaConfiguracoes;
+export declare class MapaConfigManager {
+    private static instance;
+    private config;
+    private constructor();
+    static getInstance(): MapaConfigManager;
+    private loadConfig;
+    saveConfig(newConfig: Partial<MapaConfiguracoes>): void;
+    getConfig(): MapaConfiguracoes;
+}

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

@@ -0,0 +1,53 @@
+import { default as L } from 'leaflet';
+import { Ponto, Segmento, BancoPonto, Confrontante, CanvasRenderContext, CanvasGraphicScale, CanvasLayerState, CanvasLayerDef, PontoCAD, ConexaoCAD, PoligonoCAD, DestacarElementoOpcoes } from './types';
+import { MapaCore } from './mapa_core';
+import { CanvasInteracao } from './canvas_interacao';
+import { CanvasLayerManager } from './layer_manager';
+export declare class GerenciGeoMapaController {
+    core: MapaCore;
+    layerManager: CanvasLayerManager;
+    canvasInteracao: CanvasInteracao;
+    context: CanvasRenderContext;
+    modoCliqueSequencialAtivo: boolean;
+    chaveGrupo?: string;
+    zonaProjecao: number;
+    levantamentoId: number | null;
+    customMarkerClickCallback?: (pId: number, isVizinho?: boolean) => void;
+    customPopupActionCallback?: (acaoId: string, elementoId: string | number, elemento: any) => void;
+    private destaqueState;
+    constructor(customLayers?: CanvasLayerDef[]);
+    init(containerIdOrElement: string | HTMLElement, hostRoot?: HTMLElement | ShadowRoot): L.Map | null;
+    invalidateSize(): void;
+    setPontos(pontos?: Ponto[] | null): void;
+    setSegmentos(segmentos?: Segmento[] | null): void;
+    setBancoPontos(bancoPontos?: BancoPonto[] | null): void;
+    setConfrontantes(confrontantes?: Confrontante[] | null): void;
+    plotarPontos(p?: PontoCAD[] | null, c?: string, cl?: (p: PontoCAD) => void): void;
+    plotarConexoes(conexoes?: ConexaoCAD[] | null, camadaId?: string): void;
+    plotarPolilinhaSequencial(p?: PontoCAD[] | null, fechar?: boolean, camadaId?: string, cg?: string): void;
+    plotarPoligonos(poligonos?: PoligonoCAD[] | null, camadaId?: string): void;
+    limparCamadas(idsCamadas?: string[]): void;
+    obterMarcadores(camadaId?: string): L.Marker[];
+    plotPontos(pontos?: Ponto[] | null, onMarkerClick?: (pontoId: number, isVizinho?: boolean) => void): void;
+    plotSegmentos(segmentos?: Segmento[] | null, pontos?: Ponto[] | null): void;
+    plotPolilinhaTemporaria(pontos?: Ponto[] | null): void;
+    plotPoligonalHomologada(bancoPontos?: BancoPonto[] | null): void;
+    plotPontosVizinhos(pontos?: Ponto[] | null): void;
+    plotPoligonosVizinhos(confrontantes?: Confrontante[] | null): void;
+    clearOverlays(manterBanco?: boolean): void;
+    setGraphicScale(scale: Partial<CanvasGraphicScale>): void;
+    exportState(): CanvasLayerState[];
+    importState(state: CanvasLayerState[]): void;
+    selectPonto(pId: string | number, zoomLevel?: number): void;
+    atualizarDestaqueMarcadores(): void;
+    fitBounds(pontos?: Ponto[], padding?: [number, number], incluirVizinhos?: boolean): void;
+    getMarkers(): L.Marker[];
+    getVizinhosMarkers(): L.Marker[];
+    get destaqueAtivo(): boolean;
+    localizarCoordenadasElemento(id: string | number): L.LatLng | null;
+    destacarElemento(id: string | number, opcoes?: DestacarElementoOpcoes): void;
+    limparDestaque(): void;
+    destroy(): void;
+    getMap(): L.Map | null;
+}
+export { GerenciGeoMapaController as CanvasCADController, GerenciGeoMapaController as CADMapaController };

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

@@ -0,0 +1,30 @@
+import { default as L } from 'leaflet';
+import { MapaConfigManager } from './mapa_config';
+import { MapaConfiguracoes } from './types';
+export interface MapaCoreControllerRef {
+    modoCliqueSequencialAtivo?: boolean;
+    canvasInteracao?: {
+        selectionHappened?: boolean;
+    };
+    layerManager?: any;
+}
+export declare class MapaCore {
+    map: L.Map | null;
+    configManager: MapaConfigManager;
+    config: MapaConfiguracoes;
+    apiBaseUrl: string;
+    bancoPontosGroup: L.LayerGroup;
+    pontosVizinhosGroup: L.LayerGroup;
+    private controller;
+    private containerElement;
+    private bc?;
+    private sigefState;
+    constructor(controller: MapaCoreControllerRef);
+    init(containerIdOrElement: string | HTMLElement): L.Map | null;
+    invalidateSize(animate?: boolean): void;
+    private applyMapStyles;
+    private listenConfigBroadcast;
+    destroy(): void;
+    preCarregarTilesRegiao(bounds: L.LatLngBounds): void;
+    private consultarSigef;
+}

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

@@ -0,0 +1,14 @@
+import { default as L } from 'leaflet';
+import { Segmento, Ponto, BancoPonto } from './types';
+import { MapaCore } from './mapa_core';
+export declare class MapaLinhas {
+    polylines: L.Polyline[];
+    bancoPontosAtivo: boolean;
+    private core;
+    constructor(core: MapaCore, _controller?: any);
+    setBancoPontosAtivo(ativo: boolean): void;
+    plotSegmentos(segmentos: Segmento[], pontos: Ponto[]): void;
+    plotPolilinhaTemporaria(pontos: Ponto[]): void;
+    plotPoligonalHomologada(bancoPontos: BancoPonto[]): void;
+    clearLinhas(): void;
+}

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

@@ -0,0 +1,18 @@
+import { default as L } from 'leaflet';
+import { Ponto, Confrontante } from './types';
+import { MapaCore } from './mapa_core';
+export declare class MapaMarcadores {
+    markers: L.Marker[];
+    vizinhosMarkers: L.Marker[];
+    vizinhosPoligonos: L.Polygon[];
+    private core;
+    private controller;
+    constructor(core: MapaCore, controller: any);
+    plotPontos(pontos: Ponto[], onMarkerClick: (id: number) => void): void;
+    plotPontosVizinhos(pontos: Ponto[]): void;
+    /**
+     * Desenha o perímetro (limites) dos imóveis vizinhos importados via WKT POLYGON
+     */
+    plotPoligonosVizinhos(confrontantes: Confrontante[]): void;
+    clearMarkers(): void;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Helper para renderizar elementos HTML/SVG de marcadores no Leaflet Canvas/DOM.
+ * Estilos inline 100% autônomos (independentes de Tailwind) e suporte completo a
+ * formas geométricas topográficas (circle, circle-dot, square, diamond, cross, x, triangle)
+ * com suporte nativo a seleção e destaque visual.
+ */
+export declare function extrairCorPonto(bgClassOuCor: string): string;
+export declare function getPointShapeHtml(shapeStyle: string, size: number, bgClass: string, extraClasses?: string, id?: string, selecionado?: boolean): string;

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

@@ -0,0 +1,9 @@
+import { default as L } from 'leaflet';
+import { ILayerRenderer } from '../layer_renderer_factory';
+import { CanvasLayerDef, CanvasRenderContext } from '../types';
+export declare class GridLayerRenderer implements ILayerRenderer {
+    private moveListenerMap;
+    render(layerDef: CanvasLayerDef, map: L.Map, _context: CanvasRenderContext): L.LayerGroup;
+    update(layerDef: CanvasLayerDef, layerInstance: L.LayerGroup): void;
+    destroy(layerInstance: L.LayerGroup, map: L.Map): void;
+}

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

@@ -0,0 +1,8 @@
+import { default as L } from 'leaflet';
+import { ILayerRenderer } from '../layer_renderer_factory';
+import { CanvasLayerDef, CanvasRenderContext } from '../types';
+export declare class TileLayerRenderer implements ILayerRenderer {
+    render(layerDef: CanvasLayerDef, _map: L.Map, _context: CanvasRenderContext): L.Layer | null;
+    update(_layerDef: CanvasLayerDef, layerInstance: L.Layer, changes: Partial<CanvasLayerDef>): void;
+    destroy(layerInstance: L.Layer, map: L.Map): void;
+}

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

@@ -0,0 +1,4 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerDef, CanvasRenderContext } from '../types';
+export declare function calculateLineWeight(layerDef: CanvasLayerDef, map: L.Map, context: CanvasRenderContext): number;
+export declare function rebuildVectorLines(layerDef: CanvasLayerDef, group: L.LayerGroup, map: L.Map, context: CanvasRenderContext, paneName: string): void;

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

@@ -0,0 +1,9 @@
+import { default as L } from 'leaflet';
+import { ILayerRenderer } from '../layer_renderer_factory';
+import { CanvasLayerDef, CanvasRenderContext } from '../types';
+export declare class VectorLinesLayerRenderer implements ILayerRenderer {
+    private zoomListenerMap;
+    render(layerDef: CanvasLayerDef, map: L.Map, context: CanvasRenderContext): L.LayerGroup;
+    update(layerDef: CanvasLayerDef, layerInstance: L.LayerGroup, changes: Partial<CanvasLayerDef>, context: CanvasRenderContext, map: L.Map): void;
+    destroy(layerInstance: L.LayerGroup, map: L.Map): void;
+}

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

@@ -0,0 +1,11 @@
+import { default as L } from 'leaflet';
+import { ILayerRenderer } from '../layer_renderer_factory';
+import { CanvasLayerDef, CanvasRenderContext } from '../types';
+export declare class VectorPointsLayerRenderer implements ILayerRenderer {
+    private zoomListenerMap;
+    render(layerDef: CanvasLayerDef, map: L.Map, context: CanvasRenderContext): L.LayerGroup;
+    private calculateSize;
+    private rebuildPoints;
+    update(layerDef: CanvasLayerDef, layerInstance: L.LayerGroup, changes: Partial<CanvasLayerDef>, context: CanvasRenderContext, map: L.Map): void;
+    destroy(layerInstance: L.LayerGroup, map: L.Map): void;
+}

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

@@ -0,0 +1,9 @@
+import { default as L } from 'leaflet';
+import { ILayerRenderer } from '../layer_renderer_factory';
+import { CanvasLayerDef, CanvasRenderContext } from '../types';
+export declare class VectorPolygonsLayerRenderer implements ILayerRenderer {
+    render(layerDef: CanvasLayerDef, _map: L.Map, context: CanvasRenderContext): L.LayerGroup;
+    private rebuildPolygons;
+    update(layerDef: CanvasLayerDef, layerInstance: L.LayerGroup, changes: Partial<CanvasLayerDef>, context: CanvasRenderContext): void;
+    destroy(layerInstance: L.LayerGroup, map: L.Map): void;
+}

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

@@ -0,0 +1,8 @@
+import { default as L } from 'leaflet';
+import { ILayerRenderer } from '../layer_renderer_factory';
+import { CanvasLayerDef, CanvasRenderContext } from '../types';
+export declare class WmsLayerRenderer implements ILayerRenderer {
+    render(layerDef: CanvasLayerDef, _map: L.Map, _context: CanvasRenderContext): L.Layer | null;
+    update(_layerDef: CanvasLayerDef, layerInstance: L.Layer, changes: Partial<CanvasLayerDef>): void;
+    destroy(layerInstance: L.Layer, map: L.Map): void;
+}

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

@@ -0,0 +1,9 @@
+import { default as L } from 'leaflet';
+export interface SigefConsultorState {
+    currentAbortController?: AbortController;
+}
+/**
+ * Consulta de certificações fundiárias no WMS do SIGEF/INCRA
+ * e renderização de popups informativos com links de shapefile e importação.
+ */
+export declare function consultarSigefNoPonto(map: L.Map, e: L.LeafletMouseEvent, apiBaseUrl: string, state: SigefConsultorState): Promise<void>;

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

@@ -0,0 +1,2 @@
+import { default as L } from 'leaflet';
+export declare function preCarregarTilesRegiao(map: L.Map | null, bounds: L.LatLngBounds): void;

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

@@ -0,0 +1,169 @@
+export type ScaleMode = 'screen' | 'world';
+export type CanvasLayerCategory = 'base' | 'wms' | 'levantamento' | 'referencia' | 'anotacoes' | 'custom';
+export type CanvasLayerType = 'tile' | 'wms' | 'vetorial-linhas' | 'vetorial-pontos' | 'vetorial-poligonos' | 'grid' | string;
+export interface LayerStyleDef {
+    corPrimaria?: string;
+    corSecundaria?: string;
+    espessuraLinha?: number;
+    tamanhoMarcador?: number;
+    estiloMarcador?: 'circle' | 'square' | 'cross' | 'circle-dot' | 'triangle' | 'diamond' | string;
+    dashArray?: string;
+    scaleMode?: ScaleMode;
+    /** Dimensão métrica no terreno em metros quando scaleMode === 'world' */
+    dimensaoMetros?: number;
+}
+export interface PopupAcaoCAD {
+    id: string;
+    rotulo: string;
+    variante?: 'primary' | 'secondary' | 'destrutivo';
+}
+export interface DestacarElementoOpcoes {
+    pan?: boolean;
+    zoom?: number;
+    duracaoMs?: number;
+    cor?: string;
+}
+export interface CanvasLayerDef {
+    id: string;
+    nome: string;
+    categoria: CanvasLayerCategory;
+    tipo: CanvasLayerType;
+    visivel: boolean;
+    opacidade: number;
+    zIndex: number;
+    interativo: boolean;
+    bloqueada?: boolean;
+    minZoom?: number;
+    maxZoom?: number;
+    estilo: LayerStyleDef;
+    acoes?: PopupAcaoCAD[];
+    /** Dados ou URL associados à camada */
+    dados?: any;
+}
+export interface CanvasLayerState {
+    id: string;
+    visivel: boolean;
+    opacidade: number;
+    zIndex: number;
+    bloqueada?: boolean;
+    estilo?: Partial<LayerStyleDef>;
+}
+export interface CanvasGraphicScale {
+    markerScaleMultiplier: number;
+    lineScaleMultiplier: number;
+    scaleModeGlobal?: ScaleMode;
+}
+/** Entidade pontual geométrica primitiva (agnóstica a domínio) */
+export interface PontoCAD {
+    id: string | number;
+    lat: number;
+    lon: number;
+    estilo?: string;
+    grupoId?: string | number;
+    grupoKey?: string | number;
+    ordem?: number;
+    indice?: number;
+    metadados?: Record<string, any>;
+    acoes?: PopupAcaoCAD[];
+    [key: string]: any;
+}
+/** Entidade de conexão linear entre nós primitivos (agnóstica a domínio) */
+export interface ConexaoCAD {
+    origemId: string | number;
+    destinoId: string | number;
+    tipoLinha?: 'continua' | 'tracejada';
+    estilo?: Record<string, any>;
+    acoes?: PopupAcaoCAD[];
+    [key: string]: any;
+}
+/** Entidade de área/polígono geométrica (agnóstica a domínio) */
+export interface PoligonoCAD {
+    id: string | number;
+    coordenadas?: number[][] | [number, number][];
+    wkt?: string;
+    estilo?: Record<string, any>;
+    acoes?: PopupAcaoCAD[];
+    [key: string]: any;
+}
+export interface Ponto {
+    id: number | string;
+    lat?: number;
+    lon?: number;
+    tipo_ponto?: string;
+    tipo?: string;
+    nome_vertice?: string;
+    ignorar_poligono?: number;
+    ordem_caminhamento?: number;
+    confrontante_id?: number;
+    nome_confrontante?: string;
+    nome_propriedade?: string;
+    matricula_id?: number;
+    planilha_origem?: string;
+    este?: number;
+    norte?: number;
+    altitude?: number;
+    acoes?: PopupAcaoCAD[];
+}
+export interface Segmento {
+    ponto_inicio_id: number;
+    ponto_fim_id: number;
+    tipo_limite_sigef?: string;
+    tipo_limite?: string;
+    metodo_posicionamento_sigef?: string;
+    metodo_posicionamento?: string;
+}
+export interface BancoPonto extends Ponto {
+    codigo_completo?: string;
+    este?: number;
+    norte?: number;
+    altitude?: number;
+    metodo_posicionamento?: string;
+    tipo_limite?: string;
+    confrontante_descritivo?: string;
+    matricula_id?: number;
+    planilha_origem?: string;
+}
+export interface Confrontante {
+    id?: number | string;
+    nome?: string;
+    nome_propriedade?: string;
+    poligono_wkt?: string;
+    pontos?: Ponto[];
+}
+export interface MapaConfiguracoes {
+    perimetroWeight: number;
+    fechamentoWeight: number;
+    vizinhoWeight: number;
+    bancoWeight: number;
+    markerSizeBase: number;
+    markerStyleM?: string;
+    markerSizeM?: number;
+    markerStyleP?: string;
+    markerSizeP?: number;
+    markerStyleV?: string;
+    markerSizeV?: number;
+    enableAnimations: boolean;
+    preferCanvas: boolean;
+    crosshair?: boolean;
+    satOpacity?: number;
+    magnetSnap?: boolean;
+    scaleMode?: ScaleMode;
+}
+export interface CanvasRenderContext {
+    pontos?: Ponto[];
+    segmentos?: Segmento[];
+    bancoPontos?: BancoPonto[];
+    confrontantes?: Confrontante[];
+    config: MapaConfiguracoes;
+    graphicScale: CanvasGraphicScale;
+    apiBaseUrl?: string;
+    modoSequencial?: boolean;
+    chaveGrupo?: string;
+    zonaProjecao?: number;
+    onMarkerClick?: (pontoId: string | number, isVizinho?: boolean, elemento?: any, coords?: {
+        lat: number;
+        lon: number;
+    }) => void;
+    onLayerAction?: (action: string, detail: any) => void;
+    onPopupAcao?: (acaoId: string, elementoId: string | number, elemento: any) => void;
+}

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

@@ -0,0 +1,46 @@
+import { PopupAcaoCAD } from './types';
+/**
+ * Utilitários auxiliares para o ecossistema Canvas/Mapa do GerenciGeo
+ */
+export declare const escapeHtml: (unsafe: string | null | undefined) => string;
+export declare const formatUTM: (val: number | null | undefined, casas?: number) => string;
+export interface CoordenadaGeo {
+    lat: number;
+    lon: number;
+}
+/**
+ * Converte e valida coordenadas geográficas (Lat/Lon) em graus decimais WGS-84.
+ * - Trata números e strings no formato brasileiro (vírgula como separador decimal: "-23,7661")
+ * - Filtra valores inválidos, NaN, Null Island (0, 0)
+ * - Identifica e rejeita coordenadas planas métricas (UTM/SIRGAS2000 acima de 90°/180°)
+ */
+export declare const parseCoordenada: (rawLat: any, rawLon: any) => CoordenadaGeo | null;
+/**
+ * Gera o HTML dos botões de ação customizados para o rodapé do popup.
+ */
+export declare const renderPopupAcoesHtml: (acoes: PopupAcaoCAD[] | undefined | null, elementoId: string | number) => string;
+/**
+ * Associa os eventos de clique nos botões de ação renderizados dentro do popup do Leaflet.
+ */
+export declare const bindPopupAcoesEvents: (popup: any, elemento: any, context: {
+    onPopupAcao?: (acaoId: string, elementoId: string | number, elemento: any) => void;
+}, sourceLayer?: any) => void;
+/**
+ * Agrupa coleção de pontos geométricos por uma chave de grupo genérica.
+ * Prioridade de resolução da chave:
+ * 1. ponto[chaveGrupo] (se chaveGrupo for fornecida explicitamente)
+ * 2. ponto.grupoId
+ * 3. ponto.grupoKey
+ * 4. ponto.matricula_id (como `mat_${matricula_id}`)
+ * 5. ponto.planilha_origem
+ * 6. 'padrao'
+ */
+export declare const agruparPontosPorChave: (pontos: any[], chaveGrupo?: string) => Record<string, any[]>;
+/**
+ * Ordena pontos de um grupo por sua propriedade de sequência (ordem, indice, index, seq, ordem_caminhamento, id).
+ */
+export declare const ordenarPontosPorSequencia: (pontos: any[]) => any[];
+/**
+ * Extrai o centroide geográfico (Lat, Lon) a partir de uma representação WKT (ex: POLYGON, MULTIPOLYGON, POINT, LINESTRING).
+ */
+export declare const extrairCentroDeWkt: (wkt: string | null | undefined) => CoordenadaGeo | null;