@thibezer/ui-components-kit 2.10.0 → 2.11.0

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-linha-padrao.d.ts

@@ -0,0 +1,27 @@
+import { EstiloFeicao } from '../../gerencigeo-canvas/feature_types';
+import { OpcoesLinhaPadrao } from './tipos';
+/** Atributo HTML → chave da linha padrão. */
+export declare const ATRIBUTOS_LINHA_PADRAO: {
+    readonly 'linha-cor': "cor";
+    readonly 'linha-espessura': "espessura";
+    readonly 'linha-tipo': "tipo";
+    readonly 'linha-escala': "escala";
+    readonly 'linha-tracejado': "tracejado";
+    readonly 'linha-deslocamento': "deslocamento";
+    readonly 'linha-opacidade': "opacidade";
+    readonly 'linha-terminacao': "terminacao";
+    readonly 'linha-juncao': "juncao";
+};
+export type AtributoLinhaPadrao = keyof typeof ATRIBUTOS_LINHA_PADRAO;
+export declare function ehAtributoLinhaPadrao(nome: string): nome is AtributoLinhaPadrao;
+/** Valor saneado de uma opção; `undefined` = inválido ou ausente (a opção sai do estilo de desenho). */
+export declare function sanearOpcaoLinha(chave: keyof OpcoesLinhaPadrao, valor: unknown): EstiloFeicao[keyof EstiloFeicao] | undefined;
+/**
+ * Mescla `opcoes` no estilo de desenho e devolve o novo estilo (o original não é tocado). Chave presente com valor
+ * `null`, `undefined` ou inválido remove a opção; chave ausente fica como está.
+ */
+export declare function mesclarLinhaPadrao(estilo: EstiloFeicao, opcoes: Partial<Record<keyof OpcoesLinhaPadrao, unknown>> | null | undefined): EstiloFeicao;
+/** A linha padrão vista a partir do estilo de desenho (só as opções definidas). */
+export declare function lerLinhaPadrao(estilo: EstiloFeicao): OpcoesLinhaPadrao;
+/** Atributo `linha-*` mudou: a opção correspondente, pronta para `mesclarLinhaPadrao`. */
+export declare function opcaoDoAtributo(nome: AtributoLinhaPadrao, valor: string | null): Partial<Record<keyof OpcoesLinhaPadrao, unknown>>;

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/index.d.ts

@@ -2,6 +2,8 @@ export * from './ui-canvas-cad';
 export * from './cad-painel-camadas';
 export * from './cad-eventos-canvas';
 export * from './cad-tamanho-observer';
+export type { OpcoesLinhaPadrao } from './tipos';
+export { ATRIBUTOS_LINHA_PADRAO } from './cad-linha-padrao';
 export * from '../../gerencigeo-canvas/types';
 export * from '../../gerencigeo-canvas/layer_manager';
 export * from '../../gerencigeo-canvas/layer_renderer_factory';

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

@@ -1,7 +1,4 @@
-/**
- * Tipos "emprestados" do Leaflet e do contexto do mapa usados pelo <ui-canvas-cad>.
- * Responsabilidade única: descrever, em um só lugar, as formas dinâmicas que o código antes acessava com `as any`.
- */
+import { JuncaoTraco, TerminacaoTraco, TipoLinha } from '../../gerencigeo-canvas/motor/tipos-linha';
 /** Contêiner de mapa do Leaflet: o Leaflet marca o elemento com `_leaflet_id` ao inicializar. */
 export type ContainerLeaflet = HTMLElement & {
     _leaflet_id?: number;
@@ -35,3 +32,27 @@ export interface ElementoComCoordenadas {
     latitude?: number | string;
     longitude?: number | string;
 }
+/**
+ * Linha padrão do <ui-canvas-cad> (`definirLinhaPadrao` e atributos `linha-*`): o traço das feições desenhadas daqui
+ * para frente. Cada opção vira um campo do estilo de desenho (`EstiloFeicao`).
+ */
+export interface OpcoesLinhaPadrao {
+    /** Cor do traço (hex, rgb/hsl ou nome) → `corTraco`. */
+    cor?: string;
+    /** Espessura em px (0 a 100) → `espessuraTraco`. */
+    espessura?: number;
+    /** Tipo de linha CAD → `tipoLinha`. */
+    tipo?: TipoLinha;
+    /** Escala do tipo de linha (LTSCALE) → `escalaTipoLinha`. */
+    escala?: number;
+    /** Tracejado explícito ("8 4 2 4"), vence `tipo` → `dashArray`. */
+    tracejado?: string;
+    /** Deslocamento do tracejado em px → `deslocamentoTracejado`. */
+    deslocamento?: number;
+    /** Opacidade do traço, 0 a 1 → `opacidadeTraco`. */
+    opacidade?: number;
+    /** Pontas do traço → `terminacaoTraco`. */
+    terminacao?: TerminacaoTraco;
+    /** Cantos do traço → `juncaoTraco`. */
+    juncao?: JuncaoTraco;
+}

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

@@ -6,7 +6,7 @@ import { ModoPopups } from '../../gerencigeo-canvas/popup_gate';
 import { ModoRenderizador } from '../../gerencigeo-canvas/renderers/feicoes_despachante';
 import { EstatisticasFeicoes } from '../../gerencigeo-canvas/renderers/renderizador_feicoes_tipos';
 import { UsuarioRemoto } from '../../gerencigeo-canvas/feature_cursores';
-import { EventoMapaCad, LatLngEvento } from './tipos';
+import { EventoMapaCad, LatLngEvento, OpcoesLinhaPadrao } from './tipos';
 import { PontoPixel } from './cad-evento-coordenadas';
 import { OpcoesCamadaFeicoes, OpcoesLote, LoteFeicoes, ResultadoLote, ResultadoFeicoes, ResultadoEdicao, ResultadoFerramenta } from './cad-feicoes';
 import { EstiloFeicao, Feicao } from '../../gerencigeo-canvas/feature_types';
@@ -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;
@@ -177,6 +184,15 @@ export declare class UICanvasCAD extends SafeHTMLElement {
     get camadaDesenho(): string | null;
     definirEstiloDesenho(estilo: EstiloFeicao): void;
     obterEstiloDesenho(): EstiloFeicao;
+    /**
+     * Linha padrão das feições desenhadas daqui para frente (cor, espessura, tipo de linha CAD, escala, tracejado,
+     * deslocamento, opacidade, terminação e junção). Mescla no estilo de desenho; `null` numa opção a remove e valor
+     * inválido é ignorado (a opção volta ao padrão). Os atributos `linha-*` fazem o mesmo.
+     */
+    definirLinhaPadrao(opcoes: {
+        [K in keyof OpcoesLinhaPadrao]?: OpcoesLinhaPadrao[K] | null;
+    }): void;
+    obterLinhaPadrao(): OpcoesLinhaPadrao;
     /**
      * Ferramentas: ponto, linha, poligono, retangulo, elipse, poligono-regular, estrela, circulo, texto, caneta,
      * medir-distancia, medir-area, dividir, selecao-laco, conta-gotas. `iniciarEm` ([lat, lon]) registra o primeiro clique.

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;

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

@@ -16,6 +16,11 @@ export declare function atualizarCampoVisual(shadow: ShadowRoot, propId: string,
  * (`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;
+/**
+ * Exibe o estado misto ("Varia") no select: opção oculta e desabilitada, que o usuário não
+ * consegue escolher; qualquer outra opção vira o valor de todos os objetos.
+ */
+export declare function marcarSelectMisto(select: HTMLSelectElement, texto: 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;

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

@@ -1,4 +1,6 @@
 import { CategoriaPropriedades } from './tipos';
+import { valoresIguais } from './propriedades-valor-misto';
+export { valoresIguais };
 export interface ContextoGerenciadorValores {
     hostElement: HTMLElement;
     getCategorias: () => CategoriaPropriedades[];
@@ -7,8 +9,6 @@ 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;
@@ -28,7 +28,7 @@ export declare class GerenciadorValoresPropriedades {
     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). */
+    /** Marca/desmarca a linha (modificada e mista) 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-valor-misto.d.ts

@@ -0,0 +1,25 @@
+import { ContextoEditorPropriedade, ItemPropriedade } from './tipos';
+/**
+ * Valor de uma propriedade que difere entre os objetos selecionados. `Symbol.for` mantém a
+ * identidade mesmo com duas cópias do pacote carregadas.
+ */
+export declare const VALOR_MISTO: unique symbol;
+/** Texto exibido no lugar do valor misto quando a aplicação não define `texto-misto`. */
+export declare const TEXTO_MISTO_PADRAO = "Varia";
+export declare function isValorMisto(valor: unknown): valor is typeof VALOR_MISTO;
+/** Texto do estado misto definido pela aplicação, com fallback para "Varia". */
+export declare function textoMistoDe(ctx: Pick<ContextoEditorPropriedade, 'obterTextoMisto'>): string;
+/** Igualdade de valores de propriedade: estrita, com null/undefined equivalentes e NaN igual a NaN. */
+export declare function valoresIguais(a: any, b: any): boolean;
+/** Valor inicial de um item: `misto: true` tem precedência sobre `valor`. */
+export declare function valorInicialDaPropriedade(prop: ItemPropriedade): any;
+/**
+ * Valor comum a todos os itens, ou `VALOR_MISTO` se algum diferir. Lista vazia → `undefined`.
+ */
+export declare function valorComum(valores: readonly unknown[]): any;
+/**
+ * Combina as propriedades dos objetos selecionados: cada chave recebe o valor comum ou
+ * `VALOR_MISTO`. Chave ausente em algum objeto conta como valor diferente.
+ * Uso: `painel.valores = combinarValores(formas.map(f => f.propriedades))`.
+ */
+export declare function combinarValores(registros: readonly unknown[]): Record<string, any>;

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

@@ -10,7 +10,10 @@ export interface ItemPropriedade {
     id: string;
     rotulo: string;
     tipo: TipoPropriedade;
+    /** Valor atual; `VALOR_MISTO` quando difere entre os objetos selecionados (exibe "Varia"). */
     valor: any;
+    /** Atalho para `valor: VALOR_MISTO`: a propriedade difere entre os objetos selecionados. */
+    misto?: boolean;
     unidade?: string;
     casasDecimais?: number;
     opcoes?: OpcaoPropriedade[];
@@ -45,4 +48,6 @@ export interface ContextoEditorPropriedade {
     registrarAlteracao: (categoriaId: string, propId: string, novoValor: any) => void;
     focarProximoEditor: (elementoAtual: HTMLElement) => void;
     despacharEventoAcao: (prop: ItemPropriedade, categoriaId: string) => void;
+    /** Texto exibido para valores mistos (atributo `texto-misto`); padrão "Varia". */
+    obterTextoMisto?: () => string;
 }

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

@@ -11,6 +11,7 @@ export * from './propriedades-painel-controles';
 export * from './propriedades-dom-utils';
 export * from './propriedades-flutuante';
 export * from './propriedades-densidade';
+export * from './propriedades-valor-misto';
 export declare class UITabelaPropriedades extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private shadow;
@@ -39,6 +40,12 @@ export declare class UITabelaPropriedades extends SafeHTMLElement {
     attributeChangedCallback(name: string, oldVal: string | null, newVal: string | null): void;
     get categorias(): CategoriaPropriedades[];
     set categorias(novasCategorias: CategoriaPropriedades[]);
+    /**
+     * Texto exibido nas propriedades cujo valor difere entre os objetos selecionados
+     * (`VALOR_MISTO`). Reflete o atributo `texto-misto`; padrão "Varia".
+     */
+    get textoMisto(): string;
+    set textoMisto(texto: string);
     get tipos(): SeletorTipoItem[];
     set tipos(novosTipos: SeletorTipoItem[]);
     get tipoSelecionado(): string;

package/dist/cores.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const r=require("./ui-seletor-cor-2yGryC_Z.cjs"),e=require("./ui-controle-cores-BLhrZHMh.cjs");exports.PALETA_CORES_PADRAO=r.PALETA_CORES_PADRAO;exports.UISeletorCor=r.UISeletorCor;exports.abrirSeletorCor=r.abrirSeletorCor;exports.coresUnicas=r.coresUnicas;exports.escaparHtml=r.escaparHtml;exports.fecharSeletorCor=r.fecharSeletorCor;exports.normalizarCor=r.normalizarCor;exports.normalizarOpacidade=r.normalizarOpacidade;exports.UIControleCores=e.UIControleCores;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const r=require("./ui-seletor-cor-Ft06TEUH.cjs"),e=require("./ui-controle-cores-CohlwXJK.cjs");exports.PALETA_CORES_PADRAO=r.PALETA_CORES_PADRAO;exports.UISeletorCor=r.UISeletorCor;exports.abrirSeletorCor=r.abrirSeletorCor;exports.coresUnicas=r.coresUnicas;exports.escaparHtml=r.escaparHtml;exports.fecharSeletorCor=r.fecharSeletorCor;exports.normalizarCor=r.normalizarCor;exports.normalizarEspessura=r.normalizarEspessura;exports.normalizarOpacidade=r.normalizarOpacidade;exports.UIControleCores=e.UIControleCores;

package/dist/cores.js

@@ -1,14 +1,15 @@
 /* empty css               */
-import { P as e, U as s, a as t, c as l, e as C, f as c, n as i, b as m } from "./ui-seletor-cor-BuyhoDZz.js";
-import { U as p } from "./ui-controle-cores-BEUKOq4n.js";
+import { P as s, U as e, a as l, c as t, e as i, f as m, n as C, b as c, d as n } from "./ui-seletor-cor-D9iI7yew.js";
+import { U } from "./ui-controle-cores-DMtTUtLk.js";
 export {
-  e as PALETA_CORES_PADRAO,
-  p as UIControleCores,
-  s as UISeletorCor,
-  t as abrirSeletorCor,
-  l as coresUnicas,
-  C as escaparHtml,
-  c as fecharSeletorCor,
-  i as normalizarCor,
-  m as normalizarOpacidade
+  s as PALETA_CORES_PADRAO,
+  U as UIControleCores,
+  e as UISeletorCor,
+  l as abrirSeletorCor,
+  t as coresUnicas,
+  i as escaparHtml,
+  m as fecharSeletorCor,
+  C as normalizarCor,
+  c as normalizarEspessura,
+  n as normalizarOpacidade
 };