@thibezer/ui-components-kit 2.12.5 → 2.13.0

package/dist/gerencigeo-canvas/motor/motor-formas.d.ts

@@ -6,6 +6,16 @@ export type ParteLista = 'tudo' | 'canvas' | 'dom';
 export declare class MotorFormas {
     private camadas;
     private regra;
+    private limiteMarcaPx;
+    private toleranciaPx;
+    /**
+     * Ajusta o LOD (diagonal em px abaixo da qual a feição vira marca) e a tolerância da simplificação em px (perfis de
+     * `qualidade.ts`). Valor inválido (NaN, <= 0) mantém o atual. Ao mudar de verdade, os caches por zoom são descartados.
+     */
+    definirQualidade(opcoes: {
+        limiteMarcaPx?: number;
+        toleranciaPx?: number;
+    }): void;
     /** Cria a camada ou atualiza a definição (estilo, zIndex, opacidade, visibilidade). */
     definirCamada(def: DefCamadaMotor): void;
     removerCamada(camadaId: string): void;

package/dist/gerencigeo-canvas/qualidade.d.ts

@@ -0,0 +1,52 @@
+export type NivelQualidade = 'alta' | 'media' | 'baixa';
+export type ModoRenderizadorPadrao = 'leaflet' | 'canvas';
+export interface PerfilQualidade {
+    nivel: NivelQualidade;
+    /** Renderizador das feições quando o atributo `renderizador` não foi dado. */
+    renderizadorPadrao: ModoRenderizadorPadrao;
+    /** Teto do `devicePixelRatio` dos canvases de feições (1 ou 2; `L.Browser.retina` continua sendo o limite superior). */
+    dprMaximo: 1 | 2;
+    /** Diagonal (px) abaixo da qual a feição é desenhada como marca de 1–2 px. */
+    limiteMarcaPx: number;
+    /** Tolerância (px) do Douglas-Peucker de formas projetadas. */
+    toleranciaPx: number;
+    /** Desenha `dashArray` (traço tracejado). Falso = linha contínua (mais barato no Canvas 2D). */
+    tracejado: boolean;
+    /** Animação de zoom, fade de tiles e animação de marcadores do Leaflet. */
+    animacoes: boolean;
+    /** Inércia ao soltar o arraste. */
+    inercia: boolean;
+    zoomSnap: number;
+    zoomDelta: number;
+    /** Quantas fileiras de tiles ficam em memória além da vista. */
+    keepBuffer: number;
+}
+export declare const NIVEIS_QUALIDADE: readonly NivelQualidade[];
+/** Valor do atributo -> nível. Ausente, vazio ou inválido cai em `alta` (o comportamento anterior ao atributo). */
+export declare function lerNivelQualidade(valor: string | null | undefined): NivelQualidade;
+export declare function perfilDe(nivel: NivelQualidade): PerfilQualidade;
+/** Atalho: valor do atributo -> perfil. */
+export declare function perfilDoAtributo(valor: string | null | undefined): PerfilQualidade;
+/**
+ * Renderizador efetivo: o atributo `renderizador`, quando dado, manda (inclusive valor inválido = `leaflet`, como
+ * sempre foi); sem ele vale o padrão do perfil.
+ */
+export declare function modoRenderizadorEfetivo(atributo: string | null | undefined, perfil: PerfilQualidade): ModoRenderizadorPadrao;
+/** O que o perfil mexe no mapa do Leaflet (contrato estrutural: os internos `_zoomAnimated`/`_fadeAnimated` são opcionais). */
+export interface MapaAjustavel {
+    options: {
+        zoomSnap?: number;
+        zoomDelta?: number;
+        inertia?: boolean;
+        zoomAnimation?: boolean;
+        fadeAnimation?: boolean;
+        markerZoomAnimation?: boolean;
+    };
+    _zoomAnimated?: boolean;
+    _fadeAnimated?: boolean;
+}
+/**
+ * Aplica o perfil às opções do mapa já criado. Reversível: o que o Leaflet calculou na criação (`_zoomAnimated`,
+ * `_fadeAnimated`) é guardado na primeira chamada e restaurado ao voltar para um perfil com `animacoes`. Nunca lança.
+ */
+export declare function aplicarPerfilAoMapa(mapa: MapaAjustavel | null | undefined, perfil: PerfilQualidade): void;

package/dist/gerencigeo-canvas/renderers/canvas_formas_leaflet.d.ts

@@ -36,6 +36,8 @@ export interface OpcoesCanvasFormas extends L.RendererOptions {
     incremental?: boolean;
     /** Pan incremental com até tantos itens no bitmap: repinta inteiro em vez de deslocar (padrão: `CanvasFormas.limiteRepintar`). */
     limiteRepintar?: number;
+    /** Teto do multiplicador de retina (padrão 2 = o do Leaflet; 1 = nunca acima de 1×). */
+    dprMaximo?: 1 | 2;
 }
 /** Regiões que ficam vazias quando o conteúdo se desloca de (`dx`, `dy`) px: a faixa vertical inteira e a horizontal sem a quina. */
 export declare function regioesExpostas(largura: number, altura: number, dx: number, dy: number): RegiaoPx[];
@@ -65,7 +67,16 @@ export declare class CanvasFormas extends L.Canvas {
     /** Quantas pinturas falharam (e a última causa): diagnóstico, já que a falha é engolida. */
     falhas: number;
     ultimoErro: unknown;
+    /** Teto do multiplicador de retina (perfil `qualidade`): 1 pinta 4× menos pixels num monitor retina. */
+    private dprTeto;
     constructor(opcoes: OpcoesCanvasFormas, aoPintar: PintarQuadro);
+    /** Multiplicador de retina efetivo: o do Leaflet limitado pelo teto do perfil. */
+    private get multiplicador();
+    /**
+     * Troca o teto do multiplicador em execução. Se o canvas já está no mapa e o efetivo mudou, reposiciona (o bitmap é
+     * redimensionado) e repinta tudo.
+     */
+    definirDprMaximo(teto: number): void;
     private get limiteRepintar();
     /**
      * O primeiro `update` do canvas acontece antes de o Leaflet ouvi-lo (e o `onAdd` do L.Canvas ainda limpa o canvas):

package/dist/gerencigeo-canvas/renderers/renderizador_formas.d.ts

@@ -75,7 +75,10 @@ export declare class PintorCanvas2D implements RenderizadorFormas {
     private destruido;
     /** Estatística da última pintura (diagnóstico e testes). */
     ultima: EstatisticasPintura;
+    /** Perfil de qualidade `baixa`: ignora `dash` (linha contínua, mais barata no Canvas 2D). */
+    private semTracejado;
     constructor(alvos: AlvosPintura);
+    definirTracejado(ligado: boolean): void;
     destacar(ids: Iterable<string>): void;
     limpar(): void;
     destruir(): void;

package/dist/gerencigeo-canvas/renderers/tile_renderer.d.ts

@@ -2,7 +2,7 @@ import { default as L } from 'leaflet';
 import { ILayerRenderer } from '../layer_renderer_factory';
 import { CanvasLayerDef, CanvasRenderContext } from '../types';
 export declare class TileLayerRenderer implements ILayerRenderer {
-    render(layerDef: CanvasLayerDef, _map: L.Map, _context: CanvasRenderContext): L.Layer | null;
+    render(layerDef: CanvasLayerDef, _map: L.Map, context: CanvasRenderContext): L.Layer | null;
     /** Opacidade, z-index e visibilidade são do pane da camada (LayerManager): nada a atualizar aqui. */
     update(): void;
     destroy(layerInstance: L.Layer, map: L.Map): void;

package/dist/gerencigeo-canvas/types.d.ts

@@ -191,4 +191,6 @@ export interface CanvasRenderContext {
     regraVersoes?: import('./feature_versoes').RegraVersoes;
     /** Qual renderizador desenha as camadas de feições (atributo `renderizador` do componente). Ausente = `leaflet`. */
     renderizador?: () => 'leaflet' | 'canvas';
+    /** Perfil de qualidade vigente (atributo `qualidade` do componente). Ausente = `alta` (comportamento de sempre). */
+    qualidade?: () => import('./qualidade').PerfilQualidade;
 }