@thibezer/ui-components-kit 2.8.0 → 2.8.2

package/dist/card.cjs

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

package/dist/card.js

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

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

@@ -3,21 +3,10 @@ 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,8 +12,6 @@ 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

@@ -8,7 +8,10 @@ export declare function avisarIdsDuplicados(ids: string[], contexto: string): vo
 export declare function coletarIds(itens: FerramentaItem[], saida?: string[]): string[];
 export declare function aplicarEstadoBotao(btn: HTMLButtonElement, item: FerramentaItem): void;
 export declare function criarBotaoFerramenta(item: FerramentaItem, variante: VarianteBotaoFerramenta, tamanhoIcone: number): HTMLButtonElement;
+/** 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;
 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;
@@ -16,8 +19,26 @@ export declare function atualizarRoving(botoes: HTMLButtonElement[]): void;
 export declare function seguirFoco(botoes: HTMLButtonElement[], alvo: EventTarget | null): 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;
+/** Navegação em grade de 2 colunas para paletas verticais com colunas=2. */
+export declare function navegarGrade2Colunas(e: KeyboardEvent, botoes: HTMLButtonElement[], rtl?: boolean): boolean;
+export declare class GerenciadorTooltip {
+    private raiz;
+    private el;
+    private textoEl;
+    private atalhoEl;
+    private timer;
+    private alvoAtual;
+    private readonly id;
+    private listeners;
+    constructor(raiz: ShadowRoot, container: HTMLElement);
+    private agendar;
+    mostrar(btn: HTMLElement, texto: string, atalho?: string): void;
+    esconder(): void;
+    private limparTimer;
+    destruir(): void;
+}
 export interface OpcoesMenu {
-    lado?: 'baixo' | 'direita';
+    lado?: 'baixo' | 'direita' | 'esquerda';
     /** Foca o primeiro item ao abrir (abertura por teclado). */
     focar?: boolean;
     /** Papel dos itens sem `tipo`: ribbon = botao (menuitem), paleta = ferramenta (menuitemradio). */

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

@@ -32,11 +32,36 @@ export interface FerramentaItem {
     somenteIcone?: boolean;
     /** Ribbon: itens do menu suspenso. Paleta: ferramentas agrupadas (flyout). */
     filhos?: FerramentaItem[];
+    /**
+     * Ribbon: botão dividido (split button). A ação principal dispara no clique do corpo
+     * e a seta abre o menu suspenso com os `filhos`.
+     */
+    dividido?: boolean;
 }
 export interface RibbonGrupo {
     id: string;
     rotulo: string;
     itens: FerramentaItem[];
+    /**
+     * Prioridade para colapso automático quando a largura é insuficiente (estilo Office).
+     * Grupos de menor prioridade viram um botão único com flyout primeiro. Padrão: 0.
+     */
+    prioridade?: number;
+    /** Ícone exibido quando o grupo for colapsado em um botão de flyout. */
+    icone?: string;
+    /**
+     * Exibe um botão "lançador de diálogo" no canto inferior do grupo (estilo Office Dialog Box Launcher).
+     * Pode ser `true` ou o identificador/ação a disparar.
+     */
+    lancadorDialogo?: boolean | string;
+    /** Rótulo acessível para o botão lançador de diálogo. Padrão: "Mais opções de [rotulo]". */
+    rotuloLancador?: string;
+    /**
+     * Quando `true` (padrão para grupos com ferramentas no ribbon), garante exclusividade
+     * de seleção entre itens `tipo: 'ferramenta'` dentro do mesmo grupo.
+     * Defina como `false` para desativar a exclusividade automática no grupo.
+     */
+    exclusivo?: boolean;
 }
 export interface RibbonAba {
     id: string;
@@ -73,6 +98,11 @@ export interface PaletaChangeDetail {
 export interface RecolhidoChangeDetail {
     recolhido: boolean;
 }
+/** `detail` de `ui-grupo-dialogo` do ribbon (lançador de diálogo do grupo). */
+export interface GrupoDialogoDetail {
+    id: string;
+    grupo: RibbonGrupo;
+}
 declare global {
     interface HTMLElementEventMap {
         /** Cancelável: `preventDefault()` reverte o toggle / a seleção feita pelo clique. */
@@ -81,5 +111,6 @@ declare global {
         'ui-recolhido-change': CustomEvent<RecolhidoChangeDetail>;
         'ui-change': CustomEvent<PaletaChangeDetail>;
         'ui-selecionar': CustomEvent<PaletaChangeDetail>;
+        'ui-grupo-dialogo': CustomEvent<GrupoDialogoDetail>;
     }
 }

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

@@ -26,12 +26,25 @@ export declare class UIPaletaFerramentas extends SafeHTMLElement {
     private _pendente;
     private visiveis;
     private menu;
-    private pressao;
+    private timerPressao;
+    private timerSupressao;
+    private inicioPressao;
+    private suprimirClique;
     private listeners;
+    private tooltip;
+    private _modoControlado;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    /**
+     * Quando `true` ou atributo `copiar-dados` / `modo-controlado`: clona a árvore de itens
+     * para não mutar os objetos fornecidos pelo consumidor (Item 11).
+     */
+    get modoControlado(): boolean;
+    set modoControlado(val: boolean);
+    get copiarDados(): boolean;
+    set copiarDados(val: boolean);
     get ferramentas(): FerramentaItem[];
     set ferramentas(val: FerramentaItem[]);
     get valor(): string;
@@ -68,8 +81,11 @@ 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

@@ -10,15 +10,26 @@ export declare class UIRibbon extends SafeHTMLElement {
     private readonly uid;
     private _abaPendente;
     private _pronto;
+    private _modoControlado;
     private _abas;
     private _abaAtiva;
     private menu;
     private listeners;
+    private tooltip;
+    private observerResize;
+    private gruposColapsados;
+    private keytipsAtivas;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(name: string, old: string | null, value: string | null): void;
     private aplicarRotulos;
+    get modoControlado(): boolean;
+    set modoControlado(val: boolean);
+    get copiarDados(): boolean;
+    set copiarDados(val: boolean);
+    get ativacaoManual(): boolean;
+    set ativacaoManual(val: boolean);
     get abas(): RibbonAba[];
     set abas(val: RibbonAba[]);
     get abaAtiva(): string;
@@ -40,6 +51,10 @@ export declare class UIRibbon extends SafeHTMLElement {
     private renderizarAbas;
     private idAba;
     private renderizarPainel;
+    private iniciarResizeObserver;
+    private ajustarColapsoGrupos;
+    private alternarMenuGrupoColapsado;
+    private criarGrupo;
     private criarBotao;
     private botoesPainel;
     private handleClickAbas;
@@ -51,6 +66,8 @@ export declare class UIRibbon extends SafeHTMLElement {
     private handleKeyDownGrupos;
     private handleEscape;
     private handlePointerDownFora;
+    private handleAtalho;
+    private alternarKeyTips;
     private acionar;
     private alternarMenu;
     private fecharMenu;

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

@@ -1,4 +1,2 @@
 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,7 +1,5 @@
 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[];
@@ -15,6 +13,15 @@ export interface ParametrosRenderArvore {
     limiteFeicoesPorCamada?: number;
     mostrarBotaoColapsar?: boolean;
 }
-export { escapeHtml, renderizarThumbGeometria, construirHierarquiaCamadas };
-export type { CamadaNodoHierarquico };
+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 declare function renderizarArvoreCamadas(params: ParametrosRenderArvore): string;

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

@@ -4,8 +4,6 @@ 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;
@@ -13,22 +11,12 @@ 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.
-     * Os ouvintes de `window` existem só durante o gesto e são soltos em `destruir()`.
+     * Suporte a arraste por toque e ponteiro no handle (.ui-col-drag) para tablets e mobile
      */
     bindTouchDragAndDrop(): void;
 }

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

@@ -1,7 +1,6 @@
 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;
@@ -12,10 +11,11 @@ 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;
-    /** @internal */
-    readonly lembranca: LembrancaCamadas;
+    private origensCamadas;
+    private salvarLembrancaDebounced;
     camadas: CamadaItem[];
     feicoes: FeicaoItem[];
     mapasBase: MapaBaseItem[];
@@ -79,6 +79,7 @@ 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;
@@ -113,6 +114,7 @@ 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-atributos-sync.d.ts

@@ -1,4 +1,3 @@
-import { ScaleMode } from '../../gerencigeo-canvas/types';
 import { UICanvasCAD } from './ui-canvas-cad';
 import { GerenciadorBroadcastConfig } from './cad-broadcast';
 import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
@@ -8,7 +7,7 @@ export interface ContextoAtributosCAD {
     mapContainer: HTMLDivElement | null;
     broadcastConfig: GerenciadorBroadcastConfig;
     setLayerOpacity: (id: string, op: number) => void;
-    setLayerScaleMode: (id: string, mode: ScaleMode) => void;
+    setLayerScaleMode: (id: string, mode: any) => 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(entrada: unknown): void;
+    processarMensagem(data: any): void;
     desconectar(): void;
 }

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

@@ -1,6 +1,4 @@
 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;
@@ -10,7 +8,14 @@ export interface ContextoEventosCanvas {
     obterElementoPorId: (id: string | number) => any;
     fecharPopup: () => void;
 }
-export declare function processarCliqueLivreCanvas(ctx: ContextoEventosCanvas, e: MouseEvent | EventoMapaCad, latLngParam?: LatLngEvento, containerPointParam?: PontoPixel): boolean;
+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 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.d.ts

@@ -1,4 +1,5 @@
 import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { LayerStyleDef } from '../../gerencigeo-canvas/types';
 import { Feicao, EstiloFeicao, LatLonPar } from '../../gerencigeo-canvas/feature_types';
 import { RegraVersoes } from '../../gerencigeo-canvas/feature_versoes';
 import { UsuarioRemoto } from '../../gerencigeo-canvas/feature_cursores';
@@ -6,14 +7,48 @@ import { RefFeicao } from '../../gerencigeo-canvas/feature_selecao';
 import { CaixaPx, ModoCaixa } from '../../gerencigeo-canvas/feature_caixa';
 import { MargensPopup } from '../../gerencigeo-canvas/feature_popup';
 import { default as L } from 'leaflet';
+import { MotivoRecusaEdicao } from '../../gerencigeo-canvas/feature_edicao_ops';
 import { ExcluirSnap } from '../../gerencigeo-canvas/feature_snap';
-import { EditorVertices } from '../../gerencigeo-canvas/feature_editor_vertices';
-import { ControleDesenho } from '../../gerencigeo-canvas/feature_desenho_controle';
 import { Ferramenta } from '../../gerencigeo-canvas/feature_desenho';
 import { MargensHud } from '../../gerencigeo-canvas/feature_hud';
-import { TIPO_CAMADA_FEICOES, OpcoesCamadaFeicoes, OpcoesLote, AtualizacaoFeicao, LoteFeicoes, ResultadoLote, ResultadoFeicoes, OpcoesPopup, ResultadoFerramenta, ResultadoEdicao } from './cad-feicoes-tipos';
-export { TIPO_CAMADA_FEICOES };
-export type { OpcoesCamadaFeicoes, OpcoesLote, AtualizacaoFeicao, LoteFeicoes, ResultadoLote, ResultadoFeicoes, OpcoesPopup, ResultadoFerramenta, ResultadoEdicao };
+export declare const TIPO_CAMADA_FEICOES = "feicoes";
+export interface OpcoesCamadaFeicoes {
+    nome?: string;
+    zIndex?: number;
+    opacidade?: number;
+    interativo?: boolean;
+    estilo?: Partial<LayerStyleDef>;
+}
+/** Opções de `aplicarLote` / `atualizarFeicao`. */
+export interface OpcoesLote extends OpcoesCamadaFeicoes {
+    /**
+     * Em atualizações, `propriedades` informadas SUBSTITUEM as atuais (o padrão é mesclar, e chaves apagadas
+     * pelo consumidor ficam para trás). Sem `propriedades` no item, nada muda.
+     */
+    substituirPropriedades?: boolean;
+}
+/** Itens de atualização: `id` aponta a feição; o resto é mesclado como em `atualizarFeicao`. */
+export type AtualizacaoFeicao = Record<string, any> & {
+    id: string;
+};
+export interface LoteFeicoes {
+    adicionar?: unknown[];
+    atualizar?: AtualizacaoFeicao[];
+    remover?: string[];
+}
+export interface ResultadoLote {
+    adicionadas: number;
+    atualizadas: number;
+    removidas: number;
+    /** Ids (ou posições, quando não há id) recusados: geometria inválida, feição inexistente numa atualização, camada que não é de feições. */
+    recusadas: string[];
+}
+export interface ResultadoFeicoes {
+    /** Quantas feições entraram na camada. */
+    aceitas: number;
+    /** Ids (ou posições, quando não há id) das feições recusadas por geometria inválida. */
+    recusadas: string[];
+}
 interface Contexto {
     obterLayerManager: () => CanvasLayerManager;
     obterMapa: () => L.Map | null;
@@ -26,21 +61,36 @@ interface Contexto {
     /** Regra de oficial × prévia compartilhada com o renderizador (o componente a põe no contexto de renderização). */
     regra?: RegraVersoes;
 }
+/** Opções do popup da feição. */
+export interface OpcoesPopup {
+    /** A ação "copiar" grava as coordenadas na área de transferência (padrão `true`); `cad-feicao-acao` sai de qualquer jeito. */
+    copiarParaAreaDeTransferencia?: boolean;
+}
+export interface ResultadoFerramenta {
+    ok: boolean;
+    motivo?: 'ferramenta-invalida' | 'sem-mapa' | 'sem-camada' | 'camada-invalida' | 'camada-bloqueada';
+}
+export interface ResultadoEdicao {
+    ok: boolean;
+    motivo?: MotivoRecusaEdicao | 'inexistente' | 'sem-mapa';
+}
 export declare class GerenciadorFeicoes {
     private contexto;
-    private operacoes;
     private selecao;
     private popup;
-    private edicao;
-    private consulta;
-    private ponteiro;
-    private regiao;
+    private editor;
     private snap;
-    private ferramentas;
-    private versoes;
-    private camera;
-    private repositorio;
+    private desenho;
+    private camadaDesenho;
+    private estiloDesenho;
+    private sequenciaId;
+    private regra;
+    private cacheOficiais;
+    /** id -> posição na lista da camada (válido enquanto `lista` for a lista atual); evita varrer a camada a cada consulta. */
+    private posicoes;
     private cursores;
+    private hoverId;
+    private hoverAgendado;
     private margensHud;
     /** Aceita a coordenada (0, 0) exata nas feições de entrada (atributo `aceitar-origem`). */
     aceitarOrigem: boolean;
@@ -49,18 +99,28 @@ export declare class GerenciadorFeicoes {
     /** Depois de qualquer mudança nos dados: descarta seleção órfã e atualiza/fecha o popup aberto. */
     private aposDados;
     private lista;
+    private posicaoDe;
     /** Feição da camada pelo id (O(1)); `undefined` se não existe. */
     buscar(camadaId: string, id: string): Feicao | undefined;
+    private garantirCamada;
     private opcoesNormalizacao;
     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. Ver `RepositorioFeicoes`. */
+    /**
+     * 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. */
+    /**
+     * 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;
     obterFeicoes(camadaId: string): Feicao[];
     /** Traduz as ações vindas do renderizador no evento a disparar pelo componente. */
     tratarAcaoCamada(acao: string, detalhe: {
@@ -74,7 +134,7 @@ export declare class GerenciadorFeicoes {
     /** Esc ou clique no vazio: durante a edição só encerra a edição; fora dela, limpa a seleção. */
     aoPedirLimpeza(): void;
     obterFeicoesSelecionadas(): Feicao[];
-    /** Laço: seleciona (substituindo) as feições tocadas pelo polígono; a ferramenta encerra. */
+    /** Laço: seleciona (substituindo) as feições de camadas selecionáveis tocadas pelo polígono; a ferramenta encerra. */
     private selecionarNoLaco;
     /** Caixa de seleção: só feições de camadas visíveis, interativas e desbloqueadas, com toque geométrico real. */
     selecionarNaCaixa(caixa: CaixaPx, modo: ModoCaixa, aditivo: boolean): void;
@@ -90,12 +150,14 @@ export declare class GerenciadorFeicoes {
     definirMargensHud(m: Partial<MargensHud>): void;
     private aplicarMargensHud;
     get regraVersoes(): RegraVersoes;
+    private oficiaisDe;
     /** Aparece segundo a regra de oficial × prévia? */
     visivelPorVersao(f: Feicao): boolean;
     /** Vai para a tela e responde a clique, caixa, laço, snap e hover: não excluída, não oculta e visível pela regra de versões. */
     desenhada(f: Feicao): boolean;
     /** Regra da seleção: a feição em edição continua selecionada mesmo se for ocultada no meio da edição. */
     private selecionavelAgora;
+    private aplicarVersoes;
     get previasGlobais(): boolean;
     /** Mostra (ou esconde) as prévias de todas as entidades. Prévias de entidades sem oficial aparecem sempre. */
     definirPreviasGlobais(ligado: boolean): void;
@@ -108,6 +170,10 @@ export declare class GerenciadorFeicoes {
     removerCursorRemoto(id: string): boolean;
     limparCursoresRemotos(): void;
     get cursoresRemotos(): number;
+    /** Mostra o que estava escondido (camada oculta, prévia não solicitada) para a feição poder ser vista. */
+    private garantirVisivel;
+    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;
@@ -115,6 +181,7 @@ export declare class GerenciadorFeicoes {
     ajustarTudo(): boolean;
     /** Enquadra a camada inteira; se estava oculta, torna-a visível. */
     ajustarCamada(camadaId: string): boolean;
+    private feicaoSob;
     /** Emite `cad-feicao-hover` quando a feição sob o mouse muda (uma checagem por quadro). */
     aoMoverMouse(e: MouseEvent): void;
     /** Botão direito: emite `cad-feicao-menu` com a feição sob o cursor (ou `null`), para o consumidor abrir o próprio menu. */
@@ -127,19 +194,13 @@ export declare class GerenciadorFeicoes {
     alternarSnap(): void;
     conectarTeclado(): void;
     desconectarTeclado(): void;
-    /** Feições visíveis cujo envelope toca um quadrado de `tolPx` px em volta de `coord`. */
+    /** Feições visíveis das camadas de feições cujo envelope toca um quadrado de `tolPx` px em volta de `coord`. */
     private candidatasEm;
     /** Snap de uma coordenada contra as feições visíveis de todas as camadas de feições (via índice espacial). */
     buscarSnapEm(coord: [number, number], excluir?: ExcluirSnap): import('../../gerencigeo-canvas').ResultadoSnap | null;
-    /** @internal Editor de vértices (usado pelos testes de caracterização). */
-    get editor(): EditorVertices | null;
     get editando(): boolean;
     iniciarEdicao(camadaId: string, id: string): ResultadoEdicao;
     pararEdicao(): void;
-    /** @internal Controle de desenho (usado pelos testes de caracterização). */
-    get desenho(): ControleDesenho | null;
-    /** @internal Conta-gotas (usado pelos testes de caracterização). */
-    amostrarEstilo(coord: LatLonPar): void;
     get ferramentaAtiva(): Ferramenta | null;
     /** Camada que recebe o que for desenhado. Não existe camada padrão: o consumidor escolhe. */
     definirCamadaDesenho(camadaId: string | null): void;
@@ -159,8 +220,22 @@ export declare class GerenciadorFeicoes {
     desfazerVerticeDesenho(): boolean;
     /** Liga/desliga a tecla S do snap (o botão e `definirSnap` continuam valendo). */
     definirAtalhoSnap(ligado: boolean): void;
+    private motivoCamadaDesenhoInvalida;
+    private novoId;
     private idLivre;
-    /** Divide polígonos pela linha de corte (selecionados; sem seleção, o primeiro cortado). Ver `OperacoesFeicoes`. */
+    /**
+     * Clique da ferramenta texto: emite `cad-texto-solicitado` (cancelável). Com `preventDefault()` o consumidor assume a
+     * entrada do texto e depois chama `detalhe.concluir(texto)` (cria na camada de desenho, com o estilo de desenho) ou
+     * simplesmente não faz nada para cancelar. Sem `preventDefault()`, aparece o campo inline.
+     */
+    private solicitarTexto;
+    private concluirFerramenta;
+    /** Conta-gotas: copia o estilo da feição sob o clique para o estilo de desenho. */
+    private amostrarEstilo;
+    /**
+     * Divide polígonos pela linha de corte. Alvos: os polígonos selecionados; sem seleção, o primeiro
+     * polígono (de camada visível, interativa e desbloqueada) que a linha corta.
+     */
     dividirComLinha(linha: LatLonPar[]): boolean;
     /** Cria um polígono de buffer ao redor da feição (na camada dela, ou em `camadaDestino`). */
     gerarBuffer(camadaId: string, id: string, metros: number, opcoes?: {
@@ -174,9 +249,14 @@ export declare class GerenciadorFeicoes {
     }, opcoes?: {
         id?: string;
     }): Feicao | null;
-    /** Junta linhas (encadeando pontas) ou dois polígonos numa feição só; as originais saem. Ver `OperacoesFeicoes`. */
+    /**
+     * Junta linhas (encadeando pontas) ou dois polígonos (por uma ponte) numa feição só; as originais saem.
+     * Linhas com pontas a até `toleranciaM` se ligam; polígonos precisam estar a até `toleranciaM` e
+     * não podem ter bordas que se cruzam.
+     */
     juntarFeicoes(camadaId: string, ids: string[], opcoes?: {
         toleranciaM?: number;
         id?: string;
     }): Feicao | null;
 }
+export {};

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

@@ -3,8 +3,6 @@ import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controlle
 import { GerenciadorToolbarPainel } from './cad-toolbar-painel';
 import { GerenciadorColecoesDados } from './cad-colecoes-dados';
 import { ContextoEventosCanvas } from './cad-eventos-canvas';
-import { EventoMapaCad, LatLngEvento } from './tipos';
-import { PontoPixel } from './cad-evento-coordenadas';
 export interface ContextoInicializadorCAD {
     host: UICanvasCAD;
     shadow: ShadowRoot;
@@ -15,7 +13,7 @@ export interface ContextoInicializadorCAD {
     obterContextoEventos: () => ContextoEventosCanvas;
     renderLayersUI: () => void;
     invalidateSizeSafely: () => void;
-    tratarCliqueLivreCanvas: (e: MouseEvent | EventoMapaCad, latlng?: LatLngEvento, containerPoint?: PontoPixel) => void;
+    tratarCliqueLivreCanvas: (e: any, latlng?: any, containerPoint?: any) => void;
     dispararAcaoPopup: (acaoId: string, elementoId: string | number, elemento?: any) => void;
 }
 export declare function inicializarCAD(ctx: ContextoInicializadorCAD): void;