@thibezer/ui-components-kit 2.8.2 → 2.9.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-BrjBL-yo.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-BNYCQ7g-.js";
 export {
   m as UICard
 };

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;

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

@@ -1,6 +1,7 @@
 import { SafeHTMLElement } from '../../core/ssr-safe';
 import { CamadaItem, FeicaoItem, MapaBaseItem, AbaPainelCamadas } from './tipos';
 import { CamadasHostCompleto } from './camadas-host';
+import { LembrancaCamadas } from './camadas-lembranca';
 export declare class UICamadas extends SafeHTMLElement implements CamadasHostCompleto {
     static get observedAttributes(): string[];
     private shadow;
@@ -11,11 +12,10 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     private conectado;
     private profundidadeLote;
     private renderPendente;
-    private camadasRemovidas;
     /** Painéis conectados sem `id` nem `storage-key`: dividem a mesma chave de persistência. */
     private static instanciasChavePadrao;
-    private origensCamadas;
-    private salvarLembrancaDebounced;
+    /** @internal */
+    readonly lembranca: LembrancaCamadas;
     camadas: CamadaItem[];
     feicoes: FeicaoItem[];
     mapasBase: MapaBaseItem[];
@@ -40,6 +40,11 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     set mapaBaseAtivo(valor: string);
     selecionarMapaBase(id: string, emitirEvento?: boolean): void;
     private marcarMapaBaseAtivoNoDOM;
+    /** Seção "Mapa Base" recolhida (só o cabeçalho com o mapa ativo). Atributo `mapas-base-recolhido`. */
+    get mapasBaseRecolhido(): boolean;
+    set mapasBaseRecolhido(valor: boolean);
+    /** Alterna a seção de mapas base; com `emitirEvento`, dispara `ui-mapas-base-recolhimento`. */
+    alternarMapasBaseRecolhido(emitirEvento?: boolean): void;
     get abaAtiva(): AbaPainelCamadas;
     set abaAtiva(aba: AbaPainelCamadas);
     get colapsado(): boolean;
@@ -79,7 +84,6 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     /** Atalho reativo para `definirMapasBase()` — não dispara eventos. */
     get basemaps(): MapaBaseItem[];
     set basemaps(mapas: MapaBaseItem[]);
-    private achatarCamadas;
     definirCamadas(camadas: CamadaItem[], feicoes?: FeicaoItem[]): void;
     definirFeicoes(feicoes: FeicaoItem[]): void;
     definirMapasBase(mapas: MapaBaseItem[]): void;
@@ -114,7 +118,6 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     private conectarEventosGerais;
     private sincronizarCamadaAtivaDOM;
     sincronizarSelecaoDOM(): void;
-    private sincronizarSelecoesComFeicoesValidas;
     notificarMudancaSelecao(): void;
 }
 export declare class UIPainelCamadas extends UICamadas {

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

@@ -0,0 +1,15 @@
+/**
+ * Acessibilidade do <ui-canvas-cad>.
+ * Responsabilidade única: nomes acessíveis dos botões da barra rápida, estado `aria-pressed` do snap e anúncios
+ * (região viva) de seleção e ferramenta para leitores de tela.
+ */
+/** Botões só com ícone ganham `aria-label` igual ao `title`; `aria-label` já definido é respeitado. */
+export declare function nomearBotoesDaBarra(shadow: ShadowRoot): void;
+/** Reflete o snap ligado/desligado no botão da barra. */
+export declare function marcarSnap(shadow: ShadowRoot, ligado: boolean): void;
+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. */
+export declare function conectarAnuncios(host: HTMLElement, shadow: ShadowRoot): () => void;

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

@@ -1,3 +1,4 @@
+import { ScaleMode } from '../../gerencigeo-canvas/types';
 import { UICanvasCAD } from './ui-canvas-cad';
 import { GerenciadorBroadcastConfig } from './cad-broadcast';
 import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
@@ -7,7 +8,7 @@ export interface ContextoAtributosCAD {
     mapContainer: HTMLDivElement | null;
     broadcastConfig: GerenciadorBroadcastConfig;
     setLayerOpacity: (id: string, op: number) => void;
-    setLayerScaleMode: (id: string, mode: any) => void;
+    setLayerScaleMode: (id: string, mode: ScaleMode) => void;
     atualizarZonaProjecao: (zona: number) => void;
 }
 export declare function sincronizarAtributoCAD(ctx: ContextoAtributosCAD, name: string, oldVal: string, newVal: string): void;

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

@@ -14,6 +14,6 @@ export declare class GerenciadorBroadcastConfig {
     private contexto;
     constructor(contexto: ContextoBroadcastCAD);
     conectar(canalNome?: string | null): void;
-    processarMensagem(data: any): void;
+    processarMensagem(entrada: unknown): void;
     desconectar(): void;
 }

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

@@ -0,0 +1,22 @@
+import { EventoMapaCad, LatLngEvento } from './tipos';
+export interface PontoPixel {
+    x: number;
+    y: number;
+}
+/** Evento "de baixo": o `originalEvent` do Leaflet quando existe, senão o próprio evento. */
+export declare function eventoOriginalDe(e: unknown): EventoMapaCad;
+/** Primeiro alvo do evento: `composedPath()[0]` (atravessa o shadow DOM) ou `target`. */
+export declare function alvoDoEvento(e: unknown): HTMLElement | null;
+/**
+ * Ponto em pixels relativo ao contêiner: o parâmetro explícito, depois `containerPoint`/`layerPoint` do evento
+ * e, por fim, `clientX/clientY` descontando o retângulo do contêiner.
+ */
+export declare function pontoPixelDe(e: unknown, explicito: PontoPixel | undefined, retanguloContainer: {
+    left: number;
+    top: number;
+}): PontoPixel;
+/** Latitude/longitude do parâmetro explícito ou do evento (aceita `lon` no lugar de `lng`); `null` se não houver número em `lat`. */
+export declare function latLngDe(e: unknown, explicito?: LatLngEvento): {
+    lat: number;
+    lng: number;
+} | null;

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

@@ -1,4 +1,6 @@
 import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
+import { EventoMapaCad, LatLngEvento } from './tipos';
+import { PontoPixel } from './cad-evento-coordenadas';
 export interface ContextoEventosCanvas {
     host: HTMLElement;
     controller: GerenciGeoMapaController;
@@ -8,14 +10,7 @@ export interface ContextoEventosCanvas {
     obterElementoPorId: (id: string | number) => any;
     fecharPopup: () => void;
 }
-export declare function processarCliqueLivreCanvas(ctx: ContextoEventosCanvas, e: MouseEvent | any, latLngParam?: {
-    lat: number;
-    lng?: number;
-    lon?: number;
-}, containerPointParam?: {
-    x: number;
-    y: number;
-}): boolean;
+export declare function processarCliqueLivreCanvas(ctx: ContextoEventosCanvas, e: MouseEvent | EventoMapaCad, latLngParam?: LatLngEvento, containerPointParam?: PontoPixel): boolean;
 export declare function processarAcaoPopup(ctx: ContextoEventosCanvas, acaoId: string, elementoId: string | number, elemento?: any): void;
 export declare function tratarCliqueMarcador(ctx: ContextoEventosCanvas, pId: string | number, isVizinho: boolean | undefined, elemento: any, coords: {
     lat: number;

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

@@ -0,0 +1,26 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { Feicao } from '../../gerencigeo-canvas/feature_types';
+import { RefFeicao } from '../../gerencigeo-canvas/feature_selecao';
+export interface PortasCamera {
+    obterMapa: () => L.Map | null;
+    obterLayerManager: () => CanvasLayerManager;
+    buscar: (camadaId: string, id: string) => Feicao | undefined;
+    lista: (camadaId: string) => Feicao[];
+    desenhada: (f: Feicao) => boolean;
+    /** Liga a camada e a prévia da feição, se estiverem escondidas. */
+    garantirVisivel: (f: Feicao) => void;
+}
+export declare class CameraFeicoes {
+    private p;
+    constructor(p: PortasCamera);
+    private limitesDe;
+    private enquadrar;
+    /** Aproxima da feição; liga a camada e a prévia, se estiverem escondidas. Ponto: voa até z ≥ 17. */
+    zoomParaFeicao(camadaId: string, id: string): boolean;
+    zoomParaFeicoes(refs: RefFeicao[]): boolean;
+    /** Enquadra todas as feições das camadas de feições visíveis (que aparecem pela regra de versões). */
+    ajustarTudo(): boolean;
+    /** Enquadra a camada inteira; se estava oculta, torna-a visível. */
+    ajustarCamada(camadaId: string): boolean;
+}