@thibezer/ui-components-kit 2.4.0 → 2.5.0

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

@@ -60,13 +60,6 @@ interface Contexto {
     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;
-    /** A edição de vértices começou (`true`) ou terminou (`false`), para refletir no botão da barra. */
-    aoEdicao?: (ativa: boolean) => void;
-    /**
-     * Os atalhos de teclado do canvas (S do snap, Enter para editar) valem agora? O componente responde que sim com o mouse
-     * sobre ele ou o foco dentro dele; sem esta função, valem sempre (a edição e as ferramentas em andamento também sempre valem).
-     */
-    atalhoValido?: () => boolean;
 }
 /** Opções do popup da feição. */
 export interface OpcoesPopup {
@@ -79,14 +72,13 @@ export interface ResultadoFerramenta {
 }
 export interface ResultadoEdicao {
     ok: boolean;
-    motivo?: MotivoRecusaEdicao | 'inexistente' | 'sem-mapa' | 'sem-selecao';
+    motivo?: MotivoRecusaEdicao | 'inexistente' | 'sem-mapa';
 }
 export declare class GerenciadorFeicoes {
     private contexto;
     private selecao;
     private popup;
     private editor;
-    private vigiaCamadaEmEdicao;
     private snap;
     private desenho;
     private camadaDesenho;
@@ -202,18 +194,12 @@ export declare class GerenciadorFeicoes {
     alternarSnap(): void;
     conectarTeclado(): void;
     desconectarTeclado(): void;
-    private atalhosValem;
-    /** Enter com uma só feição selecionada (e nada em andamento) abre a edição de vértices. */
-    private aoTeclaEdicao;
-    /** Botão "Editar" da barra: encerra a edição em curso ou edita a feição selecionada (uma só). */
-    alternarEdicaoDaSelecao(): ResultadoEdicao;
     /** 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;
-    private pararDeVigiarCamadaEmEdicao;
     pararEdicao(): void;
     get ferramentaAtiva(): Ferramenta | null;
     /** Camada que recebe o que for desenhado. Não existe camada padrão: o consumidor escolhe. */

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

@@ -1,22 +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[];
-/** O atributo pede o botão "Editar" (edição de vértices da feição selecionada)? Vale em "todas" ou com a palavra `editar`. */
-export declare function barraPedeEdicao(valor: string | null): boolean;
 export interface ContextoBarraFerramentas {
     raiz: HTMLElement;
     aoEscolher: (ferramenta: Ferramenta) => void;
-    /** Clique em "Editar". Sem isto o botão não é montado. */
-    aoEditar?: () => void;
 }
 export declare class BarraFerramentas {
     private ctx;
     private barra;
     constructor(ctx: ContextoBarraFerramentas);
-    montar(ferramentas: Ferramenta[], comEdicao?: boolean): void;
-    private editando;
-    /** Reflete no botão "Editar" se a edição está em curso. */
-    marcarEdicao(ativa: boolean): void;
+    montar(ferramentas: Ferramenta[]): void;
     marcar(ativa: Ferramenta | null): void;
     desmontar(): void;
 }

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

@@ -5,8 +5,6 @@ export interface ContextoControleSnap {
         ligado: boolean;
         temporario: boolean;
     }) => void;
-    /** A tecla S só vale quando isto devolve `true` (ex.: mouse sobre o canvas ou foco dentro dele). Sem a função, vale sempre. */
-    aplica?: () => boolean;
     /** Alvo dos listeners de teclado (padrão: window). */
     alvo?: Pick<Window, 'addEventListener' | 'removeEventListener'>;
 }

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

@@ -25,17 +25,10 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     private estilosExternos;
     private lastPopupActionEmit?;
     private lastCanvasClickTime;
-    /** Mouse sobre o componente: junto com o foco dentro dele, decide se S e Enter valem quando há vários canvases na página. */
-    private ponteiroSobre;
     private _chaveGrupo?;
     private _zonaProjecao;
     constructor();
     connectedCallback(): void;
-    private montarBarra;
-    /** Único canvas da página: os atalhos valem em qualquer lugar (comportamento de sempre). Com vários, só no que está sob o mouse ou com foco. */
-    private ehUnicoCanvas;
-    /** O foco do teclado está dentro do componente (inclusive no shadow DOM)? */
-    private matchesFocoInterno;
     destroy(): void;
     disconnectedCallback(): void;
     invalidateSizeSafely(): void;

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

@@ -11,6 +11,10 @@ export interface ContextoCorpoTabela {
     rowHeight: number;
     /** Linha que recebe tabindex=0 (foco móvel); fora da janela renderizada, vale a primeira visível. */
     indiceAtivo?: number | null;
+    /** Há filtro de texto ativo: o vazio vira "sem resultados" (mensagem distinta). */
+    filtroAtivo?: boolean;
+    textoVazio?: string;
+    textoSemResultados?: string;
     isItemSelecionado: (item: Record<string, any>, index: number) => boolean;
     onLinhaClique: (item: Record<string, any>, index: number) => void;
     formatWidth: (largura?: string | number) => string;

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

@@ -7,6 +7,9 @@ export interface EstruturaDOMElementos {
     colgroupElement: HTMLTableColElement;
     emptyElement: HTMLDivElement;
     loadingElement: HTMLDivElement;
+    erroElement: HTMLDivElement;
+    /** Região só para leitores de tela (contagem de resultados do filtro). */
+    anuncioElement: HTMLDivElement;
 }
 export declare function formatWidth(largura?: string | number): string;
 export declare function getAlignmentClass(alinhamento?: string): string;

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

@@ -12,7 +12,9 @@ export interface ContextoHeaderTabela {
     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;
+    onInitColumnResize: (e: MouseEvent | PointerEvent, coluna: TabelaColuna, colIndex: number, th: HTMLTableCellElement, resizer: HTMLDivElement) => void;
+    /** Ajuste por teclado (setas na alça): `delta` em px. */
+    onResizeTeclado?: (delta: number, coluna: TabelaColuna, colIndex: number, th: HTMLTableCellElement, col: HTMLTableColElement) => 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

@@ -5,5 +5,7 @@ export interface ContextoTabelaInteracao {
     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 executarRedimensionamentoColuna(e: MouseEvent | PointerEvent, 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;
+/** Redimensionamento por teclado (setas na alça): ajusta a largura e emite ui-column-resize. */
+export declare function executarRedimensionamentoTeclado(delta: number, coluna: TabelaColuna, thElement: HTMLTableCellElement, colElement: HTMLTableColElement | undefined, ctx: ContextoTabelaInteracao): void;

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

@@ -1,4 +1,4 @@
-import { UISortDetail } from './tipos';
+import { TabelaColuna, UISortDetail } from './tipos';
 /**
  * Alterna ciclicamente a ordenação tri-state:
  * Primeira vez -> 'asc'
@@ -7,6 +7,8 @@ import { UISortDetail } from './tipos';
  */
 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.
+ * Ordena os dados em memória (sem alterar o array recebido). Estável; valores nulos/undefined ficam
+ * sempre no fim, em qualquer direção. Usa `coluna.comparador` quando existir; senão `coluna.tipo`
+ * (numero, data, booleano, texto) ou o tipo dos valores, com collation pt-BR reutilizada.
  */
-export declare function aplicarOrdenacaoTabela(dadosOriginais: Record<string, any>[], colunaOrdenada: string | null, direcao: 'asc' | 'desc' | 'original'): Record<string, any>[];
+export declare function aplicarOrdenacaoTabela(dadosOriginais: Record<string, any>[], colunaOrdenada: string | null, direcao: 'asc' | 'desc' | 'original', coluna?: TabelaColuna | null): Record<string, any>[];

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

@@ -1,4 +1,6 @@
 import { TabelaColuna, UISortDetail } from './tipos';
+/** Minúsculas e sem acentos: "ipe" encontra "Ipê". */
+export declare function normalizarTexto(t: string): string;
 export declare class TabelaOrquestradorDados {
     private dadosOriginais;
     private dadosExibicao;
@@ -7,6 +9,13 @@ export declare class TabelaOrquestradorDados {
     private ultimoFiltro;
     /** Colunas declaradas: o filtro olha só elas (vazio = todos os campos do registro). */
     private colunasFiltro;
+    private colunas;
+    /** Ordenação feita pelo servidor: a tabela guarda coluna/direção (indicador) mas não reordena os dados. */
+    private ordenacaoRemota;
+    setColunas(colunas: TabelaColuna[]): void;
+    setOrdenacaoRemota(remota: boolean): void;
+    /** Restaura coluna/direção (ex.: `ui-sort` cancelado) e recalcula. */
+    restaurarOrdenacao(coluna: string | null, direcao: 'asc' | 'desc' | 'original'): void;
     setColunasFiltro(ids: string[]): void;
     getDadosOriginais(): Record<string, any>[];
     setDadosOriginais(dados: Record<string, any>[]): void;
@@ -16,7 +25,10 @@ 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). */
+    /** Recalcula a lista exibida: filtro vigente e, sobre o resultado, a ordenação da coluna (valem juntos). */
     aplicarOrdenacao(): void;
+    private casaFiltro;
+    /** Há um filtro de texto aplicado (o vazio vira "sem resultados"). */
+    temFiltro(): boolean;
     filtrar(termo: string): void;
 }

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

@@ -1,6 +1,6 @@
 import { TabelaColuna } from './tipos';
 export interface IniciarRedimensionamentoContexto {
-    evento: MouseEvent;
+    evento: MouseEvent | PointerEvent;
     coluna: TabelaColuna;
     colIndex: number;
     thElement: HTMLTableCellElement;
@@ -8,9 +8,16 @@ export interface IniciarRedimensionamentoContexto {
     colgroupElement: HTMLTableColElement | null;
     onResizeStart: () => void;
     onResizeEnd: (larguraFinal: string) => void;
+    /** Soltou sem arrastar: nada mudou, só libera o estado de redimensionamento. */
+    onResizeCancel?: () => void;
 }
+/** Aplica os limites da coluna (mínimo padrão 60px, máximo opcional). */
+export declare function limitarLarguraColuna(coluna: TabelaColuna, largura: number): number;
+/** Redimensiona por teclado: soma `delta` px à largura atual (respeitando os limites). Devolve a largura final. */
+export declare function redimensionarColunaPorDelta(coluna: TabelaColuna, thElement: HTMLTableCellElement, colElement: HTMLTableColElement | undefined, delta: number): string;
 /**
  * Gerencia o ciclo de eventos de drag-to-resize de uma coluna da tabela.
+ * Aceita mouse (mousedown) e toque/caneta (pointerdown); os ouvintes seguem o mesmo tipo do evento inicial.
  */
 export declare function iniciarRedimensionamentoColuna(ctx: IniciarRedimensionamentoContexto): () => void;
 export interface ExibirPromptPopoverContexto {
@@ -23,6 +30,8 @@ export interface ExibirPromptPopoverContexto {
     onResizeEnd: (larguraFinal: string) => void;
 }
 /**
- * Exibe o diálogo popover para ajuste numérico preciso da largura da coluna.
+ * Exibe o diálogo para ajuste numérico preciso da largura da coluna.
+ * Campo numérico rotulado (vazio = automática), validação inline, posicionado junto ao ponto de origem
+ * e mantido dentro da janela; devolve o foco ao cabeçalho ao fechar.
  */
 export declare function exibirPromptPopoverRedimensionamento(ctx: ExibirPromptPopoverContexto): void;

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

@@ -1,15 +1,28 @@
-/**
- * Gerenciador de requisições remotas para <ui-tabela> (endpoint JSON)
- */
+import { TabelaFetcher } from './tipos';
 export interface ContextoTabelaRemota {
     host: HTMLElement;
     onCarregandoAlterado: (carregando: boolean) => void;
     onDadosRecebidos: (dados: Record<string, any>[]) => void;
+    /** Opções do fetch (headers, credentials, method...); lidas a cada requisição. */
+    getOpcoes?: () => RequestInit | null | undefined;
+    /** Função de busca alternativa; padrão: `fetch` global. */
+    getFetcher?: () => TabelaFetcher | null | undefined;
 }
 export declare class TabelaRemotaController {
     private ctx;
     private autoFetchController;
+    private emVoo;
     constructor(ctx: ContextoTabelaRemota);
-    carregar(endpoint: string): Promise<void>;
+    /**
+     * Busca os dados. Resolve `true` em sucesso e `false` em falha, cancelamento ou requisição
+     * substituída (nunca rejeita; o motivo da falha vai no evento `ui-fetch-erro`).
+     * Uma chamada com a mesma URL de uma requisição em andamento reaproveita essa requisição.
+     */
+    carregar(endpoint: string): Promise<boolean>;
+    private emitir;
+    private erro;
+    private executar;
+    /** Cancela a requisição em andamento (se houver) e libera o indicador de carregamento. */
     abortar(): void;
+    private cancelarEmVoo;
 }

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

@@ -20,6 +20,8 @@ export interface ContextoOrquestradorRender {
     virtualizar: boolean;
     rowHeight: number;
     indiceAtivo: number | null;
+    textoVazio?: string;
+    textoSemResultados?: string;
     onSetIsResizing: (resizing: boolean) => void;
     onActiveResizeCleanup: (cleanup: (() => void) | null) => void;
     onHeaderClick: (col: TabelaColuna) => void;

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

@@ -32,6 +32,8 @@ export declare class TabelaSelecaoController {
      * - Item removido dos dados: limpa a seleção e emite `ui-selecao-removida`.
      */
     reconciliar(): void;
+    /** Mesmo registro com outro objeto (dados recarregados): atualiza a referência e avisa. */
+    private substituirReferencia;
     limparSelecao(): void;
     isItemSelecionado(item: Record<string, any>, index: number): boolean;
     atualizarLinhasSelecionadas(): void;

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

@@ -11,6 +11,12 @@ export interface TabelaColuna<T = any> {
     alinhamento?: 'esquerda' | 'centro' | 'direita' | 'left' | 'center' | 'right';
     ordenavel?: boolean;
     tooltip?: string;
+    /** Tipo do dado, usado só na ordenação local: `data` aceita Date, ISO e dd/mm/aaaa. Padrão: inferido pelo valor. */
+    tipo?: 'texto' | 'numero' | 'data' | 'booleano';
+    /** Comparador próprio para a ordenação local (sentido crescente; a direção é aplicada pela tabela). */
+    comparador?: (a: any, b: any, itemA: T, itemB: T) => number;
+    /** Texto pesquisável da célula (o filtro padrão olha o valor bruto); útil quando `render` formata o valor. */
+    textoFiltro?: (valor: any, item: T) => string;
     render?: (valor: any, item: T, index: number) => HTMLElement | string;
 }
 export interface UISortDetail {
@@ -31,3 +37,12 @@ export interface UISelecaoRemovidaDetail {
     /** Item que estava selecionado e deixou de existir nos dados. */
     item: Record<string, any>;
 }
+export interface UIFetchErroDetail {
+    url: string;
+    erro: string;
+    /** Código HTTP quando a falha veio de uma resposta; undefined em falha de rede/JSON/render. */
+    status?: number;
+    origem: 'rede' | 'http' | 'json' | 'render';
+}
+/** Substitui o `fetch` do modo remoto (autenticação, interceptadores, mocks). */
+export type TabelaFetcher = (url: string, init: RequestInit) => Promise<Response>;

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

@@ -1,6 +1,6 @@
-import { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions, UISelecaoRemovidaDetail } from './tipos';
+import { DensidadeTabela, TabelaColuna, TabelaFetcher, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions, UISelecaoRemovidaDetail, UIFetchErroDetail } from './tipos';
 import { SafeHTMLElement } from '../../core/ssr-safe';
-export type { DensidadeTabela, TabelaColuna, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions, UISelecaoRemovidaDetail };
+export type { DensidadeTabela, TabelaColuna, TabelaFetcher, UISortDetail, UIColumnResizeDetail, UIRowScrollOptions, UISelecaoRemovidaDetail, UIFetchErroDetail };
 export declare class UITabela extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private shadow;
@@ -10,6 +10,8 @@ export declare class UITabela extends SafeHTMLElement {
     private _isResizing;
     private _carregando;
     private _src;
+    private _fetchOpcoes;
+    private _fetcher;
     private _containerElement;
     private _tableElement;
     private _theadElement;
@@ -17,6 +19,10 @@ export declare class UITabela extends SafeHTMLElement {
     private _colgroupElement;
     private _emptyElement;
     private _loadingElement;
+    private _erroElement;
+    private _anuncioElement;
+    /** Último erro de carregamento remoto (null = sem erro). */
+    private _erro;
     private _scrollHandler;
     private _activeResizeCleanup;
     private _headerListeners;
@@ -36,14 +42,32 @@ export declare class UITabela extends SafeHTMLElement {
     attributeChangedCallback(name: string, _oldVal: string | null, newVal: string | null): void;
     /** Nome acessível vem do host (`aria-label`); `aria-busy` acompanha o carregamento remoto. */
     private sincronizarAria;
+    /** Textos de estado configuráveis por atributo (carregando, sem resultados, erro). */
+    private atualizarTextosEstado;
+    /** Mostra (ou oculta, com null) o aviso de erro de carregamento com a ação "Tentar novamente". */
+    private mostrarErro;
+    private renderizarErro;
+    /** Anuncia ao leitor de tela o resultado do filtro (a região é limpa sem filtro ativo). */
+    private anunciarResultado;
+    private _textoSemResultados;
     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>;
+    /** Opções do `fetch` do modo remoto (headers, credentials, method, body...); o `signal` é da tabela. */
+    get fetchOpcoes(): RequestInit | null;
+    set fetchOpcoes(val: RequestInit | null);
+    /** Função de busca alternativa ao `fetch` (autenticação, renovação de token, mocks). */
+    get fetcher(): TabelaFetcher | null;
+    set fetcher(val: TabelaFetcher | null);
+    /** Ordenação feita pelo servidor: o clique no cabeçalho atualiza o indicador e emite `ui-sort`, mas não reordena. */
+    get ordenacaoRemota(): boolean;
+    set ordenacaoRemota(val: boolean);
+    /** Busca a URL (guardada como `src`, para `recarregar()`). Resolve `true` em sucesso; falhas vão em `ui-fetch-erro`. */
+    carregarDoEndpoint(url?: string): Promise<boolean>;
+    recarregar(): Promise<boolean>;
     filtrar(termo: string): void;
     private cleanupEventListeners;
     get colunas(): TabelaColuna[];