@thibezer/ui-components-kit 2.8.2 → 2.10.0

package/dist/card.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});;/* empty css                 */const e=require("./ui-card-B86lJXTP.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-C_o5_0cB.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-avatar/ui-avatar.d.ts

@@ -3,10 +3,21 @@ export declare class UIAvatar extends SafeHTMLElement {
     static get observedAttributes(): string[];
     private avatarElement;
     private statusElement;
+    /** O que este componente escreveu em aria-label / aria-hidden (para distinguir do que o consumidor definiu). */
+    private _rotuloAuto;
+    private _ocultoAuto;
+    private _sincronizando;
     constructor();
     connectedCallback(): void;
     attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
+    /** Iniciais por ponto de código (emoji e caracteres fora do BMP não são cortados ao meio). */
     private extrairIniciais;
+    private lerNome;
+    /**
+     * Nome acessível: com nome, o host é uma imagem nomeada ("Ana, online"); sem nome, é decorativo.
+     * Um `aria-label`/`aria-hidden` definido pelo consumidor nunca é sobrescrito.
+     */
+    private sincronizarAcessibilidade;
     private syncState;
     private renderFallback;
 }

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

@@ -12,6 +12,8 @@ export declare class UIBadge extends SafeHTMLElement {
     get removivel(): boolean;
     set removivel(val: boolean);
     private syncState;
+    get disabled(): boolean;
+    set disabled(val: boolean);
     private handleRemove;
 }
 export declare class UIChip extends UIBadge {

package/dist/components/ui-barra-ferramentas/ferramentas-comum.d.ts

@@ -11,7 +11,9 @@ export declare function criarBotaoFerramenta(item: FerramentaItem, variante: Var
 /** Cria um botão dividido (split button) com ação principal + seta dropdown separada. */
 export declare function criarBotaoDividido(item: FerramentaItem, variante: VarianteBotaoFerramenta, tamanhoIcone: number): HTMLElement;
 export declare function acharItem(itens: FerramentaItem[], id: string): FerramentaItem | undefined;
-export declare function correspondeAtalho(e: KeyboardEvent, atalho: string | undefined): boolean;
+/** O que `correspondeAtalho` lê de um evento de teclado (permite testar com objetos simples). */
+export type TeclaAtalho = Pick<KeyboardEvent, 'key' | 'ctrlKey' | 'metaKey' | 'altKey' | 'shiftKey'>;
+export declare function correspondeAtalho(e: TeclaAtalho, atalho: string | undefined): boolean;
 export declare function definirRoving(botoes: HTMLButtonElement[]): void;
 /** Garante um único botão com tabindex 0, preservando o atual se ainda estiver habilitado. */
 export declare function atualizarRoving(botoes: HTMLButtonElement[]): void;

package/dist/components/ui-barra-ferramentas/paleta-atalhos.d.ts

@@ -0,0 +1,23 @@
+import { FerramentaItem } from './tipos';
+import { TeclaAtalho } from './ferramentas-comum';
+/**
+ * Várias paletas com `atalhos` na mesma página: só a "dona" responde, a que contém o foco ou, sem foco em nenhuma, a
+ * primeira na ordem do DOM. `temFoco` diz se uma paleta contém o foco.
+ */
+export declare function paletaDonaDosAtalhos<T>(paletas: T[], temFoco: (p: T) => boolean): T | undefined;
+/**
+ * `true` se o foco está num campo de digitação (nativo, editável ou customizado) ou dentro de um diálogo modal;
+ * nesses lugares as letras pertencem ao usuário/ao diálogo.
+ */
+export declare function atalhoBloqueadoPeloContexto(caminho: EventTarget[]): boolean;
+export interface AtalhoResolvido {
+    alvo: FerramentaItem;
+    /** Grupo que contém o alvo, se houver. */
+    pai?: FerramentaItem;
+}
+/**
+ * Ferramenta ativada pela tecla. `tecla` é o evento de teclado (atalhos compostos: `Ctrl+Z`, `Shift+V`, `Esc`, via
+ * `correspondeAtalho`) ou só o `key` (uma tecla sem modificadores). Sem diferenciar caixa. Com várias candidatas,
+ * alterna entre elas a partir da ativa. `todas` é a lista plana (grupos expandidos); `grupos` serve para achar o pai.
+ */
+export declare function resolverAtalho(tecla: string | TeclaAtalho, todas: FerramentaItem[], grupos: FerramentaItem[], idAtivo: string): AtalhoResolvido | null;

package/dist/components/ui-barra-ferramentas/paleta-pressao-longa.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Clique longo (pressão) da <ui-paleta-ferramentas>: abre o flyout de um grupo sem ativar a ferramenta.
+ * Responsabilidade única: temporizadores e limiar de movimento da pressão, mais a supressão do `click` residual
+ * que o navegador dispara ao soltar. Não conhece botões nem menus: quem usa decide o que fazer ao disparar.
+ */
+export declare const TEMPO_PRESSAO_LONGA_MS = 380;
+export declare const DISTANCIA_CANCELA_PRESSAO_PX = 8;
+export declare const TEMPO_LIMPA_SUPRESSAO_MS = 50;
+export declare class PressaoLonga {
+    private timer;
+    private timerSupressao;
+    private inicio;
+    private suprimir;
+    /** Começa a contar; `aoDisparar` roda se o ponteiro ficar parado até `TEMPO_PRESSAO_LONGA_MS`. */
+    iniciar(x: number, y: number, aoDisparar: () => void): void;
+    /** Arrastar/rolar com o dedo cancela o clique longo. */
+    mover(x: number, y: number): void;
+    /** Fim do gesto: cancela a contagem e, se o flyout abriu, descarta a supressão logo após o `click` residual. */
+    fim(): void;
+    cancelar(): void;
+    /** `true` (uma única vez) se o próximo `click` deve ser ignorado por ser o resíduo de uma pressão longa. */
+    consumirSupressao(): boolean;
+    destruir(): void;
+}

package/dist/components/ui-barra-ferramentas/ribbon-render.d.ts

@@ -0,0 +1,22 @@
+import { FerramentaItem, RibbonAba, RibbonGrupo } from './tipos';
+/** Botões pequenos consecutivos formam colunas de até 3 (padrão Office/CAD). */
+export declare const MAX_BOTOES_POR_COLUNA = 3;
+export interface OpcoesBotaoAba {
+    aba: RibbonAba;
+    ativa: boolean;
+    /** `id` do botão (para `aria-labelledby` do painel). */
+    idBotao: string;
+    /** `id` do painel (para `aria-controls` da aba ativa). */
+    idPainel: string;
+}
+export declare function criarBotaoAba({ aba, ativa, idBotao, idPainel }: OpcoesBotaoAba): HTMLButtonElement;
+export type CriarBotaoFerramenta = (item: FerramentaItem, variante: 'grande' | 'pequeno', tamanhoIcone: number) => HTMLElement;
+export interface OpcoesGrupoRibbon {
+    /** Sem espaço: o grupo vira um botão único com flyout (o clique é tratado por quem delega os cliques do painel). */
+    colapsado?: boolean;
+    /** Item `dividido` com `filhos`: ação principal + gatilho de menu (`criarBotaoDividido`). */
+    criarDividido?: CriarBotaoFerramenta;
+}
+/** Rótulo acessível do lançador de diálogo do grupo. */
+export declare const rotuloLancador: (grupo: RibbonGrupo) => string;
+export declare function criarGrupoRibbon(grupo: RibbonGrupo, criarBotao: CriarBotaoFerramenta, opcoes?: OpcoesGrupoRibbon): HTMLElement;

package/dist/components/ui-barra-ferramentas/ribbon-teclado.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Teclado das abas do <ui-ribbon> (padrão WAI-ARIA de abas, com ativação automática ou manual).
+ * Responsabilidade única: traduzir uma tecla em uma ação; quem chama executa (foco, seleção, painel).
+ */
+export type AcaoTeclaAba = 
+/** Automática: foca e seleciona a aba. Manual (`ativacao-manual`): só move o foco. */
+{
+    tipo: 'ir-para';
+    indice: number;
+}
+/** Ativação manual: Enter/Espaço selecionam a aba focada. */
+ | {
+    tipo: 'ativar';
+    indice: number;
+}
+/** Seta para baixo: leva o foco aos botões do painel (abrindo o painel flutuante se recolhido). */
+ | {
+    tipo: 'descer';
+};
+/**
+ * `indiceAtual` < 0 (foco fora das abas) ou lista vazia não produzem ação. Em RTL as setas se invertem.
+ * Navegação circular; Home/End vão às pontas.
+ */
+export declare function acaoDaTeclaAba(key: string, indiceAtual: number, total: number, rtl: boolean, manual?: boolean): AcaoTeclaAba | null;

package/dist/components/ui-barra-ferramentas/ui-paleta-ferramentas.d.ts

@@ -26,10 +26,7 @@ export declare class UIPaletaFerramentas extends SafeHTMLElement {
     private _pendente;
     private visiveis;
     private menu;
-    private timerPressao;
-    private timerSupressao;
-    private inicioPressao;
-    private suprimirClique;
+    private pressao;
     private listeners;
     private tooltip;
     private _modoControlado;
@@ -81,13 +78,12 @@ export declare class UIPaletaFerramentas extends SafeHTMLElement {
     private handleClick;
     private handleFocusIn;
     private handlePointerDown;
-    /** Arrastar/rolar com o dedo cancela o clique longo. */
     private handlePointerMove;
-    /** Fim do gesto: cancela o timer e, se o flyout abriu, descarta a supressão logo após o `click` residual. */
     private handlePointerFim;
-    private cancelarPressao;
     private handleContextMenu;
     private handleKeyDown;
+    /** Várias paletas com `atalhos` na página: só a que contém o foco (ou a primeira no DOM) responde. */
+    private donaDosAtalhos;
     private handleAtalho;
     private abrirFlyout;
     private fecharMenu;

package/dist/components/ui-barra-ferramentas/ui-ribbon.d.ts

@@ -54,7 +54,6 @@ export declare class UIRibbon extends SafeHTMLElement {
     private iniciarResizeObserver;
     private ajustarColapsoGrupos;
     private alternarMenuGrupoColapsado;
-    private criarGrupo;
     private criarBotao;
     private botoesPainel;
     private handleClickAbas;

package/dist/components/ui-camadas/camadas-arraste-controles.d.ts

@@ -1,2 +1,4 @@
 import { CamadasHostCompleto } from './camadas-host';
+/** Cancela o gesto do `host`, soltando os ouvintes de `window` e devolvendo `user-select` ao `body`. */
+export declare function cancelarArrasteControles(host: CamadasHostCompleto): void;
 export declare function conectarArrasteControles(host: CamadasHostCompleto, shadow: ShadowRoot): void;

package/dist/components/ui-camadas/camadas-arvore-renderer.d.ts

@@ -1,5 +1,7 @@
 import { CamadaItem, FeicaoItem } from './tipos';
 import { escapeHtml } from './camadas-utils';
+import { renderizarThumbGeometria } from './camadas-thumb';
+import { construirHierarquiaCamadas, CamadaNodoHierarquico } from './camadas-hierarquia';
 export interface ParametrosRenderArvore {
     camadas: CamadaItem[];
     feicoes: FeicaoItem[];
@@ -13,15 +15,6 @@ export interface ParametrosRenderArvore {
     limiteFeicoesPorCamada?: number;
     mostrarBotaoColapsar?: boolean;
 }
-export { escapeHtml };
-export declare function renderizarThumbGeometria(tipo: string | undefined, cor: string, coords?: unknown): string;
-export interface CamadaNodoHierarquico {
-    camada: CamadaItem;
-    depth: number;
-    subcamadas: CamadaNodoHierarquico[];
-}
-/**
- * Organiza a lista de camadas em uma árvore hierárquica de nós baseada em parentId ou children
- */
-export declare function construirHierarquiaCamadas(camadas: CamadaItem[]): CamadaNodoHierarquico[];
+export { escapeHtml, renderizarThumbGeometria, construirHierarquiaCamadas };
+export type { CamadaNodoHierarquico };
 export declare function renderizarArvoreCamadas(params: ParametrosRenderArvore): string;

package/dist/components/ui-camadas/camadas-colecao.d.ts

@@ -0,0 +1,27 @@
+import { CamadaItem, FeicaoItem } from './tipos';
+import { LembrancaCamadas } from './camadas-lembranca';
+/** Estado e ações do painel que as coleções usam. */
+export interface HostColecao {
+    camadas: CamadaItem[];
+    feicoes: FeicaoItem[];
+    expandedLayers: Set<string>;
+    selectedFeatureIds: Set<string>;
+    lastClickedFeatureId: string | null;
+    activeSettingsLayerId: string | null;
+    camadaAtivaId: string | null;
+    readonly persistir: boolean;
+    /** @internal Guarda de origens/remoções e acesso ao storage. */
+    readonly lembranca: LembrancaCamadas;
+    getAttribute(nome: string): string | null;
+    salvarLembrancaEstado(): void;
+    solicitarRenderizacao(): void;
+}
+/** Transforma a árvore (`children`) em lista plana, herdando `parentId` do pai quando não informado. */
+export declare function achatarCamadas(camadas: CamadaItem[], parentId?: string | null): CamadaItem[];
+export declare function definirCamadasNoHost(host: HostColecao, camadas: CamadaItem[], feicoes?: FeicaoItem[]): void;
+export declare function definirFeicoesNoHost(host: HostColecao, feicoes: FeicaoItem[]): void;
+export declare function adicionarCamadaNoHost(host: HostColecao, camada: CamadaItem): void;
+export declare function removerCamadaNoHost(host: HostColecao, camadaId: string): void;
+export declare function adicionarFeicaoNoHost(host: HostColecao, feicao: FeicaoItem): void;
+export declare function atualizarFeicaoNoHost(host: HostColecao, feicaoAtualizada: FeicaoItem): void;
+export declare function removerFeicaoNoHost(host: HostColecao, feicaoId: string): void;

package/dist/components/ui-camadas/camadas-drag-drop.d.ts

@@ -4,6 +4,8 @@ export interface UICamadasHost {
     feicoes: FeicaoItem[];
     editingLayerId: string | null;
     editingFeatureId: string | null;
+    /** Camadas expandidas; ao aninhar uma camada, o pai se expande. */
+    expandedLayers?: Set<string>;
     solicitarRenderizacao(): void;
     dispararEvento(nome: string, detalhe: unknown): void;
     salvarLembrancaEstado?(): void;
@@ -11,12 +13,22 @@ export interface UICamadasHost {
 export declare class CamadasDragDropManager {
     private host;
     private shadow;
+    /** Cancela um arraste por toque em andamento (remove os ouvintes de `window`). */
+    private cancelarToque;
     constructor(host: UICamadasHost, shadow: ShadowRoot);
     bindAll(): void;
+    /** Solta o que ficou em `window` (arraste por toque interrompido pela desconexão do componente). */
+    destruir(): void;
     bindInlineRename(): void;
+    private limparClassesDeArraste;
+    /** Depois de qualquer mudança na ordem/hierarquia de camadas. */
+    private aposReordenarCamadas;
+    private emitirFeicaoMovida;
+    private arrasteBloqueado;
     bindDragAndDrop(): void;
     /**
-     * Suporte a arraste por toque e ponteiro no handle (.ui-col-drag) para tablets e mobile
+     * Suporte a arraste por toque e ponteiro no handle (.ui-col-drag) para tablets e mobile.
+     * Os ouvintes de `window` existem só durante o gesto e são soltos em `destruir()`.
      */
     bindTouchDragAndDrop(): void;
 }

package/dist/components/ui-camadas/camadas-drop-ops.d.ts

@@ -0,0 +1,31 @@
+import { CamadaItem, FeicaoItem } from './tipos';
+export type ZonaDrop = 'acima' | 'abaixo' | 'dentro';
+/** Evita ciclos hierárquicos ao mover uma camada para dentro de outra. */
+export declare function ehDescendente(camadas: CamadaItem[], possivelDescendenteId: string, ancestralId: string): boolean;
+/** Zona do alvo pela posição vertical relativa (0..1): 25% de cima, 25% de baixo e o meio (aninhar). */
+export declare function zonaDeDropCamada(posicaoRelativa: number): ZonaDrop;
+export type ResultadoMoverCamada = {
+    tipo: 'hierarquia';
+    camada: CamadaItem;
+    novoParentId: string;
+} | {
+    tipo: 'ordem';
+    camada: CamadaItem;
+};
+/**
+ * Move `movidaId` em relação a `alvoId`. `dentro` torna-a subcamada (recusa ciclos); `acima`/`abaixo`
+ * reordena e adota o pai do alvo. Muta `camadas`; devolve `null` se nada mudou.
+ */
+export declare function moverCamada(camadas: CamadaItem[], movidaId: string, alvoId: string, zona: ZonaDrop): ResultadoMoverCamada | null;
+/** Reordena apenas (sem aninhar), como no arraste por toque. Muta `camadas`; `false` se nada mudou. */
+export declare function reordenarCamada(camadas: CamadaItem[], movidaId: string, alvoId: string, acima: boolean): boolean;
+export interface ResultadoMoverFeicao {
+    feicao: FeicaoItem;
+    camadaOrigemId: string | undefined;
+    camadaDestinoId: string | undefined;
+    mudouDeCamada: boolean;
+}
+/** Move a feição para outra camada (sem reordenar). `null` se a feição/camada não existe ou já está lá. */
+export declare function moverFeicaoParaCamada(feicoes: FeicaoItem[], camadas: CamadaItem[], feicaoId: string, camadaDestinoId: string): ResultadoMoverFeicao | null;
+/** Reordena a feição em relação a outra, adotando a camada do alvo. Muta `feicoes`; `null` se nada mudou. */
+export declare function reordenarFeicao(feicoes: FeicaoItem[], movidaId: string, alvoId: string, acima: boolean): ResultadoMoverFeicao | null;

package/dist/components/ui-camadas/camadas-hierarquia.d.ts

@@ -0,0 +1,10 @@
+import { CamadaItem } from './tipos';
+export interface CamadaNodoHierarquico {
+    camada: CamadaItem;
+    depth: number;
+    subcamadas: CamadaNodoHierarquico[];
+}
+/**
+ * Organiza a lista de camadas em uma árvore hierárquica de nós baseada em parentId ou children
+ */
+export declare function construirHierarquiaCamadas(camadas: CamadaItem[]): CamadaNodoHierarquico[];

package/dist/components/ui-camadas/camadas-host.d.ts

@@ -12,6 +12,7 @@ export interface CamadasHostCompleto extends UICamadasHost {
     readonly mapaBaseAtivo: string;
     definirCamadaAtiva(camadaId: string, emitirEvento?: boolean): void;
     selecionarMapaBase(id: string, emitirEvento?: boolean): void;
+    alternarMapasBaseRecolhido(emitirEvento?: boolean): void;
     selecionarFeicao(feicaoId: string, acumular?: boolean, intervalo?: boolean, emitirEvento?: boolean): void;
     limparSelecao(emitirEvento?: boolean): void;
     notificarMudancaSelecao(): void;

package/dist/components/ui-camadas/camadas-lembranca.d.ts

@@ -0,0 +1,34 @@
+import { CamadaItem } from './tipos';
+import { EstadoPersistidoCamadas as EstadoPersistido } from './camadas-persistencia';
+/** Leitura do estado atual do painel no momento de gravar. */
+export interface InstantaneoPainel {
+    persistir: boolean;
+    conectado: boolean;
+    storageKey: string | null;
+    id: string;
+    camadas: CamadaItem[];
+    expandedLayers: Set<string>;
+    camadaAtivaId: string | null;
+    painelColapsado: boolean;
+    mapaBaseAtivo: string;
+    densidade: 'compacto' | 'normal';
+    altura: number | null;
+}
+export declare class LembrancaCamadas {
+    private instantaneo;
+    private origens;
+    private removidas;
+    private salvarComDebounce;
+    constructor(instantaneo: () => InstantaneoPainel);
+    chaveAtual(): string;
+    carregar(): EstadoPersistido | null;
+    /** Versão com debounce, para interações contínuas (seletor de cor, slider de opacidade). */
+    agendar(): void;
+    salvar(): void;
+    limpar(): void;
+    limparOrigens(): void;
+    registrarOrigem(camada: CamadaItem): void;
+    esquecerCamada(camadaId: string): void;
+    /** Aplica por cima de `camadas` o que foi lembrado (expansão, visibilidade, travas, opacidade, cor, ordem). */
+    reidratar(camadas: CamadaItem[], estado: EstadoPersistido | null, expandedLayers: Set<string>): void;
+}

package/dist/components/ui-camadas/camadas-mapas-base.d.ts

@@ -1,3 +1,5 @@
 import { MapaBaseItem } from './tipos';
 export declare const MAPAS_BASE_PADRAO: MapaBaseItem[];
-export declare function renderizarGridMapasBase(mapasBase?: MapaBaseItem[], mapaBaseAtivo?: string): string;
+/** Nome do mapa base ativo, para o cabeçalho da seção (vazio se o id não existir na lista). */
+export declare function nomeDoMapaBase(mapasBase: MapaBaseItem[], id: string): string;
+export declare function renderizarGridMapasBase(mapasBase?: MapaBaseItem[], mapaBaseAtivo?: string, recolhido?: boolean): string;

package/dist/components/ui-camadas/camadas-render.d.ts

@@ -0,0 +1,15 @@
+import { MapaBaseItem } from './tipos';
+import { CamadasHostCompleto } from './camadas-host';
+import { CamadasDragDropManager } from './camadas-drag-drop';
+/** O que a renderização lê do componente (além do contrato de eventos). */
+export interface HostRenderizavel extends CamadasHostCompleto {
+    mapasBase: MapaBaseItem[];
+    editingLayerId: string | null;
+    editingFeatureId: string | null;
+    readonly flutuante: boolean;
+    readonly mostrarMapasBase: boolean;
+    readonly mapasBaseRecolhido: boolean;
+    readonly mostrarRodape: boolean;
+    getAttribute(nome: string): string | null;
+}
+export declare function renderizarPainel(host: HostRenderizavel, shadow: ShadowRoot, corpo: HTMLElement, dragDrop: CamadasDragDropManager): void;

package/dist/components/ui-camadas/camadas-renomear.d.ts

@@ -0,0 +1,12 @@
+import { CamadaItem, FeicaoItem } from './tipos';
+/** O que o renomear lê e altera no painel. */
+export interface HostRenomear {
+    camadas: CamadaItem[];
+    feicoes: FeicaoItem[];
+    editingLayerId: string | null;
+    editingFeatureId: string | null;
+    solicitarRenderizacao(): void;
+    dispararEvento(nome: string, detalhe: unknown): void;
+    salvarLembrancaEstado?(): void;
+}
+export declare function vincularRenomearInline(host: HostRenomear, shadow: ShadowRoot): void;

package/dist/components/ui-camadas/camadas-selecao-api.d.ts

@@ -0,0 +1,17 @@
+import { CamadaItem, FeicaoItem } from './tipos';
+/** Estado e ações do painel que a seleção usa. */
+export interface HostSelecao {
+    camadas: CamadaItem[];
+    feicoes: FeicaoItem[];
+    expandedLayers: Set<string>;
+    selectedFeatureIds: Set<string>;
+    lastClickedFeatureId: string | null;
+    searchQuery: string;
+    sincronizarSelecaoDOM(): void;
+    notificarMudancaSelecao(): void;
+    dispararEvento(nome: string, detalhe: unknown): void;
+}
+export declare function selecionarFeicaoNoHost(host: HostSelecao, feicaoId: string, acumular: boolean, intervalo: boolean, emitirEvento: boolean): void;
+export declare function selecionarFeicoesNoHost(host: HostSelecao, ids: string[], emitirEvento: boolean): void;
+export declare function limparSelecaoNoHost(host: HostSelecao, emitirEvento: boolean): void;
+export declare function emitirEventosSelecao(host: HostSelecao): void;

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

@@ -8,6 +8,18 @@ export declare const LIMITE_FEICOES_POR_CAMADA = 80;
  * Filtra feições pelo termo de busca (nome, categoria ou tipo). Sem termo, retorna todas.
  */
 export declare function filtrarFeicoesPorBusca(feicoes: FeicaoItem[], termo: string): FeicaoItem[];
+export interface ResultadoBuscaCamadas {
+    /** Camadas que permanecem na árvore: as que casam, seus ancestrais e as subcamadas de quem casa pelo nome. */
+    camadasVisiveis: Set<string>;
+    /** Feições mostradas em cada camada visível (todas, se a camada casa pelo nome; senão, só as que casam). */
+    feicoesPorCamada: Map<string, FeicaoItem[]>;
+}
+/**
+ * Busca em toda a árvore: casa pelo nome da camada ou pelos dados das feições (ver `filtrarFeicoesPorBusca`).
+ * Mantém os grupos ancestrais de cada resultado e, quando um grupo casa pelo nome, suas subcamadas.
+ * Sem termo, retorna `null` (nada a filtrar). Tolera nomes ausentes e ciclos de `parentId`.
+ */
+export declare function filtrarCamadasPorBusca(camadas: CamadaItem[], feicoes: FeicaoItem[], termo: string): ResultadoBuscaCamadas | null;
 /**
  * IDs de feições efetivamente exibidas na árvore, na ordem da tela:
  * respeita camadas expandidas (todas, durante uma busca), o filtro de busca e o limite de linhas.

package/dist/components/ui-camadas/camadas-thumb.d.ts

@@ -0,0 +1 @@
+export declare function renderizarThumbGeometria(tipo: string | undefined, cor: string, coords?: unknown): string;