@thibezer/ui-components-kit 2.0.0 → 2.2.0

package/dist/components/ui-barra-ferramentas/tipos.d.ts

@@ -1,7 +1,7 @@
 /**
  * Tipos compartilhados pelos componentes de barra de ferramentas:
- *  - <ui-ribbon>              → abas + grupos (estilo AutoCAD / Word / Excel)
- *  - <ui-paleta-ferramentas>  → paleta com flyouts (estilo Illustrator / Photoshop)
+ *  - <ui-ribbon>              → barra contextual com abas e grupos
+ *  - <ui-paleta-ferramentas>  → paleta de ferramentas com flyouts expansíveis
  */
 /**
  * - `botao`      ação pontual (Desfazer, Colar…). Padrão no ribbon.

package/dist/components/ui-barra-ferramentas/ui-paleta-ferramentas.d.ts

@@ -1,13 +1,13 @@
 import { FerramentaItem } from './tipos';
 import { SafeHTMLElement } from '../../core/ssr-safe';
 /**
- * <ui-paleta-ferramentas> — paleta de ferramentas (estilo Illustrator / Photoshop).
+ * <ui-paleta-ferramentas> — paleta de ferramentas gráficas com grupos expansíveis.
  *
  * - Itens com `filhos` viram um grupo: mostra a última ferramenta usada e abre um flyout
  *   com clique longo, botão direito ou seta (→ na vertical, ↓ na horizontal).
  * - Ferramentas (`tipo` padrão) são exclusivas; `toggle` liga/desliga; `botao` só dispara ação.
  * - Com o atributo `atalhos`, a tecla `atalho` do item ativa a ferramenta; teclas repetidas
- *   entre itens percorrem o grupo (como Shift+letra no Photoshop).
+ *   entre itens percorrem o grupo.
  *
  * Atributos: valor, orientacao (vertical|horizontal), colunas (1|2), tamanho (sm|md|lg), atalhos
  * Propriedades: ferramentas, valor

package/dist/components/ui-camadas/camadas-adapters.d.ts

@@ -0,0 +1,45 @@
+import { CamadaItem, FeicaoItem } from './tipos';
+import { CanvasLayerDef, CanvasLayerCategory, CanvasLayerType } from '../../gerencigeo-canvas/types';
+/**
+ * Converte uma definição de camada do Canvas CAD (CanvasLayerDef)
+ * para o modelo de camada do painel <ui-camadas> (CamadaItem)
+ */
+export declare function converterCanvasLayerParaCamadaItem(layer: Partial<CanvasLayerDef> & {
+    id: string;
+}): CamadaItem;
+/**
+ * Converte um item de camada do painel <ui-camadas> (CamadaItem)
+ * para o modelo interno de camada do Canvas CAD (CanvasLayerDef)
+ */
+export declare function converterCamadaItemParaCanvasLayer(item: CamadaItem, categoriaPadrao?: CanvasLayerCategory, tipoPadrao?: CanvasLayerType): CanvasLayerDef;
+/**
+ * Converte uma feição genérica do Canvas/GeoJSON para FeicaoItem do <ui-camadas>
+ */
+export declare function converterFeicaoParaItem(feicao: {
+    id: string;
+    nome?: string;
+    name?: string;
+    layerId?: string;
+    camadaId?: string;
+    tipo?: string;
+    type?: string;
+    geometria?: {
+        tipo?: string;
+        type?: string;
+        coordenadas?: unknown;
+        coordinates?: unknown;
+    };
+    coordinates?: unknown;
+    cor?: string;
+    color?: string;
+    visivel?: boolean;
+    visible?: boolean;
+    bloqueada?: boolean;
+    locked?: boolean;
+    status?: string;
+    categoria?: string;
+    category?: string;
+    propriedades?: Record<string, unknown>;
+    properties?: Record<string, unknown>;
+    [key: string]: unknown;
+}, camadaIdFallback?: string): FeicaoItem;

package/dist/components/ui-camadas/camadas-arvore-renderer.d.ts

@@ -15,4 +15,13 @@ export interface ParametrosRenderArvore {
 }
 export { escapeHtml };
 export declare function renderizarThumbGeometria(tipo: string | undefined, cor: string): string;
+export interface CamadaNodoHierarquico {
+    camada: CamadaItem;
+    depth: number;
+    subcamadas: CamadaNodoHierarquico[];
+}
+/**
+ * Organiza a lista de camadas em uma árvore hierárquica de nós baseada em parentId ou children
+ */
+export declare function construirHierarquiaCamadas(camadas: CamadaItem[]): CamadaNodoHierarquico[];
 export declare function renderizarArvoreCamadas(params: ParametrosRenderArvore): string;

package/dist/components/ui-camadas/camadas-drag-drop.d.ts

@@ -15,4 +15,8 @@ export declare class CamadasDragDropManager {
     bindAll(): void;
     bindInlineRename(): void;
     bindDragAndDrop(): void;
+    /**
+     * Suporte a arraste por toque e ponteiro no handle (.ui-col-drag) para tablets e mobile
+     */
+    bindTouchDragAndDrop(): void;
 }

package/dist/components/ui-camadas/camadas-metricas.d.ts

@@ -8,7 +8,14 @@ export declare function calcularDistanciaPontos(p1: [number, number], p2: [numbe
  */
 export declare function calcularComprimentoLinha(coords: unknown): number;
 /**
- * Calcula a área de um anel poligonal em m² usando fórmula esférica
+ * Calcula a área de um único anel fechado de coordenadas em m² usando fórmula esférica
+ */
+export declare function calcularAreaAnelSimples(coords: unknown): number;
+/**
+ * Calcula a área de um polígono em m² com suporte a:
+ * - Anel simples: [ [lat,lon], [lat,lon], ... ]
+ * - Polygon GeoJSON com furos (anel exterior menos furos): [ [exterior], [furo1], [furo2] ]
+ * - MultiPolygon GeoJSON: [ [ [exterior], [furo] ], [ [exterior] ] ]
  */
 export declare function calcularAreaPoligono(coords: unknown): number;
 /**

package/dist/components/ui-camadas/camadas-persistencia.d.ts

@@ -5,6 +5,7 @@ export interface CamadaPropsPersistidas {
     locked?: boolean;
     opacity?: number;
     color?: string;
+    parentId?: string | null;
 }
 export interface CamadaOverridePersistido extends CamadaPropsPersistidas {
     /**
@@ -20,6 +21,8 @@ export interface EstadoPersistidoCamadas {
     camadaAtivaId?: string | null;
     painelColapsado?: boolean;
     ordemCamadasIds?: string[];
+    /** Ordem em que a aplicação enviou as camadas quando `ordemCamadasIds` foi salva. */
+    ordemOrigemIds?: string[];
     mapaBaseAtivo?: string;
     densidade?: 'compacto' | 'normal';
     altura?: number | null;
@@ -57,6 +60,8 @@ export interface EntradaMontagemEstado {
     mapaBaseAtivo: string;
     densidade: 'compacto' | 'normal';
     altura: number | null;
+    /** Camadas excluídas pelo usuário: seus overrides deixam de ser guardados. */
+    camadasRemovidas?: Iterable<string>;
 }
 /**
  * Monta o estado a persistir. Se ainda não há camadas na instância,

package/dist/components/ui-camadas/camadas-rodape.d.ts

@@ -1,2 +1,7 @@
 import { CamadaItem, FeicaoItem } from './tipos';
+/**
+ * Formata opções de camadas para o select de mover, preservando
+ * a hierarquia visual com recuo e ícones de pasta
+ */
+export declare function formatarOpcoesCamadasHierarquicas(camadas: CamadaItem[]): string;
 export declare function renderizarRodapeAcoes(camadas: CamadaItem[], feicoes: FeicaoItem[], selecionadasIds: Set<string>): string;

package/dist/components/ui-camadas/index.d.ts

@@ -9,3 +9,4 @@ export * from './camadas-persistencia';
 export * from './camadas-host';
 export * from './camadas-selecao';
 export * from './ui-camadas';
+export * from './camadas-adapters';

package/dist/components/ui-camadas/tipos.d.ts

@@ -37,6 +37,9 @@ export interface CamadaItem {
     order?: number;
     count?: number;
     description?: string;
+    parentId?: string | null;
+    children?: CamadaItem[];
+    isGroup?: boolean;
     [key: string]: unknown;
 }
 export interface MapaBaseItem {
@@ -86,6 +89,11 @@ export interface DetalheEventoRenomearCamada {
     camadaId: string;
     novoNome: string;
 }
+export interface DetalheEventoMoverHierarquiaCamada {
+    camadaId: string;
+    novoParentId: string | null;
+    camada?: CamadaItem;
+}
 export interface DetalheEventoFeicao {
     feicaoId: string;
     feicao?: FeicaoItem;

package/dist/components/ui-camadas/ui-camadas.d.ts

@@ -9,6 +9,11 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     private resizerController;
     private alturaCustomizada;
     private conectado;
+    private profundidadeLote;
+    private renderPendente;
+    private camadasRemovidas;
+    /** Painéis conectados sem `id` nem `storage-key`: dividem a mesma chave de persistência. */
+    private static instanciasChavePadrao;
     private origensCamadas;
     private salvarLembrancaDebounced;
     camadas: CamadaItem[];
@@ -74,6 +79,7 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     /** Atalho reativo para `definirMapasBase()` — não dispara eventos. */
     get basemaps(): MapaBaseItem[];
     set basemaps(mapas: MapaBaseItem[]);
+    private achatarCamadas;
     definirCamadas(camadas: CamadaItem[], feicoes?: FeicaoItem[]): void;
     definirFeicoes(feicoes: FeicaoItem[]): void;
     definirMapasBase(mapas: MapaBaseItem[]): void;
@@ -98,6 +104,11 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     alternarColapso(emitirEvento?: boolean): void;
     private definirColapso;
     solicitarRenderizacao(): void;
+    /**
+     * Agrupa várias mutações (`adicionarFeicao` em laço, por exemplo) em uma só renderização, ao fim de `fn`.
+     * Sem isto, cada chamada redesenha a árvore inteira.
+     */
+    emLote(fn: () => void): void;
     dispararEvento(nome: string, detalhe: unknown): void;
     private render;
     private conectarEventosGerais;

package/dist/components/ui-canvas-cad/cad-estilos-externos.d.ts

@@ -0,0 +1,16 @@
+export type EstilosExternos = string | CSSStyleSheet[] | null | undefined;
+export declare function estilosParaTexto(entrada: EstilosExternos): string[];
+export declare class EstilosExternosShadow {
+    private shadow;
+    private textos;
+    private adotadas;
+    private fallback;
+    constructor(shadow: ShadowRoot);
+    /** O que o consumidor pediu por último (para reaplicar quando o componente reconecta). */
+    get pedido(): readonly string[];
+    definir(entrada: EstilosExternos): void;
+    /** Tira as folhas do shadow root, mantendo o pedido para `aplicar()` depois. */
+    limpar(): void;
+    aplicar(): void;
+    private remover;
+}

package/dist/components/ui-canvas-cad/cad-eventos-canvas.d.ts

@@ -24,3 +24,7 @@ export declare function tratarCliqueMarcador(ctx: ContextoEventosCanvas, pId: st
     lat: number;
     lon: number;
 }) => void, customMarkerClickHandler?: (pontoId: number, isVizinho?: boolean) => void): void;
+export declare function tratarCliqueSegmento(ctx: ContextoEventosCanvas, segmentoId: string | number, segmento: any, coords?: {
+    lat: number;
+    lon: number;
+}, customSegmentoClickHandler?: (segmentoId: string | number, segmento: any) => void): void;

package/dist/components/ui-canvas-cad/cad-feicoes.d.ts

@@ -0,0 +1,262 @@
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { LayerStyleDef } from '../../gerencigeo-canvas/types';
+import { Feicao, EstiloFeicao, LatLonPar } from '../../gerencigeo-canvas/feature_types';
+import { RegraVersoes } from '../../gerencigeo-canvas/feature_versoes';
+import { UsuarioRemoto } from '../../gerencigeo-canvas/feature_cursores';
+import { RefFeicao } from '../../gerencigeo-canvas/feature_selecao';
+import { CaixaPx, ModoCaixa } from '../../gerencigeo-canvas/feature_caixa';
+import { MargensPopup } from '../../gerencigeo-canvas/feature_popup';
+import { default as L } from 'leaflet';
+import { MotivoRecusaEdicao } from '../../gerencigeo-canvas/feature_edicao_ops';
+import { ExcluirSnap } from '../../gerencigeo-canvas/feature_snap';
+import { Ferramenta } from '../../gerencigeo-canvas/feature_desenho';
+import { MargensHud } from '../../gerencigeo-canvas/feature_hud';
+export declare const TIPO_CAMADA_FEICOES = "feicoes";
+export interface OpcoesCamadaFeicoes {
+    nome?: string;
+    zIndex?: number;
+    opacidade?: number;
+    interativo?: boolean;
+    estilo?: Partial<LayerStyleDef>;
+}
+/** Opções de `aplicarLote` / `atualizarFeicao`. */
+export interface OpcoesLote extends OpcoesCamadaFeicoes {
+    /**
+     * Em atualizações, `propriedades` informadas SUBSTITUEM as atuais (o padrão é mesclar, e chaves apagadas
+     * pelo consumidor ficam para trás). Sem `propriedades` no item, nada muda.
+     */
+    substituirPropriedades?: boolean;
+}
+/** Itens de atualização: `id` aponta a feição; o resto é mesclado como em `atualizarFeicao`. */
+export type AtualizacaoFeicao = Record<string, any> & {
+    id: string;
+};
+export interface LoteFeicoes {
+    adicionar?: unknown[];
+    atualizar?: AtualizacaoFeicao[];
+    remover?: string[];
+}
+export interface ResultadoLote {
+    adicionadas: number;
+    atualizadas: number;
+    removidas: number;
+    /** Ids (ou posições, quando não há id) recusados: geometria inválida, feição inexistente numa atualização, camada que não é de feições. */
+    recusadas: string[];
+}
+export interface ResultadoFeicoes {
+    /** Quantas feições entraram na camada. */
+    aceitas: number;
+    /** Ids (ou posições, quando não há id) das feições recusadas por geometria inválida. */
+    recusadas: string[];
+}
+interface Contexto {
+    obterLayerManager: () => CanvasLayerManager;
+    obterMapa: () => L.Map | null;
+    /** Dispara o evento do componente. Com `cancelavel`, devolve `true` se algum ouvinte chamou `preventDefault()`. */
+    emitir: (evento: string, detalhe: unknown, cancelavel?: boolean) => unknown;
+    /** O snap foi ligado/desligado (para refletir no botão da barra). */
+    aoSnapMudar?: (ligado: boolean) => void;
+    /** A ferramenta de desenho ativa mudou (`null` = nenhuma). */
+    aoFerramenta?: (ferramenta: Ferramenta | null) => void;
+    /** Regra de oficial × prévia compartilhada com o renderizador (o componente a põe no contexto de renderização). */
+    regra?: RegraVersoes;
+}
+/** Opções do popup da feição. */
+export interface OpcoesPopup {
+    /** A ação "copiar" grava as coordenadas na área de transferência (padrão `true`); `cad-feicao-acao` sai de qualquer jeito. */
+    copiarParaAreaDeTransferencia?: boolean;
+}
+export interface ResultadoFerramenta {
+    ok: boolean;
+    motivo?: 'ferramenta-invalida' | 'sem-mapa' | 'sem-camada' | 'camada-invalida' | 'camada-bloqueada';
+}
+export interface ResultadoEdicao {
+    ok: boolean;
+    motivo?: MotivoRecusaEdicao | 'inexistente' | 'sem-mapa';
+}
+export declare class GerenciadorFeicoes {
+    private contexto;
+    private selecao;
+    private popup;
+    private editor;
+    private snap;
+    private desenho;
+    private camadaDesenho;
+    private estiloDesenho;
+    private sequenciaId;
+    private regra;
+    private cacheOficiais;
+    /** id -> posição na lista da camada (válido enquanto `lista` for a lista atual); evita varrer a camada a cada consulta. */
+    private posicoes;
+    private cursores;
+    private hoverId;
+    private hoverAgendado;
+    private margensHud;
+    /** Aceita a coordenada (0, 0) exata nas feições de entrada (atributo `aceitar-origem`). */
+    aceitarOrigem: boolean;
+    private opcoesPopup;
+    constructor(contexto: Contexto);
+    /** Depois de qualquer mudança nos dados: descarta seleção órfã e atualiza/fecha o popup aberto. */
+    private aposDados;
+    private lista;
+    private posicaoDe;
+    /** Feição da camada pelo id (O(1)); `undefined` se não existe. */
+    buscar(camadaId: string, id: string): Feicao | undefined;
+    private garantirCamada;
+    private opcoesNormalizacao;
+    definirFeicoes(camadaId: string, brutas: unknown[], opcoes?: OpcoesCamadaFeicoes): ResultadoFeicoes;
+    adicionarFeicao(camadaId: string, bruta: unknown, opcoes?: OpcoesCamadaFeicoes): Feicao | null;
+    /**
+     * Mescla campos de primeiro nível; `estilo` e `propriedades` também são mesclados. Com `substituirPropriedades`,
+     * `propriedades` informadas trocam as atuais por inteiro (atributos ausentes somem).
+     */
+    atualizarFeicao(camadaId: string, id: string, parcial: Record<string, any>, opcoes?: Pick<OpcoesLote, 'substituirPropriedades'>): Feicao | null;
+    /** Grava uma feição já normalizada (usado quando o próprio mapa a altera, como ao arrastar um texto). */
+    substituir(camadaId: string, feicao: Feicao): void;
+    removerFeicao(camadaId: string, id: string): boolean;
+    /**
+     * Várias mudanças numa só regravação e num só `aposDados`: remove, depois atualiza, depois adiciona.
+     * Adicionar um id que já existe substitui a feição mantendo a posição (a ordem de empilhamento não muda).
+     */
+    aplicarLote(camadaId: string, lote: LoteFeicoes, opcoes?: OpcoesLote): ResultadoLote;
+    private mesclar;
+    private aplicar;
+    obterFeicoes(camadaId: string): Feicao[];
+    /** Traduz as ações vindas do renderizador no evento a disparar pelo componente. */
+    tratarAcaoCamada(acao: string, detalhe: {
+        camadaId: string;
+        feicao: Feicao;
+        aditivo?: boolean;
+    }): string | null;
+    selecionarFeicoes(refs: RefFeicao[], aditivo?: boolean): void;
+    alternarSelecaoFeicao(ref: RefFeicao): void;
+    limparSelecaoFeicoes(): void;
+    /** Esc ou clique no vazio: durante a edição só encerra a edição; fora dela, limpa a seleção. */
+    aoPedirLimpeza(): void;
+    obterFeicoesSelecionadas(): Feicao[];
+    /** Laço: seleciona (substituindo) as feições de camadas selecionáveis tocadas pelo polígono; a ferramenta encerra. */
+    private selecionarNoLaco;
+    /** Caixa de seleção: só feições de camadas visíveis, interativas e desbloqueadas, com toque geométrico real. */
+    selecionarNaCaixa(caixa: CaixaPx, modo: ModoCaixa, aditivo: boolean): void;
+    definirMargensPopup(m: Partial<MargensPopup>): void;
+    fecharPopup(): void;
+    /** Opções do popup (hoje: se "copiar" escreve na área de transferência). Mescla com o que já foi definido. */
+    definirOpcoesPopup(opcoes: OpcoesPopup): void;
+    obterOpcoesPopup(): Required<OpcoesPopup>;
+    /**
+     * Margens (px) de barras e painéis que cobrem o mapa: os HUDs de desenho e de edição se centralizam na área
+     * que sobra. Mescla com o que já foi definido; `undefined` numa chave volta ao padrão (ou ao CSS `--cad-hud-*` do host).
+     */
+    definirMargensHud(m: Partial<MargensHud>): void;
+    private aplicarMargensHud;
+    get regraVersoes(): RegraVersoes;
+    private oficiaisDe;
+    /** Aparece segundo a regra de oficial × prévia? */
+    visivelPorVersao(f: Feicao): boolean;
+    /** Vai para a tela e responde a clique, caixa, laço, snap e hover: não excluída, não oculta e visível pela regra de versões. */
+    desenhada(f: Feicao): boolean;
+    /** Regra da seleção: a feição em edição continua selecionada mesmo se for ocultada no meio da edição. */
+    private selecionavelAgora;
+    private aplicarVersoes;
+    get previasGlobais(): boolean;
+    /** Mostra (ou esconde) as prévias de todas as entidades. Prévias de entidades sem oficial aparecem sempre. */
+    definirPreviasGlobais(ligado: boolean): void;
+    alternarPreviasGlobais(): void;
+    /** Liga/desliga a prévia da entidade a que a feição pertence. Devolve o novo estado, ou `null` se a feição não existe. */
+    alternarPrevia(camadaId: string, id: string): boolean | null;
+    /** A prévia da feição está sendo mostrada por pedido (global ou individual)? */
+    previaSolicitada(camadaId: string, id: string): boolean;
+    atualizarCursorRemoto(usuario: UsuarioRemoto, posicao: unknown): boolean;
+    removerCursorRemoto(id: string): boolean;
+    limparCursoresRemotos(): void;
+    get cursoresRemotos(): number;
+    /** Mostra o que estava escondido (camada oculta, prévia não solicitada) para a feição poder ser vista. */
+    private garantirVisivel;
+    private limitesDe;
+    private enquadrar;
+    /** Aproxima da feição; liga a camada e a prévia, se estiverem escondidas. Ponto: voa até z ≥ 17. */
+    zoomParaFeicao(camadaId: string, id: string): boolean;
+    zoomParaFeicoes(refs: RefFeicao[]): boolean;
+    /** Enquadra todas as feições das camadas de feições visíveis (que aparecem pela regra de versões). */
+    ajustarTudo(): boolean;
+    /** Enquadra a camada inteira; se estava oculta, torna-a visível. */
+    ajustarCamada(camadaId: string): boolean;
+    private feicaoSob;
+    /** Emite `cad-feicao-hover` quando a feição sob o mouse muda (uma checagem por quadro). */
+    aoMoverMouse(e: MouseEvent): void;
+    /** Botão direito: emite `cad-feicao-menu` com a feição sob o cursor (ou `null`), para o consumidor abrir o próprio menu. */
+    menuContexto(e: MouseEvent): void;
+    destruir(): void;
+    private tratarAcaoPopup;
+    get snapLigado(): boolean;
+    get snapAtivo(): boolean;
+    definirSnap(ligado: boolean): void;
+    alternarSnap(): void;
+    conectarTeclado(): void;
+    desconectarTeclado(): void;
+    /** Feições visíveis das camadas de feições cujo envelope toca um quadrado de `tolPx` px em volta de `coord`. */
+    private candidatasEm;
+    /** Snap de uma coordenada contra as feições visíveis de todas as camadas de feições (via índice espacial). */
+    buscarSnapEm(coord: [number, number], excluir?: ExcluirSnap): import('../../gerencigeo-canvas').ResultadoSnap | null;
+    get editando(): boolean;
+    iniciarEdicao(camadaId: string, id: string): ResultadoEdicao;
+    pararEdicao(): void;
+    get ferramentaAtiva(): Ferramenta | null;
+    /** Camada que recebe o que for desenhado. Não existe camada padrão: o consumidor escolhe. */
+    definirCamadaDesenho(camadaId: string | null): void;
+    get camadaDeDesenho(): string | null;
+    /** Estilo aplicado às feições desenhadas daqui para frente (o conta-gotas também o altera). */
+    definirEstiloDesenho(estilo: EstiloFeicao): void;
+    obterEstiloDesenho(): EstiloFeicao;
+    alternarFerramenta(nome: string): ResultadoFerramenta;
+    ativarFerramenta(nome: string, opcoes?: {
+        fechar?: boolean;
+        iniciarEm?: LatLonPar;
+    }): ResultadoFerramenta;
+    desativarFerramenta(): void;
+    limparMedicao(): void;
+    /** Vértices já colocados na figura em andamento (0 sem ferramenta ou sem figura). */
+    get nosDesenho(): number;
+    desfazerVerticeDesenho(): boolean;
+    /** Liga/desliga a tecla S do snap (o botão e `definirSnap` continuam valendo). */
+    definirAtalhoSnap(ligado: boolean): void;
+    private motivoCamadaDesenhoInvalida;
+    private novoId;
+    private idLivre;
+    /**
+     * Clique da ferramenta texto: emite `cad-texto-solicitado` (cancelável). Com `preventDefault()` o consumidor assume a
+     * entrada do texto e depois chama `detalhe.concluir(texto)` (cria na camada de desenho, com o estilo de desenho) ou
+     * simplesmente não faz nada para cancelar. Sem `preventDefault()`, aparece o campo inline.
+     */
+    private solicitarTexto;
+    private concluirFerramenta;
+    /** Conta-gotas: copia o estilo da feição sob o clique para o estilo de desenho. */
+    private amostrarEstilo;
+    /**
+     * Divide polígonos pela linha de corte. Alvos: os polígonos selecionados; sem seleção, o primeiro
+     * polígono (de camada visível, interativa e desbloqueada) que a linha corta.
+     */
+    dividirComLinha(linha: LatLonPar[]): boolean;
+    /** Cria um polígono de buffer ao redor da feição (na camada dela, ou em `camadaDestino`). */
+    gerarBuffer(camadaId: string, id: string, metros: number, opcoes?: {
+        camadaDestino?: string;
+        id?: string;
+    }): Feicao | null;
+    /** Copia a feição deslocada (em metros para leste/norte). */
+    duplicarFeicao(camadaId: string, id: string, deslocamento?: {
+        lesteM?: number;
+        norteM?: number;
+    }, opcoes?: {
+        id?: string;
+    }): Feicao | null;
+    /**
+     * Junta linhas (encadeando pontas) ou dois polígonos (por uma ponte) numa feição só; as originais saem.
+     * Linhas com pontas a até `toleranciaM` se ligam; polígonos precisam estar a até `toleranciaM` e
+     * não podem ter bordas que se cruzam.
+     */
+    juntarFeicoes(camadaId: string, ids: string[], opcoes?: {
+        toleranciaM?: number;
+        id?: string;
+    }): Feicao | null;
+}
+export {};

package/dist/components/ui-canvas-cad/cad-ferramentas-barra.d.ts

@@ -0,0 +1,15 @@
+import { Ferramenta } from '../../gerencigeo-canvas/feature_desenho';
+/** Interpreta o atributo; nomes desconhecidos são ignorados e a ordem da barra é sempre a canônica. */
+export declare function interpretarFerramentas(valor: string | null): Ferramenta[];
+export interface ContextoBarraFerramentas {
+    raiz: HTMLElement;
+    aoEscolher: (ferramenta: Ferramenta) => void;
+}
+export declare class BarraFerramentas {
+    private ctx;
+    private barra;
+    constructor(ctx: ContextoBarraFerramentas);
+    montar(ferramentas: Ferramenta[]): void;
+    marcar(ativa: Ferramenta | null): void;
+    desmontar(): void;
+}

package/dist/components/ui-canvas-cad/cad-snap.d.ts

@@ -0,0 +1,32 @@
+export interface ContextoControleSnap {
+    /** Chamado quando o estado efetivo ou o ligado/desligado muda. */
+    aoMudar: (estado: {
+        ativo: boolean;
+        ligado: boolean;
+        temporario: boolean;
+    }) => void;
+    /** Alvo dos listeners de teclado (padrão: window). */
+    alvo?: Pick<Window, 'addEventListener' | 'removeEventListener'>;
+}
+export declare class ControleSnap {
+    private contexto;
+    private _ligado;
+    private _altSegurado;
+    /** Tecla S alterna o snap. Desligável para quem já trata a tecla (ex.: atalhos próprios do app). */
+    atalhoS: boolean;
+    private conectado;
+    constructor(contexto: ContextoControleSnap);
+    /** Snap valendo agora: ligado e sem Alt. */
+    get ativo(): boolean;
+    get ligado(): boolean;
+    definir(ligado: boolean): void;
+    alternar(): void;
+    conectar(): void;
+    desconectar(): void;
+    private definirAlt;
+    private aoTeclaBaixo;
+    private aoTeclaCima;
+    /** Alt+Tab e afins: sem isto o Alt "ficaria preso" e o snap sumiria. */
+    private aoPerderFoco;
+    private notificar;
+}

package/dist/components/ui-canvas-cad/cad-toolbar-painel.d.ts

@@ -6,6 +6,7 @@ export interface ContextoToolbarPainel {
     onCloseCamadas?: () => void;
     onZoomExtents?: () => void;
     onLimparSelecao?: () => void;
+    onToggleSnap?: () => void;
     onTratarCliqueCanvas?: (e: MouseEvent) => void;
     onDispararAcaoPopup?: (acaoId: string, elementoId: string | number) => void;
 }