@thibezer/ui-components-kit 2.9.0 → 2.10.1

package/dist/card.cjs

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

package/dist/card.js

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

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

@@ -0,0 +1,16 @@
+/**
+ * Altura automática da área de texto (atributo `auto-altura`).
+ * `calcularAlturaAutomatica` é pura; `ajustarAlturaAutomatica` aplica o resultado no DOM.
+ */
+/**
+ * Altura (px) a aplicar para o conteúdo caber sem rolagem, ou `null` quando o conteúdo cabe nas linhas
+ * mínimas (a altura volta a ser definida por `rows`). Medidas inválidas resultam em `null`.
+ */
+export declare function calcularAlturaAutomatica(alturaConteudo: number, alturaVisivel: number): number | null;
+/**
+ * Faz o `textarea` crescer com o conteúdo. O envoltorio segura a altura atual durante a medição, para a
+ * página não encolher (e rolar sozinha) quando a área está no fim de um documento comprido.
+ */
+export declare function ajustarAlturaAutomatica(textarea: HTMLTextAreaElement, envoltorio: HTMLElement): void;
+/** Devolve a altura ao controle de `rows`/redimensionamento do navegador. */
+export declare function limparAlturaAutomatica(textarea: HTMLTextAreaElement, envoltorio: HTMLElement): void;

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

@@ -0,0 +1,6 @@
+import { EstadoContador } from './tipos';
+/**
+ * Estado do contador de caracteres. Função pura: tolera tamanho/limite inválidos (`NaN`, negativos, `Infinity`)
+ * e só gera anúncio para leitores de tela perto do limite, evitando falar a cada tecla.
+ */
+export declare function calcularContador(tamanho: number, limite: number | null): EstadoContador;

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

@@ -0,0 +1,2 @@
+export declare const ATRIBUTOS_OBSERVADOS_AREA_TEXTO: string[];
+export declare function criarTemplateAreaTexto(): string;

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

@@ -0,0 +1,3 @@
+export * from './ui-area-texto';
+export * from './tipos';
+export { calcularContador } from './area-texto-contador';

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

@@ -0,0 +1,19 @@
+/** Direções em que o usuário pode redimensionar a área de texto (atributo `redimensionar`). */
+export type RedimensionamentoAreaTexto = 'nenhum' | 'vertical' | 'horizontal' | 'ambos';
+/** `detail` de `ui-input` e `ui-change`. */
+export interface DetalheValorAreaTexto {
+    value: string;
+}
+/** `detail` de `ui-enviar` (Ctrl/Cmd + Enter). */
+export interface DetalheEnviarAreaTexto {
+    value: string;
+}
+/** Nível visual do contador de caracteres. */
+export type NivelContador = 'normal' | 'aviso' | 'excedido';
+export interface EstadoContador {
+    /** Texto visível: `42` ou `42 / 500`. */
+    texto: string;
+    nivel: NivelContador;
+    /** Mensagem para leitores de tela; vazia enquanto o nível for `normal`. */
+    anuncio: string;
+}

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

@@ -0,0 +1,100 @@
+import { FormAssociatedElement } from '../../core/form-associated-element';
+/**
+ * Área de texto de várias linhas (descrições, observações, laudos) com rótulo, ajuda/erro, contador de
+ * caracteres e altura automática. Participa de `<form>` (FACE).
+ *
+ * @element ui-area-texto
+ *
+ * @attr {string} label - Rótulo visível (sempre texto puro).
+ * @attr {string} placeholder - Texto de apoio quando vazio.
+ * @attr {string} value - Valor inicial (também restaurado por `form.reset()`).
+ * @attr {boolean} obrigatorio - Campo obrigatório (alias `required`).
+ * @attr {number} minlength - Mínimo de caracteres.
+ * @attr {number} maxlength - Máximo de caracteres; também é o limite do contador.
+ * @attr {string} helper-text - Texto de ajuda abaixo do campo.
+ * @attr {boolean} erro - Marca o campo como inválido.
+ * @attr {string} mensagem-erro - Mensagem exibida junto com `erro`.
+ * @attr {string} mensagem-validacao - Substitui as mensagens de validação nativas.
+ * @attr {boolean} disabled - Desabilita o campo.
+ * @attr {boolean} readonly - Somente leitura (continua focável e selecionável).
+ * @attr {number} linhas - Linhas visíveis (1–50, padrão 4).
+ * @attr {boolean} auto-altura - O campo cresce com o conteúdo.
+ * @attr {number} linhas-max - Com `auto-altura`, limite de linhas antes de rolar.
+ * @attr {string} redimensionar - `nenhum` | `vertical` (padrão) | `horizontal` | `ambos`.
+ * @attr {boolean} contador - Exibe o contador de caracteres.
+ *
+ * @fires ui-input - A cada edição. `detail: { value }`.
+ * @fires ui-change - Ao confirmar a edição (blur). `detail: { value }`.
+ * @fires ui-enviar - Ctrl/Cmd + Enter. `detail: { value }`. Enter comum insere quebra de linha.
+ * @fires input - Evento nativo, reemitido no host.
+ * @fires change - Evento nativo, reemitido no host.
+ *
+ * @csspart rotulo - Rótulo.
+ * @csspart campo - Invólucro com borda.
+ * @csspart input - O `<textarea>` interno.
+ * @csspart rodape - Linha de ajuda e contador.
+ * @csspart ajuda - Texto de ajuda ou erro.
+ * @csspart contador - Contador de caracteres.
+ */
+export declare class UIAreaTexto extends FormAssociatedElement {
+    static get observedAttributes(): string[];
+    private labelElement;
+    private wrapperElement;
+    private textareaElement;
+    private helperElement;
+    private contadorElement;
+    private anuncioElement;
+    private listeners;
+    private _focado;
+    private _textareaId;
+    private _defaultValue;
+    private _nivelAnunciado;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    focus(options?: FocusOptions): void;
+    blur(): void;
+    /** Seleciona todo o texto. */
+    select(): void;
+    /** Define a seleção; índices inválidos são ignorados pelo navegador, nunca lançam. */
+    setSelectionRange(inicio: number, fim: number, direcao?: 'forward' | 'backward' | 'none'): void;
+    /** Apaga o texto programaticamente (sem disparar eventos de edição). */
+    limpar(): void;
+    get value(): string;
+    set value(val: string);
+    get name(): string;
+    set name(val: string);
+    get type(): string;
+    get disabled(): boolean;
+    set disabled(val: boolean);
+    get readOnly(): boolean;
+    set readOnly(val: boolean);
+    get minLength(): number;
+    set minLength(val: number);
+    get maxLength(): number;
+    set maxLength(val: number);
+    formResetCallback(): void;
+    formStateRestoreCallback(state: unknown, _mode: 'restore' | 'autocomplete'): void;
+    atualizarValidade(): void;
+    protected syncState(): void;
+    private sincronizarRotulo;
+    private sincronizarLimites;
+    private sincronizarEstadoInterativo;
+    private sincronizarFeedback;
+    private sincronizarContador;
+    private sincronizarAltura;
+    private emitirEdicao;
+    private handleInput;
+    private handleChange;
+    private handleFocus;
+    private handleBlur;
+    /** Ctrl/Cmd + Enter pede o envio sem submeter o `<form>`; Enter comum continua inserindo quebra de linha. */
+    private handleKeyDown;
+    /** Clique em `<label>` externo associado ao host foca o textarea. */
+    private handleHostClick;
+    private handleResize;
+}
+/** Alias semântico: `<ui-textarea>` é idêntico a `<ui-area-texto>`. */
+export declare class UITextarea extends UIAreaTexto {
+}

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

@@ -9,4 +9,8 @@ export interface ContextoLabelPlaceholder {
 }
 export declare function sincronizarLabelEPlaceholder(ctx: ContextoLabelPlaceholder): void;
 export declare function sincronizarIconeSenha(container: HTMLSpanElement, ehSenhaOuAlternar: boolean, senhaVisivel: boolean): void;
-export declare function sincronizarFeedbackErro(wrapper: HTMLDivElement, input: HTMLInputElement, helper: HTMLDivElement, temErro: boolean, mensagemErro: string | null, helperText: string | null): void;
+/**
+ * Reflete erro e texto de ajuda no campo. `prefixo` é o bloco BEM do componente (padrão `ui-campo-texto`),
+ * permitindo que `<ui-area-texto>` reutilize a mesma regra com suas próprias classes.
+ */
+export declare function sincronizarFeedbackErro(wrapper: HTMLElement, input: HTMLInputElement | HTMLTextAreaElement, helper: HTMLElement, temErro: boolean, mensagemErro: string | null, helperText: string | null, prefixo?: string): void;

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

@@ -8,6 +8,7 @@ export declare class UICampoTexto extends FormAssociatedElement {
     private rightIconContainer;
     private leftSlotElement;
     private _senhaVisivel;
+    private listeners;
     private _checkTimer;
     private _focado;
     private _inputId;

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

@@ -11,5 +11,11 @@ export declare function textoSelecao(quantidade: number): string;
 export declare function textoFerramenta(ferramenta: string | null): string;
 /** Escreve na região viva (`#cad-status`); trocar o texto é o que dispara o anúncio. */
 export declare function anunciar(shadow: ShadowRoot, texto: string): void;
-/** Liga os anúncios aos eventos que o próprio componente emite; devolve a função que desliga. */
+/** Tempo (ms) que o aviso visível de uma recusa fica na tela. */
+export declare const TEMPO_AVISO_MS = 5000;
+/**
+ * Liga os anúncios aos eventos que o próprio componente emite; devolve a função que desliga.
+ * Recusas de desenho e de edição viram aviso visível e anúncio, a menos que o host tenha o atributo `sem-avisos`
+ * (o consumidor mostra o próprio aviso a partir de `cad-desenho-recusado` / `cad-edicao-recusada`).
+ */
 export declare function conectarAnuncios(host: HTMLElement, shadow: ShadowRoot): () => void;

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

@@ -20,10 +20,15 @@ export interface PortasEdicao {
     snapAtivo: () => boolean;
     alternarSnap: () => void;
     buscarSnapEm: (coord: [number, number], excluir?: ExcluirSnap) => ReturnType<typeof import('../../gerencigeo-canvas/feature_snap').buscarSnap>;
+    /** Feições selecionadas agora (o botão "Editar" e o Enter editam quando há exatamente uma). */
+    selecionadas: () => Feicao[];
+    /** A edição começou (`true`) ou terminou (`false`), para refletir no botão "Editar" da barra. */
+    aoEdicao?: (ativa: boolean) => void;
 }
 export declare class EdicaoFeicoes {
     private p;
     private editor;
+    private pararDeVigiarCamada;
     constructor(p: PortasEdicao);
     get editando(): boolean;
     /** @internal Editor de vértices da camada L2 (`null` fora da edição). */
@@ -33,5 +38,13 @@ export declare class EdicaoFeicoes {
     sincronizar(feicao: Feicao): void;
     atualizarSnapNoHud(): void;
     iniciarEdicao(camadaId: string, id: string): ResultadoEdicao;
+    /** Camada ocultada, bloqueada ou removida no meio da edição encerra a edição (as alças gravariam numa camada que não aceita). */
+    private vigiarCamada;
+    /** A única feição selecionada, se puder ser editada agora (sem emitir recusa). */
+    private selecionadaEditavel;
+    /** Enter: edita a única feição selecionada, se ela for editável. Devolve se a edição começou. */
+    editarSelecionada(): boolean;
+    /** Botão "Editar" da barra: encerra a edição em curso ou edita a feição selecionada (uma só). */
+    alternarEdicaoDaSelecao(): ResultadoEdicao;
     parar(): void;
 }

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

@@ -1,6 +1,7 @@
 import { Feicao, LatLonPar } from '../../gerencigeo-canvas/feature_types';
 export interface PortasPonteiro {
-    emitir: (evento: string, detalhe: unknown) => unknown;
+    /** Com `cancelavel`, devolve `true` se algum ouvinte chamou `preventDefault()`. */
+    emitir: (evento: string, detalhe: unknown, cancelavel?: boolean) => unknown;
     feicaoSob: (clientX: number, clientY: number) => {
         feicao: Feicao | null;
         coordenada: LatLonPar;
@@ -11,6 +12,8 @@ export interface PortasPonteiro {
     botaoDireitoDaFerramenta: () => boolean;
     /** Pedido explícito de informações: abre o popup da feição. */
     abrirPopup?: (feicao: Feicao) => void;
+    /** O duplo clique pode abrir o popup (falso com `popups="desligado"`). Sem a função, pode. */
+    popupNoDuploClique?: () => boolean;
 }
 export declare class PonteiroFeicoes {
     private p;
@@ -21,7 +24,10 @@ export declare class PonteiroFeicoes {
     aoMoverMouse(e: MouseEvent): void;
     /** Botão direito: emite `cad-feicao-menu` com a feição sob o cursor (ou `null`), para o consumidor abrir o próprio menu. */
     menuContexto(e: MouseEvent): void;
-    /** Duplo clique sobre uma feição: pedido de informações (popup). Ignorado durante desenho ou edição de vértices. */
+    /**
+     * Duplo clique sobre uma feição: emite `cad-feicao-duplo-clique` (cancelável, para o consumidor assumir o gesto) e,
+     * se ninguém chamar `preventDefault()`, abre o popup (pedido de informações). Ignorado durante desenho ou edição de vértices.
+     */
     duploClique(e: MouseEvent): void;
     /** Esquece a feição sob o cursor (ao destruir o componente). */
     limpar(): void;

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

@@ -0,0 +1,19 @@
+export interface PortasTecladoEdicao {
+    /** Edição de vértices ou ferramenta de desenho em andamento: elas tratam o próprio Enter. */
+    ocupado: () => boolean;
+    /** Os atalhos do canvas valem agora (mouse sobre ele, foco dentro dele ou canvas único na página)? */
+    atalhosValem: () => boolean;
+    /** Edita a única feição selecionada, se houver uma editável. Devolve se a edição começou. */
+    editarSelecionada: () => boolean;
+}
+/** Enter "limpo": sem modificadores, não tratado antes, fora de campos de texto e de botões/links em foco. */
+export declare function enterLivre(e: KeyboardEvent): boolean;
+export declare class TecladoEdicao {
+    private p;
+    private ouvintes;
+    constructor(p: PortasTecladoEdicao);
+    /** Idempotente: reconectar não duplica o ouvinte. */
+    conectar(alvo?: EventTarget): void;
+    desconectar(): void;
+    private aoTecla;
+}

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

@@ -49,5 +49,5 @@ export interface ResultadoFerramenta {
 }
 export interface ResultadoEdicao {
     ok: boolean;
-    motivo?: MotivoRecusaEdicao | 'inexistente' | 'sem-mapa';
+    motivo?: MotivoRecusaEdicao | 'inexistente' | 'sem-mapa' | 'sem-selecao';
 }

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

@@ -33,6 +33,13 @@ interface Contexto {
     modoPopups?: () => ModoPopups;
     /** Executa a abertura de um popup como pedido explícito, passando pelo portão de popups do mapa. */
     liberarPopups?: <T>(fn: () => T) => T;
+    /** 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;
 }
 export declare class GerenciadorFeicoes {
     private contexto;
@@ -40,6 +47,7 @@ export declare class GerenciadorFeicoes {
     private selecao;
     private popup;
     private edicao;
+    private teclado;
     private consulta;
     private ponteiro;
     private regiao;
@@ -91,7 +99,7 @@ export declare class GerenciadorFeicoes {
     private modoPopups;
     /** Pedido explícito: abre o popup da feição (vale em qualquer modo). `false` se não existe, foi excluída ou não está na tela. */
     abrirPopupFeicao(camadaId: string, id: string): boolean;
-    /** Duplo clique no mapa: abre o popup da feição sob o cursor (a não ser que os popups estejam desligados). */
+    /** Duplo clique no mapa: `cad-feicao-duplo-clique` (cancelável) e, se ninguém assumir, o popup da feição sob o cursor. */
     aoDuploClique(e: MouseEvent): void;
     /** Opções do popup (hoje: se "copiar" escreve na área de transferência). Mescla com o que já foi definido. */
     definirOpcoesPopup(opcoes: OpcoesPopup): void;
@@ -140,6 +148,9 @@ export declare class GerenciadorFeicoes {
     alternarSnap(): void;
     conectarTeclado(): void;
     desconectarTeclado(): void;
+    private atalhosValem;
+    /** 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 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). */

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

@@ -1,15 +1,22 @@
 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[]): void;
+    montar(ferramentas: Ferramenta[], comEdicao?: boolean): void;
+    private editando;
+    /** Reflete no botão "Editar" se a edição está em curso. */
+    marcarEdicao(ativa: boolean): void;
     marcar(ativa: Ferramenta | null): void;
     desmontar(): void;
 }

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

@@ -0,0 +1,6 @@
+/**
+ * Textos (pt-BR) das recusas do <ui-canvas-cad>: o motivo que sai em `cad-desenho-recusado` e `cad-edicao-recusada`
+ * vira uma frase para o aviso visível e para o leitor de tela. Funções puras; motivo desconhecido recebe um texto genérico.
+ */
+export declare function textoDesenhoRecusado(motivo: unknown): string;
+export declare function textoEdicaoRecusada(motivo: unknown): string;

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

@@ -5,6 +5,8 @@ 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

@@ -31,10 +31,17 @@ 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-card/card-interacao.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Quando um clique ou uma tecla vinda de dentro do card deve ativá-lo.
+ * Responsabilidade única: decidir, sem tocar no DOM, se o evento pertence ao card ou a um controle interno.
+ */
+/**
+ * O alvo é (ou está dentro de) um controle com comportamento próprio, entre ele e a `raiz` (o host do card)?
+ * Aceita `Element`, e não só `HTMLElement`: o alvo de um clique num ícone é o `<path>` do SVG.
+ * Controles fora da `raiz` não contam (um card dentro de um `<a>` ou `<label>` continua clicável), e o próprio
+ * host e o `role="button"` da base do card não são "controle interno".
+ */
+export declare function ehControleInterno(alvo: EventTarget | null | undefined, raiz: Element): boolean;
+/**
+ * A tecla ativa o card? Só Enter/Espaço pressionados no próprio card, sem repetição (tecla mantida) e sem
+ * Ctrl/Alt/Meta. Teclas vindas de controles internos (campo, botão) não são do card: ativá-lo e chamar
+ * `preventDefault` impediria digitar espaço num `<input>` ou acionar o botão.
+ */
+export declare function teclaAtivaCard(e: Pick<KeyboardEvent, 'key' | 'repeat' | 'ctrlKey' | 'altKey' | 'metaKey' | 'target'>, base: EventTarget): boolean;

package/dist/components/ui-card/card-secoes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Seções opcionais do card (mídia, cabeçalho, rodapé).
+ * Responsabilidade única: dizer se um grupo de slots (nome em português e alias em inglês) tem conteúdo.
+ */
+/**
+ * Há conteúdo atribuído a algum dos slots `nomes`? Conta elementos e texto não vazio (espaços e quebras de linha
+ * entre as tags não contam). Também olha os filhos diretos do host com `slot="..."`, que cobre o intervalo antes do
+ * `slotchange`. Só filhos diretos: um `[slot]` aninhado em outro elemento pertence a outro componente.
+ */
+export declare function secaoTemConteudo(raiz: ShadowRoot | null, host: Element, nomes: readonly string[]): boolean;

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

@@ -1,4 +1,24 @@
 import { SafeHTMLElement } from '../../core/ssr-safe';
+/**
+ * Cartão de conteúdo com mídia, cabeçalho, corpo e rodapé opcionais; pode ser clicável (vira um botão).
+ *
+ * @attr {'plano'|'elevado'|'destaque'} elevacao - Profundidade visual (alias `elevation`).
+ * @attr {'plano'|'elevado'|'destaque'} variante - Estilo adicional (alias `variant`); valores desconhecidos são ignorados.
+ * @attr {boolean} clicavel - Torna o card um botão focável que emite `ui-clique` (alias `clickable`).
+ * @attr {boolean} compacto - Reduz os espaçamentos internos (alias `compact`).
+ * @attr {boolean} disabled - Desativa a interação e reduz a opacidade.
+ * @attr {string} aria-label - Nome acessível do card clicável (um card sem clique não é anunciado como controle).
+ * @slot - Corpo do card.
+ * @slot midia - Imagem ou vídeo no topo (alias `media`).
+ * @slot cabecalho - Título e ações (alias `header`); a seção some quando vazia.
+ * @slot rodape - Ações e metadados (alias `footer`); a seção some quando vazia.
+ * @csspart base - O contêiner do card.
+ * @csspart midia - A seção de mídia.
+ * @csspart cabecalho - A seção de cabeçalho.
+ * @csspart corpo - A seção do corpo.
+ * @csspart rodape - A seção de rodapé.
+ * @fires ui-clique - Card clicável ativado por clique, Enter ou Espaço (`detail.id`); também emitido como `ui-click`.
+ */
 export declare class UICard extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private cardElement;
@@ -8,6 +28,8 @@ export declare class UICard extends SafeHTMLElement {
     disconnectedCallback(): void;
     attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
     private handleSlotChange;
+    /** Leva o foco ao card clicável e habilitado; nos demais casos mantém o comportamento nativo do host. */
+    focus(options?: FocusOptions): void;
     get clicavel(): boolean;
     set clicavel(val: boolean);
     get disabled(): boolean;
@@ -15,4 +37,5 @@ export declare class UICard extends SafeHTMLElement {
     private syncState;
     private handleClick;
     private handleKeyDown;
+    private emitirClique;
 }

package/dist/components/ui-cores/cores-utils.d.ts

@@ -8,6 +8,8 @@ export declare const PALETA_CORES_PADRAO: readonly string[];
 export declare function normalizarCor(cor: unknown): ValorCor | null;
 /** Limita a opacidade a [0, 1]; valores inválidos viram `padrao`. */
 export declare function normalizarOpacidade(valor: unknown, padrao?: number): number;
+/** Limita a espessura do traço (em px) a [0.5, 50]; valores inválidos viram `padrao` (2.5). */
+export declare function normalizarEspessura(valor: unknown, padrao?: number): number;
 /** Lista de cores válidas e sem repetição, na ordem recebida. */
 export declare function coresUnicas(cores: unknown): string[];
 export declare function escaparHtml(texto: unknown): string;

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

@@ -15,6 +15,8 @@ export interface DetalheSeletorCor {
     traco: ValorCor;
     /** Opacidade do preenchimento, de 0 a 1. */
     opacidade: number;
+    /** Espessura do traçado em pixels (para linhas, contornos e formas CAD). */
+    espessuraTraco?: number;
 }
 /** Opções de `abrirSeletorCor()`. */
 export interface OpcoesSeletorCor {
@@ -35,6 +37,10 @@ export interface OpcoesSeletorCor {
     opacidade?: number;
     /** Mostra o controle de opacidade. Padrão: só quando o alvo é o preenchimento. */
     mostrarOpacidade?: boolean;
+    /** Espessura inicial do traçado em pixels (padrão 2.5). */
+    espessuraTraco?: number;
+    /** Mostra o controle de espessura do traçado. Padrão: só quando o alvo é o traço. */
+    mostrarEspessura?: boolean;
     /** A cor inicial representa uma seleção com cores diferentes (mostra "MISTO"). */
     misto?: boolean;
     /** Cores extras oferecidas em "Cores do projeto" (duplicadas e inválidas são ignoradas). */
@@ -64,13 +70,14 @@ export interface DetalheControleCores {
     preenchimento: ValorCor;
     traco: ValorCor;
     opacidade: number;
+    espessuraTraco?: number;
     alvo: AlvoCor;
     /** `false` durante a pré-visualização no seletor; `true` quando a alteração deve ser gravada. */
     confirmado: boolean;
     /** Quais valores mudaram. */
-    alterados: Array<'preenchimento' | 'traco' | 'opacidade'>;
+    alterados: Array<'preenchimento' | 'traco' | 'opacidade' | 'espessuraTraco'>;
     /** O que gerou a mudança. */
-    origem: 'seletor' | 'inverter' | 'sem-cor' | 'padrao';
+    origem: 'seletor' | 'inverter' | 'sem-cor' | 'padrao' | 'espessura';
 }
 /** Textos de atalho exibidos nas dicas dos botões (o kit não registra os atalhos; quem usa decide). */
 export interface AtalhosControleCores {

package/dist/components/ui-cores/ui-controle-cores.d.ts

@@ -2,7 +2,7 @@ import { SafeHTMLElement } from '../../core/ssr-safe';
 import { AlvoCor, AtalhosControleCores, ValorCor } from './tipos';
 /**
  * <ui-controle-cores> — par de cores de desenho no estilo Illustrator: preenchimento na frente,
- * traço atrás, e botões de canto para inverter, "sem cor" e restaurar o padrão.
+ * traço atrás, espessura do traçado e botões de canto para inverter, "sem cor" e restaurar o padrão.
  *
  * - Clique na amostra de trás: ela vira o alvo ativo. Clique no alvo ativo (ou duplo clique,
  *   Enter, Espaço): abre o `<ui-seletor-cor>` ao lado.
@@ -11,9 +11,9 @@ import { AlvoCor, AtalhosControleCores, ValorCor } from './tipos';
  * - O kit não registra atalhos de teclado; quem usa chama `alternarAlvo()`, `inverter()`,
  *   `semCor()` e `restaurarPadrao()` e pode exibir as teclas nas dicas via `atalhos`.
  *
- * Atributos: preenchimento, traco, opacidade, alvo (preenchimento|traco), padrao-preenchimento,
+ * Atributos: preenchimento, traco, opacidade, espessura-traco, alvo (preenchimento|traco), padrao-preenchimento,
  *            padrao-traco, titulo-seletor, so-traco, desabilitado
- * Propriedades: preenchimento, traco, opacidade, alvo, coresProjeto, atalhos, seletorAberto
+ * Propriedades: preenchimento, traco, opacidade, espessuraTraco, alvo, coresProjeto, atalhos, seletorAberto
  * Métodos: definirCores(), obterCores(), definirAlvo(), alternarAlvo(), definirMisto(), inverter(),
  *          semCor(), restaurarPadrao(), abrirSeletor(), fecharSeletor()
  * Eventos: ui-cores-change (DetalheControleCores), ui-alvo-change { alvo }
@@ -26,6 +26,7 @@ export declare class UIControleCores extends SafeHTMLElement {
     private _preenchimento;
     private _traco;
     private _opacidade;
+    private _espessuraTraco;
     private _alvo;
     private _misto;
     private _padrao;
@@ -43,6 +44,8 @@ export declare class UIControleCores extends SafeHTMLElement {
     set traco(v: ValorCor);
     get opacidade(): number;
     set opacidade(v: number);
+    get espessuraTraco(): number;
+    set espessuraTraco(v: number);
     get alvo(): AlvoCor;
     set alvo(v: AlvoCor);
     /** Cores oferecidas em "Cores do projeto" no seletor. */
@@ -52,16 +55,18 @@ export declare class UIControleCores extends SafeHTMLElement {
     get atalhos(): AtalhosControleCores;
     set atalhos(v: AtalhosControleCores);
     get seletorAberto(): boolean;
-    /** Define cores e/ou opacidade sem emitir eventos. Valores inválidos são ignorados; uma cor definida deixa de ser "mista". */
+    /** Define cores, opacidade e/ou espessura sem emitir eventos. Valores inválidos são ignorados; uma cor definida deixa de ser "mista". */
     definirCores(cores?: {
         preenchimento?: ValorCor;
         traco?: ValorCor;
         opacidade?: number;
+        espessuraTraco?: number;
     }): void;
     obterCores(): {
         preenchimento: ValorCor;
         traco: ValorCor;
         opacidade: number;
+        espessuraTraco: number;
         alvo: AlvoCor;
     };
     /** Marca a amostra como ativa sem emitir eventos. */

package/dist/components/ui-cores/ui-seletor-cor.d.ts

@@ -3,14 +3,11 @@ import { AlvoCor, DetalheSeletorCor, OpcoesSeletorCor, SeletorCorAberto, ValorCo
 /** Configuração aceita por `UISeletorCor.configurar()` (as opções de `abrirSeletorCor` sem âncora e callbacks). */
 export type ConfiguracaoSeletorCor = Omit<OpcoesSeletorCor, 'ancora' | 'focar' | 'aoAlterar' | 'aoConfirmar' | 'aoCancelar' | 'aoTrocarAlvo'>;
 /**
- * <ui-seletor-cor> — painel de cor no estilo Illustrator: abas Preenchimento/Traço, prévia
- * antes × depois, hexadecimal, seletor do sistema, opacidade do preenchimento, cores do projeto,
- * paleta padrão e "sem cor".
+ * <ui-seletor-cor> — painel de cor e estilo CAD: abas Preenchimento/Traço, prévia
+ * antes × depois com espessura real, hexadecimal, seletor do sistema, espessura do traçado (px),
+ * opacidade do preenchimento, cores do projeto, paleta padrão e "sem cor".
  *
- * Normalmente aberto por `abrirSeletorCor()`, que posiciona o painel junto a uma âncora e cuida
- * de fechar com Esc ou clique fora. Pode também ser usado direto no DOM.
- *
- * Métodos: configurar(opcoes), trocarAlvo(alvo), definirCor(cor), definirOpacidade(v),
+ * Métodos: configurar(opcoes), trocarAlvo(alvo), definirCor(cor), definirOpacidade(v), definirEspessura(v),
  *          confirmar(), cancelar(), obterEstado()
  * Eventos: ui-cor-input (pré-visualização), ui-cor-confirmar, ui-cor-cancelar — detail: DetalheSeletorCor;
  *          ui-alvo-change { alvo }
@@ -25,6 +22,8 @@ export declare class UISeletorCor extends SafeHTMLElement {
     private _traco;
     private _opacidade;
     private _mostrarOpacidade;
+    private _espessura;
+    private _mostrarEspessura;
     private _misto;
     private _coresProjeto;
     private _paleta;
@@ -38,6 +37,7 @@ export declare class UISeletorCor extends SafeHTMLElement {
     /** Cor do alvo em edição. */
     get cor(): ValorCor;
     get opacidade(): number;
+    get espessura(): number;
     obterEstado(): DetalheSeletorCor;
     /** Alterna entre Preenchimento e Traço (só no modo duplo). */
     trocarAlvo(alvo: AlvoCor): void;
@@ -45,10 +45,13 @@ export declare class UISeletorCor extends SafeHTMLElement {
     definirCor(cor: ValorCor): void;
     /** Opacidade do preenchimento (0 a 1); emite `ui-cor-input`. */
     definirOpacidade(valor: number): void;
+    /** Espessura do traço em pixels (0.5 a 50); emite `ui-cor-input`. */
+    definirEspessura(valor: number): void;
     confirmar(): void;
-    /** Restaura as cores iniciais (emitindo `ui-cor-input`) e emite `ui-cor-cancelar`. */
+    /** Restaura os valores iniciais (emitindo `ui-cor-input`) e emite `ui-cor-cancelar`. */
     cancelar(): void;
     private get opacidadeVisivel();
+    private get espessuraVisivel();
     private renderizar;
     private atualizarVisual;
     /** `activeElement` lança em alguns DOMs simulados quando o foco está em outra árvore de sombra. */
@@ -60,7 +63,7 @@ export declare class UISeletorCor extends SafeHTMLElement {
  * Abre um `<ui-seletor-cor>` flutuante ao lado de `ancora` (à direita; à esquerda se não couber).
  * Só um seletor fica aberto por vez: abrir outro descarta o anterior sem confirmar.
  * Fecha confirmando com Concluir, ✕, Enter no hexadecimal, Esc ou clique fora; "Cancelar"
- * restaura as cores iniciais. `X` alterna Preenchimento/Traço enquanto ele está aberto.
+ * restaura as cores e espessura iniciais. `X` alterna Preenchimento/Traço enquanto ele está aberto.
  */
 export declare function abrirSeletorCor(opcoes: OpcoesSeletorCor): SeletorCorAberto;
 /** Fecha o seletor aberto por `abrirSeletorCor()`, se houver. */

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

@@ -1,5 +1,5 @@
 import { ItemPropriedade, ContextoEditorPropriedade } from './tipos';
-export declare function criarEditorReadonly(valorAtual: any): HTMLElement;
+export declare function criarEditorReadonly(valorAtual: any, obterTextoMisto?: () => string): 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;