@thibezer/ui-components-kit 2.0.0 → 2.2.0

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-seletor-mapa-base/ui-seletor-mapa-base.d.ts

@@ -26,6 +26,8 @@ export declare class UISeletorMapaBase extends SafeHTMLElement {
     set aberto(valor: boolean);
     get compacto(): boolean;
     set compacto(valor: boolean);
+    get desabilitado(): boolean;
+    set desabilitado(valor: boolean);
     get mapasBase(): MapaBaseItem[];
     definirMapasBase(novosMapas: MapaBaseItem[]): void;
     abrir(): void;
@@ -36,6 +38,7 @@ export declare class UISeletorMapaBase extends SafeHTMLElement {
     private aplicarEstadoAberto;
     private atualizarGatilho;
     private renderizarOpcoes;
+    private focarItem;
     private atualizarSelecaoVisual;
     private conectarEventos;
 }

package/dist/components/ui-tabela/tabela-atributos-sync.d.ts

@@ -5,6 +5,9 @@ export interface ContextoAtributosTabela {
     loadingElement: HTMLDivElement | null;
     onTextoVazioAlterado: (texto: string) => void;
     onVirtualizarAlterado: (virtualizar: boolean) => void;
+    /** O atributo `src` foi lido (sem buscar nada); `null` = sem atributo. */
+    onSrcLido: (src: string | null) => void;
+    /** O atributo `src` mudou com o elemento conectado: busca os dados. */
     onCarregarSrc: (src: string) => void;
     onCarregandoAlterado: (carregando: boolean) => void;
     onRenderBody: () => void;

package/dist/components/ui-tabela/tabela-localizador.d.ts

@@ -1,4 +1,11 @@
+/** Converte `idOuIndice` em índice de linha válido, ou -1. Aceita número inteiro ou string só com dígitos. */
+export declare function interpretarIndice(idOuIndice: string | number, total: number): number;
 /**
  * Localiza o índice de um item pelo ID, chave customizada, predicado funcional ou índice direto.
+ *
+ * Ordem de busca: predicado → chave configurada (`chaveId`) em todos os itens → chaves
+ * alternativas (`id`, `_id`, `codigo`, `key`), uma de cada vez → índice numérico.
+ * Assim um item cujo `codigo` coincide com o valor nunca "rouba" o item da chave configurada.
+ * Com `porIndice`, o valor é tratado apenas como índice de linha (sem ambiguidade com IDs numéricos).
  */
-export declare function localizarIndiceItem(dados: Record<string, any>[], idOuIndice: string | number | ((item: any, idx: number) => boolean), chaveId?: string): number;
+export declare function localizarIndiceItem(dados: Record<string, any>[], idOuIndice: string | number | ((item: any, idx: number) => boolean), chaveId?: string, porIndice?: boolean): number;

package/dist/components/ui-tabela/tabela-orquestrador-dados.d.ts

@@ -5,6 +5,9 @@ export declare class TabelaOrquestradorDados {
     private colunaOrdenada;
     private direcaoOrdenacao;
     private ultimoFiltro;
+    /** Colunas declaradas: o filtro olha só elas (vazio = todos os campos do registro). */
+    private colunasFiltro;
+    setColunasFiltro(ids: string[]): void;
     getDadosOriginais(): Record<string, any>[];
     setDadosOriginais(dados: Record<string, any>[]): void;
     getDadosExibicao(): Record<string, any>[];
@@ -13,6 +16,7 @@ export declare class TabelaOrquestradorDados {
     getDirecaoOrdenacao(): 'asc' | 'desc' | 'original';
     setDirecaoOrdenacao(dir: 'asc' | 'desc' | 'original'): void;
     alternarOrdenacaoColuna(coluna: TabelaColuna): UISortDetail | null;
+    /** Recalcula a lista exibida: ordenação da coluna e, por cima, o filtro vigente (os dois valem juntos). */
     aplicarOrdenacao(): void;
     filtrar(termo: string): void;
 }

package/dist/components/ui-tabela/tabela-selecao.d.ts

@@ -1,27 +1,37 @@
 import { UIRowScrollOptions } from './tipos';
+/**
+ * Contexto lido sob demanda (getters): dados, chave e tbody sempre refletem o estado atual da tabela,
+ * mesmo após ordenar, filtrar, trocar dados ou mudar `chave-id`.
+ */
 export interface ContextoTabelaSelecao {
     host: HTMLElement;
-    tbodyElement: HTMLTableSectionElement | null;
-    containerElement: HTMLDivElement | null;
-    dadosExibicao: Record<string, any>[];
-    chaveId: string;
-    getRowHeight: () => number;
-    onRenderBody: () => void;
+    getTbody: () => HTMLTableSectionElement | null;
+    getDadosExibicao: () => Record<string, any>[];
+    getDadosOriginais: () => Record<string, any>[];
+    getChaveId: () => string;
+    /** Posiciona a linha exibida `indice` na área visível; retorna false se a tabela ainda não foi montada. */
+    onRolarParaIndice: (indice: number, comportamento: 'smooth' | 'auto') => boolean;
+    /** Chamado quando uma seleção programática muda a linha ativa (foco móvel do teclado). */
+    onLinhaAtiva: (indice: number) => void;
 }
 export declare class TabelaSelecaoController {
     private ctx;
     private itemSelecionado;
     private indiceSelecionado;
     constructor(ctx: ContextoTabelaSelecao);
+    /** Mesmo objeto ou mesmo valor na chave configurada. */
+    private indiceDoItem;
     getItemSelecionado(): Record<string, any> | null;
     setItemSelecionado(item: Record<string, any> | null): void;
     getIndiceSelecionado(): number | null;
     setIndiceSelecionado(idx: number | null): void;
     /**
-     * Reaplica uma seleção anterior após ordenar, filtrar ou trocar os dados:
-     * mantém o item se ele (ou outro com a mesma chave) ainda estiver na exibição.
+     * Reaplica a seleção após ordenar, filtrar ou trocar os dados.
+     * - Item ainda exibido: atualiza o índice (e a referência, se veio um objeto novo com a mesma chave).
+     * - Item só escondido pelo filtro: mantém a seleção (sem índice) para reaparecer ao limpar o filtro.
+     * - Item removido dos dados: limpa a seleção e emite `ui-selecao-removida`.
      */
-    restaurarSelecao(item: Record<string, any>): void;
+    reconciliar(): void;
     limparSelecao(): void;
     isItemSelecionado(item: Record<string, any>, index: number): boolean;
     atualizarLinhasSelecionadas(): void;

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

@@ -24,4 +24,10 @@ export interface UIColumnResizeDetail {
 export interface UIRowScrollOptions {
     comportamento?: 'smooth' | 'auto';
     selecionar?: boolean;
+    /** Trata o valor apenas como índice da linha exibida, nunca como ID (evita ambiguidade com IDs numéricos). */
+    porIndice?: boolean;
+}
+export interface UISelecaoRemovidaDetail {
+    /** Item que estava selecionado e deixou de existir nos dados. */
+    item: Record<string, any>;
 }

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

@@ -1,6 +1,6 @@
-import { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions } from './tipos';
+import { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions, UISelecaoRemovidaDetail } from './tipos';
 import { SafeHTMLElement } from '../../core/ssr-safe';
-export type { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions };
+export type { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions, UISelecaoRemovidaDetail };
 export declare class UITabela extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private shadow;
@@ -23,6 +23,10 @@ export declare class UITabela extends SafeHTMLElement {
     private _corpoListeners;
     /** Linha com o foco móvel (navegação por teclado); null = primeira linha visível. */
     private _indiceAtivo;
+    /** Altura real das linhas medida no DOM; null = usa a estimativa da densidade. */
+    private _alturaLinhaMedida;
+    /** Cancela a correção pendente de uma rolagem suave anterior. */
+    private _cancelarCorrecaoRolagem;
     private remotaController;
     private selecaoController;
     private dadosController;
@@ -66,11 +70,25 @@ export declare class UITabela extends SafeHTMLElement {
     get textoVazio(): string;
     set textoVazio(txt: string);
     private handleHeaderClick;
+    /** Altura fixa das linhas em px (`altura-linha`), sobrepõe a densidade; null = vale a densidade. */
+    get alturaLinha(): number | null;
+    set alturaLinha(val: number | null);
+    /** Publica a altura fixa como variável CSS (usada pelo estilo `:host([altura-linha])`). */
+    private aplicarAlturaLinha;
+    /** Altura usada na virtualização: a fixa (`altura-linha`), a medida no DOM ou a estimativa da densidade. */
     private getRowHeight;
+    /**
+     * Mede a altura real das linhas uma vez por configuração (densidade/colunas): padding, fonte e
+     * renderizadores customizados mudam a altura, e a estimativa fixa desalinharia a janela virtual.
+     * Não remede a cada rolagem para os espaçadores não "pularem" com linhas de alturas diferentes.
+     */
+    private medirAlturaLinha;
+    /** Ordenar, filtrar, trocar os dados ou a chave mantém a linha selecionada (se ainda existir). */
     private atualizarContextoSelecao;
     renderTotal(): void;
     /** Mantém um único tabindex=0 (foco móvel): Tab entra na tabela pela última linha ativa. */
     private handleFocoLinha;
+    private definirLinhaAtiva;
     /**
      * Teclado nas linhas: setas, Home/End e PageUp/PageDown movem o foco;
      * Enter/Espaço selecionam a linha (mesmo caminho do clique, emite `ui-linha-clique`).
@@ -79,10 +97,31 @@ export declare class UITabela extends SafeHTMLElement {
     private linhasPorPagina;
     /** Foca a linha, renderizando a janela virtual se necessário, e a mantém visível abaixo do cabeçalho fixo. */
     private focarLinha;
+    /**
+     * Quanto o container precisa rolar para a linha ficar inteira na área útil: abaixo do cabeçalho
+     * fixo e acima da barra de rolagem horizontal. 0 = já visível. Linha maior que a área alinha pelo topo.
+     */
+    private deslocamentoAteLinha;
+    /** Rola só o container da tabela (nunca a página, ao contrário de `scrollIntoView`). */
+    private rolarContainer;
+    /**
+     * Posiciona a linha exibida `indice` na área visível.
+     * Fora da janela virtual, rola até a posição estimada, renderiza a janela e corrige pela posição
+     * real da linha. No modo suave a correção ocorre ao fim da animação (`scrollend`, com timeout de
+     * segurança para navegadores sem o evento ou quando não há rolagem a fazer).
+     */
+    private posicionarLinha;
     private obterContextoRenderizador;
     private renderHeader;
     renderBody(): void;
+    /**
+     * Rola até um item e opcionalmente o seleciona. Aceita ID (pela `chave-id`, depois `id`, `_id`,
+     * `codigo`, `key`), predicado ou índice. Um número é procurado primeiro como ID; use
+     * `{ porIndice: true }` ou `rolarParaIndice()` para tratá-lo só como índice da linha exibida.
+     */
     rolarPara(idOuIndice: string | number | ((item: any, index: number) => boolean), opcoes?: UIRowScrollOptions): boolean;
+    /** Rola até a linha exibida de índice `indice` (posição após ordenação/filtro, base 0). */
+    rolarParaIndice(indice: number, opcoes?: Omit<UIRowScrollOptions, 'porIndice'>): boolean;
 }
 export * from './tabela-ordenacao';
 export * from './tabela-localizador';

package/dist/components/ui-tabela-propriedades/avaliador-expressao.d.ts

@@ -1,6 +1 @@
-/**
- * Avaliador de expressões matemáticas para campos numéricos técnicos (AutoCAD / Revit / Blender).
- * Parser seguro de descida recursiva sem eval(), com suporte a +, -, *, /, ^, parênteses,
- * porcentagens, constantes (pi, e) e funções matemáticas (sqrt, abs, round, floor, ceil, sin, cos, tan).
- */
 export declare function avaliarExpressaoMatematica(expr: string): number | null;

package/dist/components/ui-tabela-propriedades/propriedades-dom-utils.d.ts

@@ -1,6 +1,22 @@
 import { CategoriaPropriedades } from './tipos';
-export declare function focarProximoEditor(shadow: ShadowRoot, atual: HTMLElement): void;
+/**
+ * Linha de uma propriedade. Compara o atributo em vez de montar um seletor CSS com o id:
+ * ids com aspas, colchetes ou barras não quebram a consulta.
+ */
+export declare function buscarLinhaPropriedade(raiz: ParentNode | null | undefined, propId: string): HTMLElement | null;
+/** Cada editor registra como refletir um novo valor (usado por `definirValor` e pelo scrubber). */
+export declare function registrarAtualizadorEditor(editor: Element, atualizar: (valor: any) => void): void;
+/**
+ * Atualiza o editor na tela para o novo valor, qualquer que seja o tipo (texto, número, seleção,
+ * booleano, cores, linha). Não recria a linha: preserva foco e arrastos em andamento.
+ */
 export declare function atualizarCampoVisual(shadow: ShadowRoot, propId: string, novoValor: any): void;
+/**
+ * Seleciona a opção correspondente ao valor. Valor fora da lista ganha uma opção própria
+ * (`data-externa`) em vez de o select exibir a primeira opção como se fosse o valor real.
+ */
+export declare function sincronizarSelect(select: HTMLSelectElement, valor: any, corresponde?: (opcao: string, valor: any) => boolean, rotuloExterno?: (valor: any) => string): void;
+export declare function focarProximoEditor(shadow: ShadowRoot, atual: HTMLElement): void;
 export declare function expandirTodasCategorias(shadow: ShadowRoot, categorias: CategoriaPropriedades[]): void;
 export declare function colapsarTodasCategorias(shadow: ShadowRoot, categorias: CategoriaPropriedades[]): void;
 export declare function alternarCategoria(shadow: ShadowRoot, host: HTMLElement, categorias: CategoriaPropriedades[], idCategoria: string): void;

package/dist/components/ui-tabela-propriedades/propriedades-flutuante.d.ts

@@ -1,6 +1,8 @@
 import { ListenerBag } from '../../core/listener-bag';
 /**
  * Aplica ao host o posicionamento flutuante (fixed) ou o restaura ao fluxo normal.
+ * Ao acoplar, devolve a largura/altura originais (o painel não fica preso em 300×480);
+ * ao flutuar de novo, volta à última posição e tamanho flutuantes.
  * Retorna o novo estado (true = flutuante).
  */
 export declare function alternarPosicionamentoFlutuante(host: HTMLElement): boolean;

package/dist/components/ui-tabela-propriedades/propriedades-gerenciador-valores.d.ts

@@ -7,20 +7,29 @@ export interface ContextoGerenciadorValores {
     onRenderCategorias: () => void;
     isModoManual: () => boolean;
 }
+/** Igualdade de valores de propriedade: estrita, com null/undefined equivalentes e NaN igual a NaN. */
+export declare function valoresIguais(a: any, b: any): boolean;
 export declare class GerenciadorValoresPropriedades {
     private ctx;
     private valoresOriginais;
     private valoresAtuais;
-    private dirty;
     constructor(ctx: ContextoGerenciadorValores);
     inicializarCategorias(categorias: CategoriaPropriedades[]): void;
+    /** Há alguma propriedade com valor diferente do original (último aplicar/carregar)? */
     get isDirty(): boolean;
+    isModificada(propId: string): boolean;
     getValores(): Record<string, any>;
+    getValoresOriginais(): Record<string, any>;
     setValores(novosValores: Record<string, any>): void;
     obterValor(propId: string): any;
+    /** Alteração programática: atualiza o editor na tela; não emite se o valor não mudou. */
     definirValor(propId: string, novoValor: any, emitirEvento?: boolean): void;
+    /** Alteração feita pelo usuário num editor. Em modo manual só emite no Aplicar. */
     registrarAlteracao(categoriaId: string, propId: string, novoValor: any): void;
     aplicar(): void;
     desfazer(): void;
+    /** Marca/desmarca a linha e recalcula os botões do rodapé (voltar ao original limpa o estado). */
+    private aposAlterar;
+    private categoriaDe;
     private emitirAlteracao;
 }

package/dist/components/ui-tabela-propriedades/propriedades-render-arvore.d.ts

@@ -2,8 +2,10 @@ import { ItemPropriedade, CategoriaPropriedades } from './tipos';
 import { ContextoEditorPropriedade } from './propriedades-editores';
 export interface ContextoLinhaPropriedade {
     valoresAtuais: Record<string, any>;
+    /** Valores do último carregar/aplicar: a linha é marcada como modificada quando difere deles. */
     valoresOriginais: Record<string, any>;
-    isDirty: boolean;
+    /** @deprecated Não é mais usado: o destaque compara cada valor com o original. */
+    isDirty?: boolean;
     editorCtx: ContextoEditorPropriedade;
     onAtualizarCampoVisual: (propId: string, novoValor: any) => void;
 }

package/dist/components/ui-tabela-propriedades/ui-tabela-propriedades.d.ts

@@ -32,7 +32,11 @@ export declare class UITabelaPropriedades extends SafeHTMLElement {
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
-    attributeChangedCallback(name: string, _oldVal: string | null, newVal: string | null): void;
+    /**
+     * Cada atributo atualiza só o que depende dele: redesenhar todas as linhas (ex.: ao trocar o
+     * `titulo`) tiraria o foco de um campo em edição.
+     */
+    attributeChangedCallback(name: string, oldVal: string | null, newVal: string | null): void;
     get categorias(): CategoriaPropriedades[];
     set categorias(novasCategorias: CategoriaPropriedades[]);
     get tipos(): SeletorTipoItem[];

package/dist/core/alvo-digitavel.d.ts

@@ -0,0 +1 @@
+export declare function focoEmCampoDeTexto(evento?: Event): boolean;

package/dist/core/index.d.ts

@@ -5,3 +5,4 @@ export * from './leaflet-loader';
 export * from './ssr-safe';
 export * from './form-validacao';
 export * from './acessibilidade';
+export * from './svg-seguro';

package/dist/core/svg-seguro.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Higienização de ícones SVG vindos de dados (props, APIs, configuração do usuário).
+ *
+ * Lista de permissão de elementos: tudo fora dela é removido com o conteúdo — inclusive
+ * `script`, `foreignObject`, `a`, `image`, `animate`/`set` (que podem reescrever `href`)
+ * e `style`. Atributos `on*` são removidos; `href` só aceita referências locais (`#id`);
+ * valores com `javascript:`/`data:`/`vbscript:` ou `url()` externo são descartados.
+ */
+/** Retorna o `<svg>` higienizado (já pronto para inserir no DOM) ou null se não houver SVG. */
+export declare function higienizarSvg(codigo: string): SVGSVGElement | null;

package/dist/core.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./zero-js-triggers-C_gtaojZ.cjs"),i=require("./listener-bag-D5omxZ9h.cjs"),t=require("./leaflet-loader-94z5VsdY.cjs"),o=require("./ssr-safe-CiHD1adl.cjs"),e=require("./form-validacao-ytRYSF3E.cjs");typeof document<"u"&&r.initZeroJSTriggers();exports.UIBus=r.UIBus;exports.initZeroJSTriggers=r.initZeroJSTriggers;exports.ListenerBag=i.ListenerBag;exports.carregarLeaflet=t.carregarLeaflet;exports.obterLeafletSincrono=t.obterLeafletSincrono;exports.SafeHTMLElement=o.SafeHTMLElement;exports.definirCustomElement=o.definirCustomElement;exports.isBrowser=o.isBrowser;exports.aplicarValidadeInternals=e.aplicarValidadeInternals;exports.cliqueVeioDeRotuloExterno=e.cliqueVeioDeRotuloExterno;exports.gerarIdUnico=e.gerarIdUnico;exports.obterRotuloExterno=e.obterRotuloExterno;exports.validarRestricoesCampoTexto=e.validarRestricoesCampoTexto;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./zero-js-triggers-C_gtaojZ.cjs"),t=require("./listener-bag-D5omxZ9h.cjs"),i=require("./leaflet-loader-94z5VsdY.cjs"),o=require("./ssr-safe-CiHD1adl.cjs"),e=require("./form-validacao-ytRYSF3E.cjs"),a=require("./svg-seguro-C76iLlAZ.cjs");typeof document<"u"&&r.initZeroJSTriggers();exports.UIBus=r.UIBus;exports.initZeroJSTriggers=r.initZeroJSTriggers;exports.ListenerBag=t.ListenerBag;exports.carregarLeaflet=i.carregarLeaflet;exports.obterLeafletSincrono=i.obterLeafletSincrono;exports.SafeHTMLElement=o.SafeHTMLElement;exports.definirCustomElement=o.definirCustomElement;exports.isBrowser=o.isBrowser;exports.aplicarValidadeInternals=e.aplicarValidadeInternals;exports.cliqueVeioDeRotuloExterno=e.cliqueVeioDeRotuloExterno;exports.gerarIdUnico=e.gerarIdUnico;exports.obterRotuloExterno=e.obterRotuloExterno;exports.validarRestricoesCampoTexto=e.validarRestricoesCampoTexto;exports.higienizarSvg=a.higienizarSvg;

package/dist/core.js

@@ -1,22 +1,24 @@
 import { i as e } from "./zero-js-triggers-C_KrvFOQ.js";
 import { U as t } from "./zero-js-triggers-C_KrvFOQ.js";
-import { L as i } from "./listener-bag-DQgv7OON.js";
+import { L as s } from "./listener-bag-DQgv7OON.js";
 import { c as f, o as m } from "./leaflet-loader-Cjcdgj5R.js";
-import { S as p, d as c, i as d } from "./ssr-safe-5cWfJP-s.js";
-import { a as u, c as g, g as L, o as E, v as S } from "./form-validacao-BIOXxt-1.js";
+import { S as p, d as x, i as c } from "./ssr-safe-5cWfJP-s.js";
+import { a as g, c as u, g as L, o as S, v as E } from "./form-validacao-BIOXxt-1.js";
+import { h as B } from "./svg-seguro-BsbNQqpd.js";
 typeof document < "u" && e();
 export {
-  i as ListenerBag,
+  s as ListenerBag,
   p as SafeHTMLElement,
   t as UIBus,
-  u as aplicarValidadeInternals,
+  g as aplicarValidadeInternals,
   f as carregarLeaflet,
-  g as cliqueVeioDeRotuloExterno,
-  c as definirCustomElement,
+  u as cliqueVeioDeRotuloExterno,
+  x as definirCustomElement,
   L as gerarIdUnico,
+  B as higienizarSvg,
   e as initZeroJSTriggers,
-  d as isBrowser,
+  c as isBrowser,
   m as obterLeafletSincrono,
-  E as obterRotuloExterno,
-  S as validarRestricoesCampoTexto
+  S as obterRotuloExterno,
+  E as validarRestricoesCampoTexto
 };