@thibezer/ui-components-kit 2.6.1 → 2.7.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-alerta/ui-toast.d.ts

@@ -1,19 +1,6 @@
 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;
-}
+import { UIToastAcao, UIToastOpcoes } from '../../core/tipos-toast';
+export type { UIToastAcao, UIToastOpcoes };
 export declare class UIToast extends UIAlerta {
     private timerId;
     private tempoRestante;
@@ -32,3 +19,5 @@ export declare class UIToast extends UIAlerta {
     private static obterContainer;
     static notificar(opcoes: UIToastOpcoes): any;
 }
+/** Registra o `UIToast` como provedor de `UIBus.notificar` (idempotente). */
+export declare function registrarToastNoBus(): void;

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

@@ -0,0 +1,16 @@
+import { FerramentaItem } from './tipos';
+/**
+ * `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` (uma letra, 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, 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,14 @@
+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) => HTMLButtonElement;
+export declare function criarGrupoRibbon(grupo: RibbonGrupo, criarBotao: CriarBotaoFerramenta): HTMLElement;

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

@@ -0,0 +1,17 @@
+/**
+ * Teclado das abas do <ui-ribbon> (padrão WAI-ARIA de abas com ativação automática).
+ * Responsabilidade única: traduzir uma tecla em uma ação; quem chama executa (foco, seleção, painel).
+ */
+export type AcaoTeclaAba = {
+    tipo: 'ir-para';
+    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): 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;
     constructor();
     connectedCallback(): void;
@@ -71,11 +68,8 @@ 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;
     private handleAtalho;

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

@@ -40,7 +40,6 @@ export declare class UIRibbon extends SafeHTMLElement {
     private renderizarAbas;
     private idAba;
     private renderizarPainel;
-    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-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-render.d.ts

@@ -0,0 +1,14 @@
+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 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-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[];
@@ -79,7 +79,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 +113,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;
+}

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

@@ -0,0 +1,21 @@
+import { default as L } from 'leaflet';
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { Feicao, LatLonPar } from '../../gerencigeo-canvas/feature_types';
+import { ExcluirSnap } from '../../gerencigeo-canvas/feature_snap';
+export interface PortasConsulta {
+    obterMapa: () => L.Map | null;
+    obterLayerManager: () => CanvasLayerManager;
+    desenhada: (f: Feicao) => boolean;
+}
+export declare class ConsultaEspacialFeicoes {
+    private p;
+    constructor(p: PortasConsulta);
+    /** Feições visíveis das camadas de feições cujo envelope toca um quadrado de `tolPx` px em volta de `coord`. */
+    candidatasEm(coord: LatLonPar, tolPx: number): Feicao[];
+    /** Snap de uma coordenada contra as feições visíveis de todas as camadas de feições (via índice espacial). */
+    buscarSnapEm(coord: [number, number], excluir?: ExcluirSnap): import('../../gerencigeo-canvas').ResultadoSnap | null;
+    feicaoSob(clientX: number, clientY: number): {
+        feicao: Feicao | null;
+        coordenada: LatLonPar;
+    } | null;
+}

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

@@ -0,0 +1,39 @@
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { Feicao } from '../../gerencigeo-canvas/feature_types';
+import { OpcoesCamadaFeicoes, OpcoesLote, LoteFeicoes, ResultadoLote, ResultadoFeicoes } from './cad-feicoes-tipos';
+export interface PortasRepositorio {
+    obterLayerManager: () => CanvasLayerManager;
+    opcoesNormalizacao: () => {
+        aceitarOrigem: boolean;
+    };
+    /** Chamado depois de cada mudança nos dados, para reconciliar seleção, edição e popup. */
+    aposDados: () => void;
+}
+export declare class RepositorioFeicoes {
+    private p;
+    /** id -> posição na lista da camada (válido enquanto `lista` for a lista atual); evita varrer a camada a cada consulta. */
+    private posicoes;
+    constructor(p: PortasRepositorio);
+    lista(camadaId: string): Feicao[];
+    private posicaoDe;
+    /** Feição da camada pelo id (O(1)); `undefined` se não existe. */
+    buscar(camadaId: string, id: string): Feicao | undefined;
+    private garantirCamada;
+    definirFeicoes(camadaId: string, brutas: unknown[], opcoes?: OpcoesCamadaFeicoes): ResultadoFeicoes;
+    adicionarFeicao(camadaId: string, bruta: unknown, opcoes?: OpcoesCamadaFeicoes): Feicao | null;
+    /**
+     * Mescla campos de primeiro nível; `estilo` e `propriedades` também são mesclados. Com `substituirPropriedades`,
+     * `propriedades` informadas trocam as atuais por inteiro (atributos ausentes somem).
+     */
+    atualizarFeicao(camadaId: string, id: string, parcial: Record<string, any>, opcoes?: Pick<OpcoesLote, 'substituirPropriedades'>): Feicao | null;
+    /** Grava uma feição já normalizada (usado quando o próprio mapa a altera, como ao arrastar um texto). */
+    substituir(camadaId: string, feicao: Feicao): void;
+    removerFeicao(camadaId: string, id: string): boolean;
+    /**
+     * Várias mudanças numa só regravação e num só `aposDados`: remove, depois atualiza, depois adiciona.
+     * Adicionar um id que já existe substitui a feição mantendo a posição (a ordem de empilhamento não muda).
+     */
+    aplicarLote(camadaId: string, lote: LoteFeicoes, opcoes?: OpcoesLote): ResultadoLote;
+    private mesclar;
+    private aplicar;
+}