@thibezer/ui-components-kit 1.0.0

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

@@ -0,0 +1,18 @@
+import { TabelaColuna } from './tipos';
+import { ListenerBag } from '../../core/listener-bag';
+export interface ContextoHeaderTabela {
+    theadElement: HTMLTableSectionElement | null;
+    colgroupElement: HTMLTableColElement | null;
+    colunas: TabelaColuna[];
+    colunaOrdenada: string | null;
+    direcaoOrdenacao: 'asc' | 'desc' | 'original';
+    headerListeners: ListenerBag;
+    formatWidth: (largura?: string | number) => string;
+    getAlignmentClass: (alinhamento?: string) => string;
+    getTextAlign: (alinhamento?: string) => string;
+    onHeaderClick: (coluna: TabelaColuna) => void;
+    onHeaderContextMenu: (e: MouseEvent, coluna: TabelaColuna, colIndex: number, th: HTMLTableCellElement) => void;
+    onInitColumnResize: (e: MouseEvent, coluna: TabelaColuna, colIndex: number, th: HTMLTableCellElement, resizer: HTMLDivElement) => void;
+    onColumnAutoFit: (coluna: TabelaColuna, th: HTMLTableCellElement, col: HTMLTableColElement) => void;
+}
+export declare function renderizarHeaderTabela(ctx: ContextoHeaderTabela): void;

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

@@ -0,0 +1,9 @@
+import { TabelaColuna } from './tipos';
+export interface ContextoTabelaInteracao {
+    host: HTMLElement;
+    colgroupElement: HTMLTableColElement | null;
+    shadow: ShadowRoot;
+    onSetIsResizing: (resizing: boolean) => void;
+}
+export declare function executarRedimensionamentoColuna(e: MouseEvent, coluna: TabelaColuna, colIndex: number, thElement: HTMLTableCellElement, resizer: HTMLDivElement, ctx: ContextoTabelaInteracao): (() => void) | null;
+export declare function abrirPopoverRedimensionamento(e: MouseEvent, coluna: TabelaColuna, colIndex: number, thElement: HTMLTableCellElement, ctx: ContextoTabelaInteracao): void;

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

@@ -0,0 +1,4 @@
+/**
+ * Localiza o índice de um item pelo ID, chave customizada, predicado funcional ou índice direto.
+ */
+export declare function localizarIndiceItem(dados: Record<string, any>[], idOuIndice: string | number | ((item: any, idx: number) => boolean), chaveId?: string): number;

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

@@ -0,0 +1,12 @@
+import { UISortDetail } from './tipos';
+/**
+ * Alterna ciclicamente a ordenação tri-state:
+ * Primeira vez -> 'asc'
+ * Segunda vez -> 'desc'
+ * Terceira vez -> 'original' (reseta)
+ */
+export declare function alternarDirecaoOrdenacao(colunaAtual: string | null, direcaoAtual: 'asc' | 'desc' | 'original', colunaClicada: string): UISortDetail;
+/**
+ * Ordena os dados em memória respeitando valores nulos/undefined, números e strings com collation pt-BR.
+ */
+export declare function aplicarOrdenacaoTabela(dadosOriginais: Record<string, any>[], colunaOrdenada: string | null, direcao: 'asc' | 'desc' | 'original'): Record<string, any>[];

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

@@ -0,0 +1,18 @@
+import { TabelaColuna, UISortDetail } from './tipos';
+export declare class TabelaOrquestradorDados {
+    private dadosOriginais;
+    private dadosExibicao;
+    private colunaOrdenada;
+    private direcaoOrdenacao;
+    private ultimoFiltro;
+    getDadosOriginais(): Record<string, any>[];
+    setDadosOriginais(dados: Record<string, any>[]): void;
+    getDadosExibicao(): Record<string, any>[];
+    getColunaOrdenada(): string | null;
+    setColunaOrdenada(id: string | null): void;
+    getDirecaoOrdenacao(): 'asc' | 'desc' | 'original';
+    setDirecaoOrdenacao(dir: 'asc' | 'desc' | 'original'): void;
+    alternarOrdenacaoColuna(coluna: TabelaColuna): UISortDetail | null;
+    aplicarOrdenacao(): void;
+    filtrar(termo: string): void;
+}

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

@@ -0,0 +1,28 @@
+import { TabelaColuna } from './tipos';
+export interface IniciarRedimensionamentoContexto {
+    evento: MouseEvent;
+    coluna: TabelaColuna;
+    colIndex: number;
+    thElement: HTMLTableCellElement;
+    resizer: HTMLDivElement;
+    colgroupElement: HTMLTableColElement | null;
+    onResizeStart: () => void;
+    onResizeEnd: (larguraFinal: string) => void;
+}
+/**
+ * Gerencia o ciclo de eventos de drag-to-resize de uma coluna da tabela.
+ */
+export declare function iniciarRedimensionamentoColuna(ctx: IniciarRedimensionamentoContexto): () => void;
+export interface ExibirPromptPopoverContexto {
+    evento: MouseEvent;
+    coluna: TabelaColuna;
+    colIndex: number;
+    thElement: HTMLTableCellElement;
+    colgroupElement: HTMLTableColElement | null;
+    shadow: ShadowRoot;
+    onResizeEnd: (larguraFinal: string) => void;
+}
+/**
+ * Exibe o diálogo popover para ajuste numérico preciso da largura da coluna.
+ */
+export declare function exibirPromptPopoverRedimensionamento(ctx: ExibirPromptPopoverContexto): void;

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

@@ -0,0 +1,15 @@
+/**
+ * Gerenciador de requisições remotas para <ui-tabela> (endpoint JSON)
+ */
+export interface ContextoTabelaRemota {
+    host: HTMLElement;
+    onCarregandoAlterado: (carregando: boolean) => void;
+    onDadosRecebidos: (dados: Record<string, any>[]) => void;
+}
+export declare class TabelaRemotaController {
+    private ctx;
+    private autoFetchController;
+    constructor(ctx: ContextoTabelaRemota);
+    carregar(endpoint: string): Promise<void>;
+    abortar(): void;
+}

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

@@ -0,0 +1,29 @@
+import { TabelaColuna } from './tipos';
+import { ListenerBag } from '../../core/listener-bag';
+import { EstruturaDOMElementos } from './tabela-dom';
+import { TabelaOrquestradorDados } from './tabela-orquestrador-dados';
+import { TabelaSelecaoController } from './tabela-selecao';
+export interface ContextoOrquestradorRender {
+    host: HTMLElement;
+    shadow: ShadowRoot;
+    theadElement: HTMLTableSectionElement | null;
+    colgroupElement: HTMLTableColElement | null;
+    tbodyElement: HTMLTableSectionElement | null;
+    tableElement: HTMLTableElement | null;
+    emptyElement: HTMLDivElement | null;
+    containerElement: HTMLDivElement | null;
+    colunas: TabelaColuna[];
+    dadosController: TabelaOrquestradorDados;
+    selecaoController: TabelaSelecaoController;
+    headerListeners: ListenerBag;
+    chaveId: string;
+    virtualizar: boolean;
+    rowHeight: number;
+    onSetIsResizing: (resizing: boolean) => void;
+    onActiveResizeCleanup: (cleanup: (() => void) | null) => void;
+    onHeaderClick: (col: TabelaColuna) => void;
+}
+export declare function executarOrquestracaoHeader(ctx: ContextoOrquestradorRender): void;
+export declare function executarOrquestracaoCorpo(ctx: ContextoOrquestradorRender): void;
+export declare function inicializarScrollVirtualizacao(container: HTMLElement, onRenderBody: () => void): (e: Event) => void;
+export declare function orquestrarEstruturaInicial(shadow: ShadowRoot, textoVazio: string, maxHeight: string | null, carregando: boolean): EstruturaDOMElementos;

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

@@ -0,0 +1,24 @@
+import { UIRowScrollOptions } from './tipos';
+export interface ContextoTabelaSelecao {
+    host: HTMLElement;
+    tbodyElement: HTMLTableSectionElement | null;
+    containerElement: HTMLDivElement | null;
+    dadosExibicao: Record<string, any>[];
+    chaveId: string;
+    getRowHeight: () => number;
+    onRenderBody: () => void;
+}
+export declare class TabelaSelecaoController {
+    private ctx;
+    private itemSelecionado;
+    private indiceSelecionado;
+    constructor(ctx: ContextoTabelaSelecao);
+    getItemSelecionado(): Record<string, any> | null;
+    setItemSelecionado(item: Record<string, any> | null): void;
+    getIndiceSelecionado(): number | null;
+    setIndiceSelecionado(idx: number | null): void;
+    limparSelecao(): void;
+    isItemSelecionado(item: Record<string, any>, index: number): boolean;
+    atualizarLinhasSelecionadas(): void;
+    rolarPara(idOuIndice: string | number | ((item: any, index: number) => boolean), opcoes?: UIRowScrollOptions): boolean;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Tipos e interfaces de configuração para a Tabela Técnica de Alta Densidade (<ui-tabela>).
+ */
+export type DensidadeTabela = 'compacta' | 'normal' | 'relaxada';
+export interface TabelaColuna<T = any> {
+    id: string;
+    rotulo: string;
+    largura?: string | number;
+    larguraMinima?: string | number;
+    larguraMaxima?: string | number;
+    alinhamento?: 'esquerda' | 'centro' | 'direita' | 'left' | 'center' | 'right';
+    ordenavel?: boolean;
+    tooltip?: string;
+    render?: (valor: any, item: T, index: number) => HTMLElement | string;
+}
+export interface UISortDetail {
+    idColuna: string | null;
+    direcao: 'asc' | 'desc' | 'original';
+}
+export interface UIColumnResizeDetail {
+    idColuna: string;
+    largura: string;
+}
+export interface UIRowScrollOptions {
+    comportamento?: 'smooth' | 'auto';
+    selecionar?: boolean;
+}

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

@@ -0,0 +1,83 @@
+import { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions } from './tipos';
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export type { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions };
+export declare class UITabela extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private shadow;
+    private _colunas;
+    private _textoVazio;
+    private _virtualizar;
+    private _isResizing;
+    private _carregando;
+    private _src;
+    private _containerElement;
+    private _tableElement;
+    private _theadElement;
+    private _tbodyElement;
+    private _colgroupElement;
+    private _emptyElement;
+    private _loadingElement;
+    private _scrollHandler;
+    private _activeResizeCleanup;
+    private _headerListeners;
+    private remotaController;
+    private selecaoController;
+    private dadosController;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _oldVal: string | null, newVal: string | null): void;
+    private syncAttributes;
+    private obterContextoAtributos;
+    get src(): string | null;
+    set src(val: string | null);
+    get carregando(): boolean;
+    set carregando(val: boolean);
+    carregarDoEndpoint(url?: string): Promise<void>;
+    recarregar(): Promise<void>;
+    filtrar(termo: string): void;
+    private cleanupEventListeners;
+    get colunas(): TabelaColuna[];
+    set colunas(val: TabelaColuna[]);
+    get dados(): Record<string, any>[];
+    set dados(val: Record<string, any>[]);
+    get itens(): Record<string, any>[];
+    set itens(val: Record<string, any>[]);
+    get chaveId(): string;
+    set chaveId(val: string);
+    get itemSelecionado(): Record<string, any> | null;
+    set itemSelecionado(item: Record<string, any> | null);
+    get indiceSelecionado(): number | null;
+    set indiceSelecionado(idx: number | null);
+    limparSelecao(): void;
+    get densidade(): DensidadeTabela;
+    set densidade(val: DensidadeTabela);
+    get virtualizar(): boolean;
+    set virtualizar(val: boolean);
+    get colunaOrdenada(): string | null;
+    set colunaOrdenada(id: string | null);
+    get direcaoOrdenacao(): 'asc' | 'desc' | 'original';
+    set direcaoOrdenacao(dir: 'asc' | 'desc' | 'original');
+    get textoVazio(): string;
+    set textoVazio(txt: string);
+    private handleHeaderClick;
+    private getRowHeight;
+    private atualizarContextoSelecao;
+    renderTotal(): void;
+    private obterContextoRenderizador;
+    private renderHeader;
+    renderBody(): void;
+    rolarPara(idOuIndice: string | number | ((item: any, index: number) => boolean), opcoes?: UIRowScrollOptions): boolean;
+}
+export * from './tabela-ordenacao';
+export * from './tabela-localizador';
+export * from './tabela-redimensionamento';
+export * from './tabela-header';
+export * from './tabela-corpo';
+export * from './tabela-remota';
+export * from './tabela-selecao';
+export * from './tabela-orquestrador-dados';
+export * from './tabela-interacao';
+export * from './tabela-dom';
+export * from './tabela-renderizador';
+export * from './tabela-atributos-sync';

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

@@ -0,0 +1,6 @@
+/**
+ * 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/editores-basicos.d.ts

@@ -0,0 +1,7 @@
+import { ItemPropriedade, ContextoEditorPropriedade } from './tipos';
+export declare function criarEditorReadonly(valorAtual: any): HTMLElement;
+export declare function criarEditorBooleano(categoriaId: string, prop: ItemPropriedade, valorAtual: any, ctx: ContextoEditorPropriedade): HTMLElement;
+export declare function criarEditorSelecao(categoriaId: string, prop: ItemPropriedade, valorAtual: any, ctx: ContextoEditorPropriedade): HTMLElement;
+export declare function criarEditorAcao(categoriaId: string, prop: ItemPropriedade, ctx: ContextoEditorPropriedade): HTMLElement;
+export declare function criarEditorNumero(categoriaId: string, prop: ItemPropriedade, valorAtual: any, ctx: ContextoEditorPropriedade): HTMLElement;
+export declare function criarEditorTexto(categoriaId: string, prop: ItemPropriedade, valorAtual: any, ctx: ContextoEditorPropriedade): HTMLElement;

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

@@ -0,0 +1,17 @@
+import { ItemPropriedade, ContextoEditorPropriedade } from './tipos';
+/**
+ * Editor Tipo de Linha CAD (Linetype com preview SVG em tempo real)
+ */
+export declare function criarEditorLinetype(categoriaId: string, prop: ItemPropriedade, valorAtual: any, ctx: ContextoEditorPropriedade): HTMLElement;
+/**
+ * Editor Espessura de Linha CAD (Lineweight com espessura SVG proporcional)
+ */
+export declare function criarEditorLineweight(categoriaId: string, prop: ItemPropriedade, valorAtual: any, ctx: ContextoEditorPropriedade): HTMLElement;
+/**
+ * Editor Cor CAD (ByLayer, ByBlock, Cores Indexadas ACI e Hexadecimal)
+ */
+export declare function criarEditorCorCad(categoriaId: string, prop: ItemPropriedade, valorAtual: any, ctx: ContextoEditorPropriedade): HTMLElement;
+/**
+ * Editor Cor Padrão (Swatch com Color Picker Nativo)
+ */
+export declare function criarEditorCorSwatch(categoriaId: string, prop: ItemPropriedade, valorAtual: any, ctx: ContextoEditorPropriedade): HTMLElement;

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

@@ -0,0 +1,6 @@
+export * from './tipos';
+export * from './avaliador-expressao';
+export * from './propriedades-editores';
+export * from './propriedades-seletor-tipo';
+export * from './propriedades-splitter';
+export * from './ui-tabela-propriedades';

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

@@ -0,0 +1,5 @@
+export type DensidadePropriedades = 'padrao' | 'compacta' | 'ultracompacta' | 'relaxada';
+/**
+ * Próxima densidade no ciclo do botão: padrao -> compacta -> ultracompacta -> padrao
+ */
+export declare function proximaDensidade(atual: string): DensidadePropriedades;

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

@@ -0,0 +1,6 @@
+import { CategoriaPropriedades } from './tipos';
+export declare function focarProximoEditor(shadow: ShadowRoot, atual: HTMLElement): void;
+export declare function atualizarCampoVisual(shadow: ShadowRoot, propId: string, novoValor: any): 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-editores.d.ts

@@ -0,0 +1,5 @@
+import { ItemPropriedade, ContextoEditorPropriedade } from './tipos';
+export * from './editores-basicos';
+export * from './editores-cad';
+export type { ContextoEditorPropriedade } from './tipos';
+export declare function criarEditorValor(categoriaId: string, prop: ItemPropriedade, valorAtual: any, ctx: ContextoEditorPropriedade): HTMLElement;

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

@@ -0,0 +1,7 @@
+import { ListenerBag } from '../../core/listener-bag';
+/**
+ * Aplica ao host o posicionamento flutuante (fixed) ou o restaura ao fluxo normal.
+ * Retorna o novo estado (true = flutuante).
+ */
+export declare function alternarPosicionamentoFlutuante(host: HTMLElement): boolean;
+export declare function conectarArrastoFlutuante(host: HTMLElement, shadow: ShadowRoot, listeners: ListenerBag): void;

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

@@ -0,0 +1,26 @@
+import { CategoriaPropriedades } from './tipos';
+export interface ContextoGerenciadorValores {
+    hostElement: HTMLElement;
+    getCategorias: () => CategoriaPropriedades[];
+    onAtualizarBotoesFooter: (dirty: boolean) => void;
+    onAtualizarCampoVisual: (propId: string, novoValor: any) => void;
+    onRenderCategorias: () => void;
+    isModoManual: () => boolean;
+}
+export declare class GerenciadorValoresPropriedades {
+    private ctx;
+    private valoresOriginais;
+    private valoresAtuais;
+    private dirty;
+    constructor(ctx: ContextoGerenciadorValores);
+    inicializarCategorias(categorias: CategoriaPropriedades[]): void;
+    get isDirty(): boolean;
+    getValores(): Record<string, any>;
+    setValores(novosValores: Record<string, any>): void;
+    obterValor(propId: string): any;
+    definirValor(propId: string, novoValor: any, emitirEvento?: boolean): void;
+    registrarAlteracao(categoriaId: string, propId: string, novoValor: any): void;
+    aplicar(): void;
+    desfazer(): void;
+    private emitirAlteracao;
+}

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

@@ -0,0 +1,15 @@
+import { ListenerBag } from '../../core/listener-bag';
+export interface ContextoPainelControles {
+    shadow: ShadowRoot;
+    listeners: ListenerBag;
+    host: HTMLElement;
+    onToggleExpandirTodas: () => void;
+    onFiltrar: (termo: string) => void;
+    onAplicar: () => void;
+    onDesfazer: () => void;
+    onAlternarDensidade?: () => void;
+    onAlternarFlutuante?: () => void;
+    onAlternarColapsoHorizontal?: () => void;
+}
+export declare function conectarPainelControles(ctx: ContextoPainelControles): void;
+export declare function sincronizarPainelControles(shadow: ShadowRoot, host: HTMLElement): void;

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

@@ -0,0 +1,24 @@
+import { ItemPropriedade, CategoriaPropriedades } from './tipos';
+import { ContextoEditorPropriedade } from './propriedades-editores';
+export interface ContextoLinhaPropriedade {
+    valoresAtuais: Record<string, any>;
+    valoresOriginais: Record<string, any>;
+    isDirty: boolean;
+    editorCtx: ContextoEditorPropriedade;
+    onAtualizarCampoVisual: (propId: string, novoValor: any) => void;
+}
+export interface OpcoesRenderArvore {
+    listaContainer: HTMLElement;
+    categorias: CategoriaPropriedades[];
+    termoBusca: string;
+    onToggleCategoria: (idCategoria: string) => void;
+    linhaCtx: ContextoLinhaPropriedade;
+}
+/**
+ * Renderiza todas as categorias e suas propriedades filtradas
+ */
+export declare function renderizarCategoriasETree(opcoes: OpcoesRenderArvore): void;
+/**
+ * Cria a linha individual de uma propriedade com rótulo, scrubber e editor
+ */
+export declare function criarLinhaPropriedade(categoriaId: string, prop: ItemPropriedade, ctx: ContextoLinhaPropriedade): HTMLDivElement;

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

@@ -0,0 +1,13 @@
+import { SeletorTipoItem } from './tipos';
+export interface ContextoSeletorTipo {
+    tipoContainerElement: HTMLElement | null;
+    tipos: SeletorTipoItem[];
+    tipoSelecionadoId: string;
+    estiloVisual: string;
+    onSelecionarTipo: (id: string) => void;
+    onEditarTipo: (tipo: SeletorTipoItem) => void;
+    onQuickSelect: (tipo: SeletorTipoItem) => void;
+    onSelectObjects: (tipo: SeletorTipoItem) => void;
+    onCalculadora: (tipo: SeletorTipoItem) => void;
+}
+export declare function renderizarSeletorTipos(ctx: ContextoSeletorTipo): void;

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

@@ -0,0 +1,13 @@
+import { ListenerBag } from '../../core/listener-bag';
+export interface ContextoSplitterPropriedades {
+    splitterElement: HTMLElement | null;
+    corpoElement: HTMLElement | null;
+    hostElement: HTMLElement;
+    splitterListeners: ListenerBag;
+    onLarguraAlterada: (larguraPorcentagem: number) => void;
+}
+export interface ControladorSplitterPropriedades {
+    init: () => void;
+    definirLarguraRotulo: (porcentagem: number) => number;
+}
+export declare function criarControladorSplitter(ctx: ContextoSplitterPropriedades): ControladorSplitterPropriedades;

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

@@ -0,0 +1 @@
+export declare function criarTemplateTabelaPropriedades(): string;

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

@@ -0,0 +1,48 @@
+/**
+ * Contratos, tipos e interfaces para a Paleta Técnica de Propriedades (<ui-tabela-propriedades>).
+ */
+export type TipoPropriedade = 'texto' | 'numero' | 'selecao' | 'booleano' | 'cor' | 'cor-cad' | 'linha' | 'linetype' | 'espessura' | 'lineweight' | 'acao' | 'readonly';
+export interface OpcaoPropriedade {
+    id: string | number;
+    rotulo: string;
+}
+export interface ItemPropriedade {
+    id: string;
+    rotulo: string;
+    tipo: TipoPropriedade;
+    valor: any;
+    unidade?: string;
+    casasDecimais?: number;
+    opcoes?: OpcaoPropriedade[];
+    placeholder?: string;
+    somenteLeitura?: boolean;
+    dica?: string;
+    rotuloAcao?: string;
+    textoAmostra?: string;
+    onClickAcao?: (item: ItemPropriedade) => void;
+}
+export interface CategoriaPropriedades {
+    id: string;
+    titulo: string;
+    aberto?: boolean;
+    propriedades: ItemPropriedade[];
+}
+export interface SeletorTipoItem {
+    id: string;
+    rotulo: string;
+    subtipo?: string;
+    iconeSvg?: string;
+}
+export interface UIPropertyChangeDetail {
+    id: string;
+    categoriaId: string;
+    valor: any;
+    valorAnterior: any;
+    todosValores: Record<string, any>;
+}
+export interface ContextoEditorPropriedade {
+    obterValorAtual: (propId: string) => any;
+    registrarAlteracao: (categoriaId: string, propId: string, novoValor: any) => void;
+    focarProximoEditor: (elementoAtual: HTMLElement) => void;
+    despacharEventoAcao: (prop: ItemPropriedade, categoriaId: string) => void;
+}

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

@@ -0,0 +1,66 @@
+import { CategoriaPropriedades, SeletorTipoItem } from './tipos';
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export * from './tipos';
+export { avaliarExpressaoMatematica } from './avaliador-expressao';
+export * from './propriedades-editores';
+export * from './propriedades-seletor-tipo';
+export * from './propriedades-splitter';
+export * from './propriedades-render-arvore';
+export * from './propriedades-gerenciador-valores';
+export * from './propriedades-painel-controles';
+export * from './propriedades-dom-utils';
+export * from './propriedades-flutuante';
+export * from './propriedades-densidade';
+export declare class UITabelaPropriedades extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private shadow;
+    private listeners;
+    private splitterListeners;
+    private controladorSplitter;
+    private gerenciadorValores;
+    private _categorias;
+    private _tipos;
+    private _tipoSelecionadoId;
+    private _termoBusca;
+    private _larguraRotuloPorcentagem;
+    get larguraRotuloPorcentagem(): number;
+    private tipoContainerElement;
+    private corpoElement;
+    private btnAplicarElement;
+    private btnDesfazerElement;
+    private splitterElement;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _oldVal: string | null, newVal: string | null): void;
+    get categorias(): CategoriaPropriedades[];
+    set categorias(novasCategorias: CategoriaPropriedades[]);
+    get tipos(): SeletorTipoItem[];
+    set tipos(novosTipos: SeletorTipoItem[]);
+    get tipoSelecionado(): string;
+    set tipoSelecionado(idTipo: string);
+    get valores(): Record<string, any>;
+    set valores(novosValores: Record<string, any>);
+    get isDirty(): boolean;
+    get dirty(): boolean;
+    obterValor(propId: string): any;
+    definirValor(propId: string, novoValor: any, emitirEvento?: boolean): void;
+    aplicar(): void;
+    desfazer(): void;
+    expandirTudo(): void;
+    colapsarTudo(): void;
+    toggleCategoria(idCategoria: string): void;
+    get densidade(): 'padrao' | 'compacta' | 'ultracompacta' | 'relaxada';
+    set densidade(val: 'padrao' | 'compacta' | 'ultracompacta' | 'relaxada');
+    alternarDensidade(): string;
+    get flutuante(): boolean;
+    set flutuante(val: boolean);
+    get colapsado(): boolean;
+    set colapsado(val: boolean);
+    alternarFlutuante(): boolean;
+    alternarColapsoHorizontal(): boolean;
+    private syncState;
+    private toggleExpandirTodas;
+    private renderSeletorTipos;
+    private renderCategorias;
+}

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

@@ -0,0 +1 @@
+export * from './ui-texto';

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

@@ -0,0 +1,15 @@
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export type VarianteTexto = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'corpo' | 'corpo-sm' | 'caption' | 'codigo';
+export type CorTexto = 'primaria' | 'secundaria' | 'destaque' | 'erro' | 'sucesso' | 'alerta';
+export type PesoTexto = 'normal' | 'medio' | 'seminegrito' | 'negrito';
+export type AlinhamentoTexto = 'esquerda' | 'centro' | 'direita' | 'justificado';
+export declare class UITexto extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private container;
+    private shadow;
+    constructor();
+    connectedCallback(): void;
+    attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
+    private resolveTag;
+    private render;
+}

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

@@ -0,0 +1 @@
+export * from './ui-tooltip';

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

@@ -0,0 +1,25 @@
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export declare class UITooltip extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private containerElement;
+    private bubbleElement;
+    private _posicionamentoAtivo;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
+    get aberto(): boolean;
+    set aberto(val: boolean);
+    get disabled(): boolean;
+    set disabled(val: boolean);
+    mostrar(): void;
+    ocultar(): void;
+    private posicionarBubble;
+    private syncState;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    private handleClick;
+    private handleClickOutside;
+}
+export declare class UIPopover extends UITooltip {
+}

package/dist/core/acessibilidade.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Gera um identificador único e estável para a vida do elemento.
+ * O contador garante unicidade no documento; o sufixo aleatório evita
+ * colisões entre múltiplas cópias da biblioteca carregadas na mesma página.
+ */
+export declare function gerarIdUnico(prefixo?: string): string;
+/**
+ * Resolve o rótulo fornecido de fora do Shadow DOM:
+ * `aria-label` no host, `<label for="id-do-host">` ou `<label>` envolvendo o host.
+ * Usado quando o componente não recebe o atributo `label`, para que o controle
+ * nativo interno nunca fique sem nome acessível.
+ */
+export declare function obterRotuloExterno(host: HTMLElement, internals?: {
+    labels?: NodeList;
+} | null): string;
+/**
+ * Indica se um clique no host veio de um `<label>` externo (ativação de rótulo),
+ * e não de uma interação dentro do Shadow DOM — cujo evento também é
+ * redirecionado (retargeted) para o host.
+ */
+export declare function cliqueVeioDeRotuloExterno(host: HTMLElement, evento: Event): boolean;