@thibezer/ui-components-kit 1.0.0

package/dist/card.cjs

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

package/dist/card.d.ts

@@ -0,0 +1,7 @@
+import { UICard } from './components/ui-card';
+export * from './components/ui-card';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ui-card': UICard;
+    }
+}

package/dist/card.js

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

package/dist/components/ui-alerta/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ui-alerta';
+export * from './ui-toast';

package/dist/components/ui-alerta/ui-alerta-base.d.ts

@@ -0,0 +1,23 @@
+import { ListenerBag } from '../../core/listener-bag';
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export declare const ICONES_ALERTA: Record<string, string>;
+export declare class UIAlerta extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    protected alertaElement: HTMLDivElement;
+    protected iconeElement: HTMLSpanElement;
+    protected tituloElement: HTMLHeadingElement;
+    protected mensagemElement: HTMLParagraphElement;
+    protected mensagemTextoElement: HTMLSpanElement;
+    protected closeElement: HTMLButtonElement;
+    protected acoesElement: HTMLDivElement;
+    protected botaoAcaoElement: HTMLButtonElement;
+    protected progressoContainer: HTMLDivElement;
+    protected progressoBarra: HTMLDivElement;
+    protected listeners: ListenerBag;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
+    fechar(): void;
+    protected syncState(): void;
+}

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

@@ -0,0 +1,2 @@
+export * from './ui-alerta-base';
+export * from './ui-toast';

package/dist/components/ui-alerta/ui-toast.d.ts

@@ -0,0 +1,34 @@
+import { UIAlerta } from './ui-alerta-base';
+export interface UIToastAcao {
+    rotulo: string;
+    onClick: (e: MouseEvent) => void;
+    tipo?: 'primario' | 'secundario' | 'destrutivo';
+}
+export interface UIToastOpcoes {
+    tipo?: 'sucesso' | 'erro' | 'alerta' | 'info';
+    titulo?: string;
+    mensagem: string;
+    duracao?: number;
+    posicao?: 'bottom-right' | 'top-right' | 'bottom-left' | 'top-left' | 'bottom-center' | 'top-center';
+    acao?: UIToastAcao;
+    fechavel?: boolean;
+    pausarNoHover?: boolean;
+}
+export declare class UIToast extends UIAlerta {
+    private timerId;
+    private tempoRestante;
+    private inicioTimestamp;
+    private isPausado;
+    private acaoConfig?;
+    private containerRef;
+    configurarAcao(acao: UIToastAcao): void;
+    connectedCallback(): void;
+    fechar(): void;
+    disconnectedCallback(): void;
+    private handleAcaoClick;
+    private iniciarTimer;
+    private pausarTimer;
+    private retomarTimer;
+    private static obterContainer;
+    static notificar(opcoes: UIToastOpcoes): any;
+}

package/dist/components/ui-avatar/index.d.ts

@@ -0,0 +1 @@
+export * from './ui-avatar';

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

@@ -0,0 +1,12 @@
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export declare class UIAvatar extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private avatarElement;
+    private statusElement;
+    constructor();
+    connectedCallback(): void;
+    attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
+    private extrairIniciais;
+    private syncState;
+    private renderFallback;
+}

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

@@ -0,0 +1 @@
+export * from './ui-badge';

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

@@ -0,0 +1,20 @@
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export declare class UIBadge extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private badgeElement;
+    private labelElement;
+    private closeElement;
+    private listeners;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
+    get removivel(): boolean;
+    set removivel(val: boolean);
+    private syncState;
+    private handleRemove;
+}
+export declare class UIChip extends UIBadge {
+}
+export declare class UITag extends UIBadge {
+}

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

@@ -0,0 +1,22 @@
+import { FerramentaItem } from './tipos';
+export type VarianteBotaoFerramenta = 'grande' | 'pequeno' | 'paleta';
+export declare function criarIcone(icone: string | undefined, tamanho: number): HTMLElement | null;
+export declare function textoTooltip(item: FerramentaItem): string;
+export declare function aplicarEstadoBotao(btn: HTMLButtonElement, item: FerramentaItem): void;
+export declare function criarBotaoFerramenta(item: FerramentaItem, variante: VarianteBotaoFerramenta, tamanhoIcone: number): HTMLButtonElement;
+export declare function acharItem(itens: FerramentaItem[], id: string): FerramentaItem | undefined;
+export declare function definirRoving(botoes: HTMLButtonElement[]): void;
+/** Move o foco entre botões com as setas informadas. Retorna true se tratou a tecla. */
+export declare function navegarRoving(e: KeyboardEvent, botoes: HTMLButtonElement[], teclasAnterior: string[], teclasProximo: string[]): boolean;
+export interface OpcoesMenu {
+    lado?: 'baixo' | 'direita';
+    /** Foca o primeiro item ao abrir (abertura por teclado). */
+    focar?: boolean;
+    onFechar?: () => void;
+}
+export interface MenuHandle {
+    elemento: HTMLElement;
+    ancora: HTMLElement;
+    fechar(): void;
+}
+export declare function abrirMenu(raiz: ShadowRoot, ancora: HTMLElement, itens: FerramentaItem[], onEscolher: (item: FerramentaItem) => void, opcoes?: OpcoesMenu): MenuHandle;

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

@@ -0,0 +1,24 @@
+export declare const ICONES_FERRAMENTAS: {
+    readonly selecionar: string;
+    readonly mover: string;
+    readonly mao: string;
+    readonly zoom: string;
+    readonly linha: string;
+    readonly polilinha: string;
+    readonly retangulo: string;
+    readonly circulo: string;
+    readonly arco: string;
+    readonly ponto: string;
+    readonly texto: string;
+    readonly caneta: string;
+    readonly medir: string;
+    readonly camadas: string;
+    readonly grade: string;
+    readonly desfazer: string;
+    readonly refazer: string;
+    readonly colar: string;
+    readonly copiar: string;
+    readonly negrito: string;
+    readonly italico: string;
+};
+export type NomeIconeFerramenta = keyof typeof ICONES_FERRAMENTAS;

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

@@ -0,0 +1,4 @@
+export * from './tipos';
+export * from './ferramentas-icones';
+export * from './ui-ribbon';
+export * from './ui-paleta-ferramentas';

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

@@ -0,0 +1,55 @@
+/**
+ * Tipos compartilhados pelos componentes de barra de ferramentas:
+ *  - <ui-ribbon>              → abas + grupos (estilo AutoCAD / Word / Excel)
+ *  - <ui-paleta-ferramentas>  → paleta com flyouts (estilo Illustrator / Photoshop)
+ */
+/**
+ * - `botao`      ação pontual (Desfazer, Colar…). Padrão no ribbon.
+ * - `toggle`     liga/desliga de forma independente (Negrito, Grade…).
+ * - `ferramenta` seleção exclusiva: só uma ativa por vez (Mover, Linha…). Padrão na paleta.
+ * - `menu`       abre um menu com `filhos` (ribbon).
+ * - `separador`  divisor visual.
+ */
+export type TipoFerramenta = 'botao' | 'toggle' | 'ferramenta' | 'menu' | 'separador';
+export interface FerramentaItem {
+    id: string;
+    rotulo?: string;
+    /** Nome de um ícone do <ui-icone> ou um trecho `<svg>…</svg>` confiável. */
+    icone?: string;
+    /** Tecla de atalho exibida no tooltip/menu. Na paleta, com o atributo `atalhos`, também é ativa. */
+    atalho?: string;
+    tipo?: TipoFerramenta;
+    ativo?: boolean;
+    disabled?: boolean;
+    /** Apenas ribbon: botão grande (ícone sobre o rótulo) ou pequeno (em colunas de 3). Padrão: 'pequeno'. */
+    tamanho?: 'grande' | 'pequeno';
+    /** Apenas ribbon: oculta o rótulo em botões pequenos. */
+    somenteIcone?: boolean;
+    /** Ribbon: itens do menu suspenso. Paleta: ferramentas agrupadas (flyout). */
+    filhos?: FerramentaItem[];
+}
+export interface RibbonGrupo {
+    id: string;
+    rotulo: string;
+    itens: FerramentaItem[];
+}
+export interface RibbonAba {
+    id: string;
+    rotulo: string;
+    grupos: RibbonGrupo[];
+    /** Aba contextual (destacada, ex.: "Edição de Polilinha"). */
+    contextual?: boolean;
+    /** Aba oculta até ser habilitada via `definirAbaVisivel`. */
+    oculta?: boolean;
+}
+export interface FerramentaDetail {
+    id: string;
+    item: FerramentaItem;
+    /** Item pai quando o disparo veio de um menu/flyout. */
+    pai?: FerramentaItem;
+    /** Estado atual para itens `toggle` / `ferramenta`. */
+    ativo?: boolean;
+    origem: 'ribbon' | 'paleta';
+    /** Apenas ribbon: id da aba ativa no momento do disparo. */
+    aba?: string;
+}

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

@@ -0,0 +1,54 @@
+import { FerramentaItem } from './tipos';
+import { SafeHTMLElement } from '../../core/ssr-safe';
+/**
+ * <ui-paleta-ferramentas> — paleta de ferramentas (estilo Illustrator / Photoshop).
+ *
+ * - Itens com `filhos` viram um grupo: mostra a última ferramenta usada e abre um flyout
+ *   com clique longo, botão direito ou seta (→ na vertical, ↓ na horizontal).
+ * - Ferramentas (`tipo` padrão) são exclusivas; `toggle` liga/desliga; `botao` só dispara ação.
+ * - Com o atributo `atalhos`, a tecla `atalho` do item ativa a ferramenta; teclas repetidas
+ *   entre itens percorrem o grupo (como Shift+letra no Photoshop).
+ *
+ * Atributos: valor, orientacao (vertical|horizontal), colunas (1|2), tamanho (sm|md|lg), atalhos
+ * Propriedades: ferramentas, valor
+ * Métodos: ativar(id), atualizarItem(id, parcial)
+ * Eventos: ui-change / ui-selecionar { valor, item, anterior }, ui-ferramenta { id, item, pai?, ativo?, origem }
+ */
+export declare class UIPaletaFerramentas extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private rootElement;
+    private _ferramentas;
+    private _ativo;
+    private visiveis;
+    private menu;
+    private timerPressao;
+    private suprimirClique;
+    private listeners;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    get ferramentas(): FerramentaItem[];
+    set ferramentas(val: FerramentaItem[]);
+    get valor(): string;
+    set valor(id: string);
+    get value(): string;
+    set value(id: string);
+    /** Ativa uma ferramenta (exclusiva). Se estiver dentro de um grupo, ela passa a ser a exibida. */
+    ativar(id: string, emitir?: boolean): void;
+    atualizarItem(id: string, parcial: Partial<FerramentaItem>): void;
+    private definirAtivoInterno;
+    private itemExibido;
+    private todasFerramentas;
+    private renderizar;
+    private botoes;
+    private acionar;
+    private handleClick;
+    private handlePointerDown;
+    private cancelarPressao;
+    private handleContextMenu;
+    private handleKeyDown;
+    private handleAtalho;
+    private abrirFlyout;
+    private fecharMenu;
+}

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

@@ -0,0 +1,52 @@
+import { FerramentaItem, RibbonAba } from './tipos';
+import { SafeHTMLElement } from '../../core/ssr-safe';
+/**
+ * <ui-ribbon> — barra de ferramentas em abas com grupos (estilo AutoCAD / Word / Excel).
+ *
+ * Atributos: aba-ativa, recolhido, compacto
+ * Propriedades: abas, abaAtiva, recolhido
+ * Métodos: atualizarItem(id, parcial), definirAbaVisivel(id, visivel), selecionarAba(id)
+ * Eventos: ui-ferramenta { id, item, pai?, ativo?, origem, aba }, ui-aba-change { id, aba }
+ */
+export declare class UIRibbon extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private rootElement;
+    private abasElement;
+    private gruposElement;
+    private _abas;
+    private _abaAtiva;
+    private menu;
+    private listeners;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    get abas(): RibbonAba[];
+    set abas(val: RibbonAba[]);
+    get abaAtiva(): string;
+    set abaAtiva(id: string);
+    get recolhido(): boolean;
+    set recolhido(val: boolean);
+    selecionarAba(id: string, emitir?: boolean): void;
+    definirAbaVisivel(id: string, visivel: boolean): void;
+    /** Atualiza um item (estado ou aparência) sem precisar recriar as abas. */
+    atualizarItem(id: string, parcial: Partial<FerramentaItem>): void;
+    private abasVisiveis;
+    private renderizar;
+    private renderizarAbas;
+    private renderizarPainel;
+    private criarGrupo;
+    private criarBotao;
+    private botoesPainel;
+    private handleClickAbas;
+    private handleDblClickAbas;
+    private handleKeyDownAbas;
+    private handleClickGrupos;
+    private handleKeyDownGrupos;
+    private handleEscape;
+    private handlePointerDownFora;
+    private acionar;
+    private alternarMenu;
+    private fecharMenu;
+    private emitir;
+}

package/dist/components/ui-botao/index.d.ts

@@ -0,0 +1 @@
+export * from './ui-botao';

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

@@ -0,0 +1,26 @@
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export type VarianteBotao = 'primary' | 'primario' | 'secondary' | 'secundario' | 'ghost' | 'terciario' | 'destructive' | 'destrutivo' | 'erro' | 'icon-only' | 'icone' | 'destaque' | 'outline' | 'borda';
+export declare class UIBotao extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private button;
+    private spinnerContainer;
+    private slotElement;
+    private opticalState;
+    private listeners;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
+    get carregando(): boolean;
+    set carregando(val: boolean);
+    private handleSlotChange;
+    /**
+     * Remove espaços e quebras de linha fantasmas no slot e identifica
+     * se há ícone no início ou fim para aplicar compensação óptica de padding.
+     */
+    private sanitizeAndBalanceContent;
+    private syncState;
+    private handleClick;
+}
+export declare class UIBotaoPrimario extends UIBotao {
+}

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

@@ -0,0 +1,18 @@
+import { CamadaItem, FeicaoItem } from './tipos';
+import { escapeHtml } from './camadas-utils';
+export interface ParametrosRenderArvore {
+    camadas: CamadaItem[];
+    feicoes: FeicaoItem[];
+    camadaAtivaId: string | null;
+    expandedLayers: Set<string>;
+    selectedFeatureIds: Set<string>;
+    activeSettingsLayerId: string | null;
+    editingLayerId: string | null;
+    editingFeatureId: string | null;
+    searchQuery: string;
+    limiteFeicoesPorCamada?: number;
+    mostrarBotaoColapsar?: boolean;
+}
+export { escapeHtml };
+export declare function renderizarThumbGeometria(tipo: string | undefined, cor: string): string;
+export declare function renderizarArvoreCamadas(params: ParametrosRenderArvore): string;

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

@@ -0,0 +1,18 @@
+import { CamadaItem, FeicaoItem } from './tipos';
+export interface UICamadasHost {
+    camadas: CamadaItem[];
+    feicoes: FeicaoItem[];
+    editingLayerId: string | null;
+    editingFeatureId: string | null;
+    solicitarRenderizacao(): void;
+    dispararEvento(nome: string, detalhe: unknown): void;
+    salvarLembrancaEstado?(): void;
+}
+export declare class CamadasDragDropManager {
+    private host;
+    private shadow;
+    constructor(host: UICamadasHost, shadow: ShadowRoot);
+    bindAll(): void;
+    bindInlineRename(): void;
+    bindDragAndDrop(): void;
+}

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

@@ -0,0 +1,2 @@
+import { CamadasHostCompleto } from './camadas-host';
+export declare function conectarEventosArvore(host: CamadasHostCompleto, shadow: ShadowRoot): void;

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

@@ -0,0 +1,2 @@
+import { CamadasHostCompleto } from './camadas-host';
+export declare function conectarEventosCamadas(host: CamadasHostCompleto, shadow: ShadowRoot): void;

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

@@ -0,0 +1,2 @@
+import { CamadasHostCompleto } from './camadas-host';
+export declare function conectarEventosRodape(host: CamadasHostCompleto, shadow: ShadowRoot): void;

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

@@ -0,0 +1,23 @@
+import { UICamadasHost } from './camadas-drag-drop';
+export interface CamadasHostCompleto extends UICamadasHost {
+    expandedLayers: Set<string>;
+    selectedFeatureIds: Set<string>;
+    lastClickedFeatureId: string | null;
+    activeSettingsLayerId: string | null;
+    searchQuery: string;
+    salvarLembrancaEstado(): void;
+    agendarSalvarLembranca(): void;
+    colapsar(emitirEvento?: boolean): void;
+    readonly camadaAtivaId: string | null;
+    readonly mapaBaseAtivo: string;
+    definirCamadaAtiva(camadaId: string, emitirEvento?: boolean): void;
+    selecionarMapaBase(id: string, emitirEvento?: boolean): void;
+    selecionarFeicao(feicaoId: string, acumular?: boolean, intervalo?: boolean, emitirEvento?: boolean): void;
+    limparSelecao(emitirEvento?: boolean): void;
+    notificarMudancaSelecao(): void;
+    alternarVisibilidadeTodas(emitirEvento?: boolean): void;
+    expandirTodas(): void;
+    colapsarTodas(): void;
+    removerCamada(camadaId: string): void;
+    sincronizarSelecaoDOM(): void;
+}

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

@@ -0,0 +1,23 @@
+export declare const ICONES: {
+    camadas: string;
+    inspecao: string;
+    equipe: string;
+    olhoAberto: string;
+    olhoFechado: string;
+    cadeadoTrancado: string;
+    cadeadoAberto: string;
+    chevronDir: string;
+    dragHandle: string;
+    alvoEnquadrar: string;
+    engrenagem: string;
+    mais: string;
+    lixeira: string;
+    fechar: string;
+    busca: string;
+    recolherPainel: string;
+    expandirPainel: string;
+    reguaMetrica: string;
+    moverPasta: string;
+    mapa: string;
+    gradeCad: string;
+};

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

@@ -0,0 +1,3 @@
+import { MapaBaseItem } from './tipos';
+export declare const MAPAS_BASE_PADRAO: MapaBaseItem[];
+export declare function renderizarGridMapasBase(mapasBase?: MapaBaseItem[], mapaBaseAtivo?: string): string;

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

@@ -0,0 +1,17 @@
+import { FeicaoItem } from './tipos';
+/**
+ * Calcula a distância em metros entre duas coordenadas [lat, lon] ou [lon, lat]
+ */
+export declare function calcularDistanciaPontos(p1: [number, number], p2: [number, number]): number;
+/**
+ * Calcula o comprimento total de uma linha de coordenadas em metros
+ */
+export declare function calcularComprimentoLinha(coords: unknown): number;
+/**
+ * Calcula a área de um anel poligonal em m² usando fórmula esférica
+ */
+export declare function calcularAreaPoligono(coords: unknown): number;
+/**
+ * Formata métrica resumida para lista de feições selecionadas
+ */
+export declare function formatarMetricaFeicoes(feicoes: FeicaoItem[]): string;

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

@@ -0,0 +1,65 @@
+import { CamadaItem } from './tipos';
+export interface CamadaPropsPersistidas {
+    name?: string;
+    visible?: boolean;
+    locked?: boolean;
+    opacity?: number;
+    color?: string;
+}
+export interface CamadaOverridePersistido extends CamadaPropsPersistidas {
+    /**
+     * Valores fornecidos pela aplicação (via definirCamadas/adicionarCamada) quando o override foi salvo.
+     * Se a aplicação passar um valor diferente depois, ela vence a customização do usuário.
+     */
+    origem?: CamadaPropsPersistidas;
+}
+export interface EstadoPersistidoCamadas {
+    versao: number;
+    expandedLayerIds: string[];
+    collapsedLayerIds: string[];
+    camadaAtivaId?: string | null;
+    painelColapsado?: boolean;
+    ordemCamadasIds?: string[];
+    mapaBaseAtivo?: string;
+    densidade?: 'compacto' | 'normal';
+    altura?: number | null;
+    camadasOverrides?: Record<string, CamadaOverridePersistido>;
+    ultimaAtualizacao?: number;
+}
+/**
+ * Retorna a chave do localStorage para uma determinada instância
+ */
+export declare function gerarChaveStorage(chaveProp?: string | null, elementId?: string | null): string;
+/**
+ * Lê o estado persistido do localStorage com tolerância a falhas (SSR, restrições de sandbox)
+ */
+export declare function carregarEstadoPersistido(storageKey: string): EstadoPersistidoCamadas | null;
+/**
+ * Salva o estado atualizado no localStorage de forma segura
+ */
+export declare function salvarEstadoPersistido(storageKey: string, estado: EstadoPersistidoCamadas): void;
+/**
+ * Remove o estado persistido no localStorage
+ */
+export declare function limparEstadoPersistido(storageKey: string): void;
+/**
+ * Mescla o estado das camadas carregadas com os overrides persistidos pelo usuário
+ */
+export declare function snapshotCamada(camada: CamadaItem): CamadaPropsPersistidas;
+export declare function reidratarCamadasComOverrides(camadas: CamadaItem[], estadoPersistido: EstadoPersistidoCamadas | null, expandedLayersSet: Set<string>, origensCamadas?: Map<string, CamadaPropsPersistidas>): void;
+export interface EntradaMontagemEstado {
+    estadoAnterior: EstadoPersistidoCamadas | null;
+    origensCamadas?: Map<string, CamadaPropsPersistidas>;
+    camadas: CamadaItem[];
+    expandedLayers: Set<string>;
+    camadaAtivaId: string | null;
+    painelColapsado: boolean;
+    mapaBaseAtivo: string;
+    densidade: 'compacto' | 'normal';
+    altura: number | null;
+}
+/**
+ * Monta o estado a persistir. Se ainda não há camadas na instância,
+ * preserva listas e overrides do estado anterior.
+ */
+export declare function montarEstadoPersistido(entrada: EntradaMontagemEstado): EstadoPersistidoCamadas;

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

@@ -0,0 +1,16 @@
+import { ListenerBag } from '../../core/listener-bag';
+export interface ContextoResizerCamadas {
+    hostElement: HTMLElement;
+    resizerElement: HTMLElement | null;
+    listeners: ListenerBag;
+    getMinAltura?: () => number;
+    getMaxAltura?: () => number;
+    onAlturaAlterada?: (alturaPx: number | null) => void;
+    onRedimensionando?: (alturaPx: number) => void;
+}
+export interface ControladorResizerCamadas {
+    init: () => void;
+    definirAltura: (alturaPx: number | string | null, dispararEvento?: boolean) => void;
+    destruir: () => void;
+}
+export declare function criarControladorRedimensionamentoAltura(ctx: ContextoResizerCamadas): ControladorResizerCamadas;

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

@@ -0,0 +1,2 @@
+import { CamadaItem, FeicaoItem } from './tipos';
+export declare function renderizarRodapeAcoes(camadas: CamadaItem[], feicoes: FeicaoItem[], selecionadasIds: Set<string>): string;

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

@@ -0,0 +1,24 @@
+import { CamadaItem, FeicaoItem } from './tipos';
+export interface ResultadoSelecao {
+    selecionados: Set<string>;
+    ultimoClicadoId: string | null;
+}
+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[];
+/**
+ * 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.
+ */
+export declare function obterIdsVisiveisFeicoes(camadas: CamadaItem[], feicoes: FeicaoItem[], camadasExpandidas: Set<string>, termoBusca?: string, limitePorCamada?: number): string[];
+/**
+ * Calcula a nova seleção após clique (simples, Ctrl/Cmd acumulado ou Shift em intervalo).
+ * Retorna null se a feição clicada não estiver visível.
+ */
+export declare function calcularSelecaoFeicao(idsVisiveis: string[], selecionadosAtuais: Set<string>, ultimoClicadoId: string | null, feicaoId: string, acumular: boolean, intervalo: boolean): ResultadoSelecao | null;
+/**
+ * Remove da seleção IDs que não existem mais nas feições
+ */
+export declare function removerSelecoesInvalidas(selecionados: Set<string>, feicoes: FeicaoItem[]): void;

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

@@ -0,0 +1,3 @@
+import { CamadasHostCompleto } from './camadas-host';
+export declare function sincronizarCamadaAtivaDOM(host: CamadasHostCompleto, shadow: ShadowRoot): void;
+export declare function sincronizarSelecaoDOM(host: CamadasHostCompleto, shadow: ShadowRoot): void;

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

@@ -0,0 +1,3 @@
+import { ListenerBag } from '../../core/listener-bag';
+import { CamadasHostCompleto } from './camadas-host';
+export declare function conectarTecladoEAcessibilidade(host: CamadasHostCompleto, hostElement: HTMLElement, shadow: ShadowRoot, corpo: HTMLElement, listeners: ListenerBag): void;

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

@@ -0,0 +1,26 @@
+/**
+ * Escapa caracteres HTML perigosos para prevenir ataques XSS
+ */
+export declare function escapeHtml(str: string | null | undefined): string;
+/**
+ * Sanitiza e valida cor para interpolação segura em inline styles e variáveis CSS
+ */
+export declare function sanitizarCorCss(cor: string | null | undefined, fallback?: string): string;
+/**
+ * Converte uma cor CSS para `#rrggbb`, único formato aceito por <input type="color">.
+ * Suporta hex (3/4/6/8 dígitos), rgb()/rgba() e hsl()/hsla(); demais valores retornam o fallback.
+ */
+export declare function corParaHex(cor: string | null | undefined, fallback?: string): string;
+/**
+ * Localiza um elemento pelo valor exato de um atributo, sem montar seletor CSS.
+ * IDs arbitrários (aspas, colchetes, barras) quebram `[attr="valor"]`; comparar o valor evita escape.
+ */
+export declare function buscarPorAtributo(raiz: ParentNode, atributo: string, valor: string): HTMLElement | null;
+/**
+ * Cria uma função com debounce para limitar disparos de alta frequência (ex: busca rápida)
+ */
+export declare function debounce<T extends (...args: any[]) => void>(fn: T, delayMs?: number): (...args: Parameters<T>) => void;
+/**
+ * Atualiza título e aria-label de um controle-ícone de uma só vez
+ */
+export declare function definirRotuloControle(el: Element, texto: string): void;