@thibezer/ui-components-kit 2.12.4 → 2.13.0

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

@@ -1,4 +1,5 @@
 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;
+/** Liga o arraste sobre os controles dentro de `raiz` (padrão: o painel todo; na atualização incremental, só as linhas novas). */
+export declare function conectarArrasteControles(host: CamadasHostCompleto, shadow: ShadowRoot, raiz?: ParentNode): void;

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

@@ -0,0 +1,24 @@
+import { CamadaItem, DecisaoAtualizacao, EntradaDecisaoIncremental, FeicaoItem, MudancaFeicoes } from './tipos';
+/** O que a atualização incremental lê do painel. */
+export interface HostIncremental {
+    camadas: CamadaItem[];
+    feicoes: FeicaoItem[];
+    selectedFeatureIds: Set<string>;
+    expandedFeatureLimits: ReadonlyMap<string, number>;
+    editingLayerId: string | null;
+    editingFeatureId: string | null;
+    activeSettingsLayerId: string | null;
+    searchQuery: string;
+}
+/** Liga os eventos dos elementos novos dentro de `raiz` (só deles: nunca religa linhas existentes). */
+export type LigarElementos = (raiz: ParentNode) => void;
+/**
+ * Decide se a mutação pode ser aplicada só nas linhas afetadas. Função pura: qualquer dúvida sobre o que o
+ * render completo produziria (busca, edição inline, drawer, camada fora da árvore, ids repetidos) vira fallback.
+ */
+export declare function decidirAtualizacao(entrada: EntradaDecisaoIncremental): DecisaoAtualizacao;
+/**
+ * Aplica a mudança de feições só nas linhas afetadas. Devolve `false` quando não pôde garantir o mesmo
+ * resultado do render completo (o chamador então redesenha o painel inteiro, o que também corrige o DOM).
+ */
+export declare function tentarAtualizacaoIncremental(host: HostIncremental, shadow: ShadowRoot, mudanca: MudancaFeicoes, ligar: LigarElementos): boolean;

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

@@ -1,4 +1,4 @@
-import { CamadaItem, FeicaoItem } from './tipos';
+import { CamadaItem, FeicaoItem, MudancaFeicoes } from './tipos';
 import { LembrancaCamadas } from './camadas-lembranca';
 /** Estado e ações do painel que as coleções usam. */
 export interface HostColecao {
@@ -15,6 +15,8 @@ export interface HostColecao {
     getAttribute(nome: string): string | null;
     salvarLembrancaEstado(): void;
     solicitarRenderizacao(): void;
+    /** Mutação de feição: atualiza só as linhas afetadas quando possível (ver `UICamadas`). */
+    solicitarAtualizacaoFeicoes(mudanca: MudancaFeicoes): 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, visitados?: Set<string>): CamadaItem[];

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

@@ -15,6 +15,11 @@ export declare class CamadasDragDropManager {
     private shadow;
     /** Cancela um arraste por toque em andamento (remove os ouvintes de `window`). */
     private cancelarToque;
+    /**
+     * Arraste HTML5 em andamento. Fica no gerenciador (e não numa closure de `bindDragAndDrop`) para que linhas
+     * ligadas depois, na atualização incremental, enxerguem o arraste iniciado numa linha mais antiga.
+     */
+    private arraste;
     constructor(host: UICamadasHost, shadow: ShadowRoot);
     bindAll(): void;
     /** Solta o que ficou em `window` (arraste por toque interrompido pela desconexão do componente). */
@@ -27,7 +32,12 @@ export declare class CamadasDragDropManager {
     /** Camada travada (ou sob grupo travado) não recebe nem perde feições pelo arraste. */
     private trocaEntreCamadasTravada;
     private arrasteBloqueado;
+    /** Render completo: zera o arraste e liga camadas e feições do painel todo. */
     bindDragAndDrop(): void;
+    /** Atualização incremental: liga renomear e arraste só nas linhas de feição novas dentro de `raiz`. */
+    bindLinhasFeicao(raiz: ParentNode): void;
+    private vincularArrasteCamadas;
+    private vincularArrasteFeicoes;
     /**
      * 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()`.

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

@@ -1,2 +1,7 @@
 import { CamadasHostCompleto } from './camadas-host';
+/**
+ * Liga os eventos das linhas de feição que estão dentro de `raiz` (a árvore toda, no render completo; só as
+ * linhas novas, na atualização incremental, para nunca duplicar listeners em linhas existentes).
+ */
+export declare function conectarEventosFeicoes(host: CamadasHostCompleto, raiz: ParentNode): void;
 export declare function conectarEventosArvore(host: CamadasHostCompleto, shadow: ShadowRoot): void;

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

@@ -1,4 +1,6 @@
 import { CamadasHostCompleto } from './camadas-host';
 export declare function conectarEventosCamadas(host: CamadasHostCompleto, shadow: ShadowRoot): void;
+/** Botão "Mostrar mais" do aviso de truncamento (paginação incremental das feições de uma camada). */
+export declare function conectarMostrarMais(host: CamadasHostCompleto, raiz: ParentNode): void;
 /** Mantém o ícone do botão "expandir/recolher todas" coerente com o estado individual das camadas */
 export declare function atualizarIconeExpansaoGlobal(host: CamadasHostCompleto, shadow: ShadowRoot): void;

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

@@ -0,0 +1,29 @@
+import { CamadaItem, FeicaoItem } from './tipos';
+import { EstadoHerdadoCamada } from './camadas-hierarquia';
+/** O que a linha de uma feição herda da camada onde ela está. */
+export interface ContextoLinhaFeicao {
+    /** `id` da camada, já escapado para atributo HTML. */
+    camadaIdSeguro: string;
+    /** Cor da camada, sanitizada (fallback da cor da feição). */
+    corCamada: string;
+    /** Profundidade da camada na hierarquia (a feição fica um nível abaixo). */
+    profundidade: number;
+    /** Camada oculta ou sob grupo oculto: a linha fica esmaecida. */
+    esmaecida: boolean;
+    /** Camada travada ou sob grupo travado: o cadeado da feição não pode ser alterado. */
+    travadaPelaCamada: boolean;
+}
+export declare function criarContextoLinhaFeicao(camada: CamadaItem, profundidade: number, heranca: EstadoHerdadoCamada | undefined): ContextoLinhaFeicao;
+/** Título do chip de contagem: total do ramo e, num grupo, quanto é da própria camada. */
+export declare function tituloContagem(totalRamo: number, proprias: number, subcamadas: number): string;
+/** Chip com o total de feições do ramo; vazio num grupo sem feições. */
+export declare function renderizarChipContagem(totalRamo: number, proprias: number, subcamadas: number, ehGrupo: boolean): string;
+/** Textos do aviso "Exibindo X de Y", compartilhados pelo HTML e pela atualização no lugar. */
+export declare function textosAvisoTruncamento(exibidas: number, total: number): {
+    resumo: string;
+    botao: string;
+};
+export declare function renderizarAvisoTruncamento(camadaIdSeguro: string, exibidas: number, total: number): string;
+export declare function renderizarLinhaVazia(ehGrupo: boolean): string;
+export declare function mesmaLinhaFeicao(a: FeicaoItem, b: FeicaoItem): boolean;
+export declare function renderizarLinhaFeicao(feat: FeicaoItem, ctx: ContextoLinhaFeicao, selecionada: boolean, editando: boolean): string;

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

@@ -1,4 +1,4 @@
-import { MapaBaseItem } from './tipos';
+import { MapaBaseItem, MudancaFeicoes } 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). */
@@ -12,4 +12,11 @@ export interface HostRenderizavel extends CamadasHostCompleto {
     readonly mostrarRodape: boolean;
     getAttribute(nome: string): string | null;
 }
+/** Troca uma <img> de miniatura que não carregou pelo mesmo placeholder usado por "Sem Mapa". */
+export declare function substituirMiniaturaQuebrada(img: HTMLImageElement): void;
 export declare function renderizarPainel(host: HostRenderizavel, shadow: ShadowRoot, corpo: HTMLElement, dragDrop: CamadasDragDropManager): void;
+/**
+ * Tenta atualizar só as linhas de feição afetadas pela `mudanca`, sem tocar no resto do painel (foco, scroll e
+ * listeners das linhas existentes ficam como estão). Devolve `false` quando o chamador deve redesenhar tudo.
+ */
+export declare function renderizarFeicoesIncremental(host: HostRenderizavel, shadow: ShadowRoot, dragDrop: CamadasDragDropManager, mudanca: MudancaFeicoes): boolean;

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

@@ -9,4 +9,5 @@ export interface HostRenomear {
     dispararEvento(nome: string, detalhe: unknown): void;
     salvarLembrancaEstado?(): void;
 }
-export declare function vincularRenomearInline(host: HostRenomear, shadow: ShadowRoot): void;
+/** Liga o duplo clique de renomear nos nomes dentro de `raiz` (padrão: o painel todo). */
+export declare function vincularRenomearInline(host: HostRenomear, shadow: ShadowRoot, raiz?: ParentNode): void;

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

@@ -1,6 +1,11 @@
 import { CamadasHostCompleto } from './camadas-host';
+import { FeicaoItem } from './tipos';
 export declare function sincronizarCamadaAtivaDOM(host: CamadasHostCompleto, shadow: ShadowRoot): void;
 export declare function sincronizarSelecaoDOM(host: CamadasHostCompleto, shadow: ShadowRoot): void;
+/** Estado do círculo de seleção de uma camada: tudo selecionado, parte, ou nada (camada sem feições). */
+export declare function aplicarEstadoTarget(circle: Element | null, feats: readonly FeicaoItem[], selecionadas: ReadonlySet<string>): void;
+/** Contador, rótulo e modo (resumo × ações em massa) do rodapé, conforme a seleção atual. */
+export declare function sincronizarRodapeDOM(host: Pick<CamadasHostCompleto, 'camadas' | 'feicoes' | 'selectedFeatureIds'>, shadow: ShadowRoot): void;
 /**
  * Reflete no DOM o estado herdado dos grupos (sem redesenhar a árvore): esmaece o que está sob um
  * grupo oculto e trava os cadeados das feições cuja camada, ou um grupo acima dela, está travada.

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

@@ -117,6 +117,43 @@ export interface DetalheEventoMoverFeicao {
     camadaDestinoId: string;
     feicao: FeicaoItem;
 }
+/**
+ * O que uma mutação de feição (`adicionarFeicao`, `atualizarFeicao`, `removerFeicao`, `definirFeicoes`) alterou.
+ * Permite ao painel atualizar só as linhas afetadas em vez de redesenhar a árvore inteira.
+ */
+export interface MudancaFeicoes {
+    /** Camadas cujas feições mudaram (`''` = feição sem camada), ou `'todas'` (troca da lista inteira). */
+    camadas: ReadonlySet<string> | 'todas';
+    /** Ids de feições cuja linha precisa ser refeita (as demais linhas da camada continuam como estão). */
+    idsAlterados: ReadonlySet<string>;
+    /** A seleção mudou nesta mutação (o rodapé precisa ser atualizado mesmo sem seleção restante). */
+    selecaoAfetada: boolean;
+}
+/** Por que o painel desistiu da atualização incremental e redesenhou tudo. */
+export type MotivoRenderCompleto = 'arvore-nao-renderizada' | 'busca-ativa' | 'edicao-inline' | 'camada-orfa' | 'camada-fora-do-dom' | 'drawer-aberto' | 'ids-duplicados';
+/** Situação de uma camada afetada por uma mutação de feição. */
+export interface SituacaoCamadaAfetada {
+    /** A camada existe em `host.camadas`. */
+    existeNoModelo: boolean;
+    /** O grupo da camada está desenhado na árvore. */
+    renderizadaNoDom: boolean;
+    /** O drawer de configurações dessa camada está aberto (ele mostra a contagem de feições). */
+    drawerAberto: boolean;
+}
+export interface EntradaDecisaoIncremental {
+    arvoreRenderizada: boolean;
+    buscaAtiva: boolean;
+    editandoCamada: boolean;
+    editandoFeicao: boolean;
+    idsDuplicados: boolean;
+    camadasAfetadas: readonly SituacaoCamadaAfetada[];
+}
+export type DecisaoAtualizacao = {
+    incremental: true;
+} | {
+    incremental: false;
+    motivo: MotivoRenderCompleto;
+};
 export interface DetalheEventoAcaoMassa {
     feicoesIds: string[];
     feicoes: FeicaoItem[];

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

@@ -1,5 +1,5 @@
 import { SafeHTMLElement } from '../../core/ssr-safe';
-import { CamadaItem, FeicaoItem, MapaBaseItem, AbaPainelCamadas } from './tipos';
+import { CamadaItem, FeicaoItem, MapaBaseItem, AbaPainelCamadas, MudancaFeicoes } from './tipos';
 import { CamadasHostCompleto } from './camadas-host';
 import { LembrancaCamadas } from './camadas-lembranca';
 export declare class UICamadas extends SafeHTMLElement implements CamadasHostCompleto {
@@ -12,6 +12,8 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     private conectado;
     private profundidadeLote;
     private renderPendente;
+    /** Mudança de feições à espera do `render()` (consumida nele): permite atualizar só as linhas afetadas. */
+    private mudancaFeicoes;
     /** Painéis conectados sem `id` nem `storage-key`: dividem a mesma chave de persistência. */
     private static instanciasChavePadrao;
     /** @internal */
@@ -111,9 +113,16 @@ export declare class UICamadas extends SafeHTMLElement implements CamadasHostCom
     alternarColapso(emitirEvento?: boolean): void;
     private definirColapso;
     solicitarRenderizacao(): void;
+    /**
+     * Caminho das mutações de feição: o DOM fica atualizado na volta da chamada, mas só as linhas afetadas são
+     * refeitas quando possível. Em `emLote` vale o adiamento de sempre (uma renderização completa no fim).
+     * Qualquer caso que o caminho incremental não garanta (busca, edição inline, drawer, camada fora da árvore…)
+     * cai no render completo.
+     */
+    solicitarAtualizacaoFeicoes(mudanca: MudancaFeicoes): void;
     /**
      * Agrupa várias mutações (`adicionarFeicao` em laço, por exemplo) em uma só renderização, ao fim de `fn`.
-     * Sem isto, cada chamada redesenha a árvore inteira.
+     * Mesmo com a atualização incremental, é a forma ideal para cargas grandes: o DOM é refeito uma só vez.
      */
     emLote(fn: () => void): void;
     dispararEvento(nome: string, detalhe: unknown): void;

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

@@ -4,6 +4,7 @@ import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controlle
 import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
 import { ModoPopups } from '../../gerencigeo-canvas/popup_gate';
 import { ModoRenderizador } from '../../gerencigeo-canvas/renderers/feicoes_despachante';
+import { NivelQualidade, PerfilQualidade } from '../../gerencigeo-canvas/qualidade';
 import { EstatisticasFeicoes } from '../../gerencigeo-canvas/renderers/renderizador_feicoes_tipos';
 import { UsuarioRemoto } from '../../gerencigeo-canvas/feature_cursores';
 import { EventoMapaCad, LatLngEvento, OpcoesLinhaPadrao } from './tipos';
@@ -97,6 +98,18 @@ export declare class UICanvasCAD extends SafeHTMLElement {
      */
     get renderizador(): ModoRenderizador;
     set renderizador(val: ModoRenderizador);
+    /**
+     * Perfil de desempenho do canvas (atributo `qualidade`): `alta` (padrão, comportamento de sempre), `media` ou `baixa`.
+     * `media` e `baixa` trocam fidelidade visual por velocidade: renderizador `canvas` (se `renderizador` não foi dado),
+     * marcas e simplificação mais agressivas, zoom em passos maiores; `baixa` ainda usa dpr 1, linhas sem tracejado e
+     * sem animação de zoom nem inércia. Valor inválido usa `alta`. Ao mudar, o mapa é ajustado e as camadas de feições
+     * são recriadas; a API, os eventos e os dados não mudam.
+     */
+    get qualidade(): NivelQualidade;
+    set qualidade(val: NivelQualidade);
+    /** Perfil completo vigente (valores numéricos do nível em `qualidade`). */
+    get perfilQualidade(): PerfilQualidade;
+    private aplicarQualidadeAoMapa;
     /**
      * Contadores do desenho de uma camada de feições (`total`, `materializadas`, `desenhadas`, `marcasLOD`, `clusters`,
      * `canvases`, `renderizador`...), para diagnóstico e benchmark. `null` se a camada não está desenhada.