@thibezer/ui-components-kit 1.0.0 → 2.1.0

package/dist/card.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const e=require("./ui-card-Bhm6k91e.cjs");exports.UICard=e.UICard;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const e=require("./ui-card-B86lJXTP.cjs");exports.UICard=e.UICard;

package/dist/card.js

@@ -1,5 +1,5 @@
 /* empty css               */
-import { U as m } from "./ui-card-BJ8SmvVf.js";
+import { U as m } from "./ui-card-C_o5_0cB.js";
 export {
   m as UICard
 };

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

@@ -1,16 +1,26 @@
 import { SafeHTMLElement } from '../../core/ssr-safe';
 export type VarianteBotao = 'primary' | 'primario' | 'secondary' | 'secundario' | 'ghost' | 'terciario' | 'destructive' | 'destrutivo' | 'erro' | 'icon-only' | 'icone' | 'destaque' | 'outline' | 'borda';
 export declare class UIBotao extends SafeHTMLElement {
+    /** Form-associated: respeita `form="id"` e `<fieldset disabled>` como um <button> nativo. */
+    static formAssociated: boolean;
     static get observedAttributes(): string[];
     private button;
     private spinnerContainer;
     private slotElement;
     private opticalState;
     private listeners;
+    private internals;
+    private _formDisabled;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
+    formDisabledCallback(disabled: boolean): void;
+    get form(): HTMLFormElement | null;
+    get disabled(): boolean;
+    set disabled(val: boolean);
+    /** Ativa o botão como um clique real (no-op se desabilitado ou carregando), como `HTMLButtonElement.click()`. */
+    click(): void;
     get carregando(): boolean;
     set carregando(val: boolean);
     private handleSlotChange;
@@ -20,6 +30,11 @@ export declare class UIBotao extends SafeHTMLElement {
      */
     private sanitizeAndBalanceContent;
     private syncState;
+    /**
+     * O foco e o anúncio do leitor de tela ficam no <button> interno, então os atributos
+     * ARIA do host são copiados para ele. Botão só com ícone e sem `aria-label` usa o `title`.
+     */
+    private sincronizarAria;
     private handleClick;
 }
 export declare class UIBotaoPrimario extends UIBotao {

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

@@ -20,6 +20,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 +59,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/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[];
@@ -98,6 +103,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-campo-texto/ui-campo-texto.d.ts

@@ -47,6 +47,11 @@ export declare class UICampoTexto extends FormAssociatedElement {
     private handleRightIconKeyDown;
     private handleFocus;
     private handleBlur;
+    /**
+     * Enter submete o formulário como num <input> nativo. Aguarda um tick para que
+     * ouvintes do consumidor possam cancelar com `preventDefault()` no keydown.
+     */
+    private handleKeyDown;
     private handleInput;
     private handleChange;
 }

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

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

@@ -2,7 +2,11 @@ import { default as L } from 'leaflet';
 import { Ponto, Segmento, BancoPonto, Confrontante, CanvasLayerState, CanvasGraphicScale, ScaleMode, PontoCAD, ConexaoCAD, PoligonoCAD, DestacarElementoOpcoes } from '../../gerencigeo-canvas/types';
 import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
 import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { UsuarioRemoto } from '../../gerencigeo-canvas/feature_cursores';
+import { OpcoesCamadaFeicoes, OpcoesLote, LoteFeicoes, ResultadoLote, ResultadoFeicoes, ResultadoEdicao, ResultadoFerramenta } from './cad-feicoes';
+import { EstiloFeicao, Feicao } from '../../gerencigeo-canvas/feature_types';
 import { SafeHTMLElement } from '../../core/ssr-safe';
+import { EstilosExternos } from './cad-estilos-externos';
 export declare class UICanvasCAD extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private shadow;
@@ -13,8 +17,12 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     private toolbarPainel;
     private broadcastConfig;
     private colecoesDados;
+    private feicoes;
+    private barraFerramentas;
+    private hoverListeners;
     private layerItemListeners;
     private initTimeout?;
+    private estilosExternos;
     private lastPopupActionEmit?;
     private lastCanvasClickTime;
     private _chaveGrupo?;
@@ -25,6 +33,17 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     disconnectedCallback(): void;
     invalidateSizeSafely(): void;
     attributeChangedCallback(name: string, oldVal: string, newVal: string): void;
+    /**
+     * Cria o mapa agora, sem esperar o agendamento do `connectedCallback`. Idempotente: se o mapa já existe,
+     * devolve o mesmo; nunca cria um segundo. Devolve `null` se não houver contêiner (ex.: componente já destruído).
+     */
+    inicializarAgora(): L.Map | null;
+    /**
+     * CSS do consumidor dentro do shadow root (popups, rótulos...). Aceita texto ou folhas (`document.styleSheets`,
+     * copiadas como texto); cada chamada substitui a anterior, `null`/`[]` remove. `destroy()` tira as folhas do
+     * shadow root e uma reconexão as recoloca.
+     */
+    definirEstilosExternos(css: EstilosExternos): void;
     private initCAD;
     private obterContextoEventos;
     tratarCliqueLivreCanvas(e: MouseEvent | any, latLng?: any, pt?: any): void;
@@ -44,6 +63,12 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     set confrontantes(val: Confrontante[]);
     get vizinhos(): Confrontante[];
     set vizinhos(val: Confrontante[]);
+    /**
+     * Aceita a coordenada (0, 0) exata nas feições (atributo `aceitar-origem`). Padrão `false`: (0, 0) costuma ser
+     * placeholder de erro e a feição com vértice ali é recusada. Vale para as feições enviadas daqui para frente.
+     */
+    get aceitarOrigem(): boolean;
+    set aceitarOrigem(val: boolean);
     get modoSequencial(): boolean;
     set modoSequencial(val: boolean);
     get chaveGrupo(): string | undefined;
@@ -59,6 +84,9 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     get pontosSelecionados(): (string | number)[];
     set pontosSelecionados(ids: (string | number)[]);
     atualizarDestaqueMarcadores(): void;
+    selectSegmento(id: string | number | null): void;
+    get segmentoSelecionado(): string | number | null;
+    set segmentoSelecionado(id: string | number | null);
     limparSelecao(): void;
     setLayerVisibility(id: string, visivel: boolean): void;
     setLayerOpacity(id: string, opacidade: number): void;
@@ -85,6 +113,121 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     clearOverlays(manterBanco?: boolean): void;
     getMarkers(): L.Marker[];
     getVizinhosMarkers(): L.Marker[];
+    /** Cria (se preciso) a camada de feições e a preenche. Nenhuma camada de feições existe até esta chamada. */
+    definirFeicoes(camadaId: string, feicoes: unknown[], opcoes?: OpcoesCamadaFeicoes): ResultadoFeicoes;
+    adicionarFeicao(camadaId: string, feicao: unknown, opcoes?: OpcoesCamadaFeicoes): Feicao | null;
+    /**
+     * Mescla `parcial` na feição (estilo e propriedades também). Com `opcoes.substituirPropriedades`, as `propriedades`
+     * informadas trocam as atuais por inteiro, para refletir atributos apagados no consumidor.
+     */
+    atualizarFeicao(camadaId: string, id: string, parcial: Record<string, any>, opcoes?: {
+        substituirPropriedades?: boolean;
+    }): Feicao | null;
+    /**
+     * Várias mudanças numa só regravação da camada: remove, atualiza e adiciona (nessa ordem). Adicionar um id existente
+     * substitui a feição mantendo a posição. Devolve contagens e os ids recusados.
+     */
+    aplicarLote(camadaId: string, lote: LoteFeicoes, opcoes?: OpcoesLote): ResultadoLote;
+    removerFeicao(camadaId: string, id: string): boolean;
+    obterFeicoes(camadaId: string): Feicao[];
+    selecionarFeicoes(refs: Array<{
+        camadaId: string;
+        id: string;
+    }>, aditivo?: boolean): void;
+    selecionarFeicao(camadaId: string, id: string): void;
+    alternarSelecaoFeicao(camadaId: string, id: string): void;
+    limparSelecaoFeicoes(): void;
+    obterFeicoesSelecionadas(): Feicao[];
+    /** Edita os vértices da feição (ponto, linha ou polígono de um anel). Recusas também saem em `cad-edicao-recusada`. */
+    editarVertices(camadaId: string, id: string): ResultadoEdicao;
+    pararEdicaoVertices(): void;
+    get editandoVertices(): boolean;
+    get snapLigado(): boolean;
+    definirSnap(ligado: boolean): void;
+    alternarSnap(): void;
+    /** Camada que recebe o que for desenhado; criada na primeira feição se ainda não existir. */
+    definirCamadaDesenho(camadaId: string | null): void;
+    get camadaDesenho(): string | null;
+    definirEstiloDesenho(estilo: EstiloFeicao): void;
+    obterEstiloDesenho(): EstiloFeicao;
+    /**
+     * Ferramentas: ponto, linha, poligono, retangulo, elipse, poligono-regular, estrela, circulo, texto, caneta,
+     * medir-distancia, medir-area, dividir, selecao-laco, conta-gotas. `iniciarEm` ([lat, lon]) registra o primeiro clique.
+     */
+    definirFerramenta(nome: string | null, opcoes?: {
+        fechar?: boolean;
+        iniciarEm?: [number, number];
+    }): ResultadoFerramenta;
+    get ferramentaAtiva(): string | null;
+    limparMedicao(): void;
+    /** Vértices já colocados na figura em andamento. */
+    get nosDesenho(): number;
+    /** Desfaz o último vértice da figura em andamento; devolve se havia algo a desfazer. */
+    desfazerVerticeDesenho(): boolean;
+    /** Desliga a tecla S do snap para quem já trata a tecla; o botão e `definirSnap` seguem funcionando. */
+    definirAtalhoSnap(ligado: boolean): void;
+    gerarBuffer(camadaId: string, id: string, metros: number, opcoes?: {
+        camadaDestino?: string;
+        id?: string;
+    }): Feicao | null;
+    duplicarFeicao(camadaId: string, id: string, deslocamento?: {
+        lesteM?: number;
+        norteM?: number;
+    }, opcoes?: {
+        id?: string;
+    }): Feicao | null;
+    juntarFeicoes(camadaId: string, ids: string[], opcoes?: {
+        toleranciaM?: number;
+        id?: string;
+    }): Feicao | null;
+    zoomParaFeicao(camadaId: string, id: string): boolean;
+    zoomParaFeicoes(refs: Array<{
+        camadaId: string;
+        id: string;
+    }>): boolean;
+    /** Enquadra todas as feições das camadas de feições visíveis. */
+    ajustarTudo(): boolean;
+    /** Enquadra a camada; se estiver oculta, torna-a visível. */
+    ajustarCamada(camadaId: string): boolean;
+    get previasGlobais(): boolean;
+    definirPreviasGlobais(ligado: boolean): void;
+    alternarPreviasGlobais(): void;
+    alternarPrevia(camadaId: string, id: string): boolean | null;
+    previaSolicitada(camadaId: string, id: string): boolean;
+    /** Cursor de outro operador. Nome e cor vêm da rede: o nome é escapado e a cor só vale como #hex. */
+    atualizarCursorRemoto(usuario: UsuarioRemoto, posicao: [number, number] | {
+        lat: number;
+        lng?: number;
+        lon?: number;
+    }): boolean;
+    removerCursorRemoto(id: string): boolean;
+    limparCursoresRemotos(): void;
+    fecharPopupFeicao(): void;
+    /**
+     * Opções do popup. `copiarParaAreaDeTransferencia` (padrão `true`): a ação "copiar" também grava as coordenadas na área de
+     * transferência; com `false` só sai `cad-feicao-acao` e o consumidor decide (ex.: para mostrar o próprio aviso).
+     */
+    definirOpcoesPopup(opcoes: {
+        copiarParaAreaDeTransferencia?: boolean;
+    }): void;
+    /** Distância (px) que o auto-pan do popup mantém de barras, tabelas ou painéis laterais sobrepostos ao mapa. */
+    definirMargensPopup(margens: {
+        topo?: number;
+        base?: number;
+        esquerda?: number;
+        direita?: number;
+    }): void;
+    /**
+     * Margens (px) de barras e painéis sobrepostos ao mapa; os HUDs de desenho e de edição de vértices se centralizam
+     * na área visível. Padrão: `{ topo: 0, base: 16, esquerda: 0, direita: 0 }`. Em CSS: `--cad-hud-base`, `--cad-hud-esquerda`,
+     * `--cad-hud-direita` e `--cad-hud-topo` no host.
+     */
+    definirMargensHud(margens: {
+        topo?: number;
+        base?: number;
+        esquerda?: number;
+        direita?: number;
+    }): void;
     getMap(): L.Map | null;
     getController(): GerenciGeoMapaController;
     getLayerManager(): CanvasLayerManager;

package/dist/components/ui-lista-flutuante/lista-flutuante-posicionamento.d.ts

@@ -10,6 +10,8 @@ export declare class ListaFlutuantePosicionamento {
     constructor(host: HTMLElement, button: HTMLElement, content: HTMLElement);
     isMobileOrBottomSheet(): boolean;
     posicionar: () => void;
+    /** Com a lista já visível (medida real): abre para cima se faltar espaço embaixo e não deixa sair pela lateral. */
+    private ajustarAoViewport;
     ativarAcompanhamento(onFechar: () => void): void;
     desativarAcompanhamento(): void;
 }

package/dist/components/ui-lista-flutuante/ui-lista-flutuante.d.ts

@@ -20,6 +20,7 @@ export declare class UIListaFlutuante extends FormAssociatedElement {
     private _itens;
     private _value;
     private _defaultValue;
+    private _defaultCapturado;
     private observer;
     private posicionamento;
     private teclado;

package/dist/components/ui-modal/modal-pilha.d.ts

@@ -0,0 +1,3 @@
+export declare function empilharModal(modal: HTMLElement): void;
+export declare function desempilharModal(modal: HTMLElement): void;
+export declare function ehModalDoTopo(modal: HTMLElement): boolean;