@thibezer/ui-components-kit 2.0.0 → 2.1.0

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