@json_1013/core-geografico-isa-mapa 0.1.0-poc

package/dist-lib/tipos/features/maps/components/iconos.d.ts

@@ -0,0 +1,51 @@
+interface PropsIcono {
+    className?: string;
+}
+interface PropsIconoHerramienta extends PropsIcono {
+    codigo: string;
+    /** Ícono real de la herramienta (`herramienta.rutaIcono` del contrato). */
+    rutaIcono?: string;
+    /** Estado activo (hoy solo `three-dimensional` cambia de ícono). */
+    activo?: boolean;
+}
+/** Ícono de una herramienta: `rutaIcono` del backend, el propio de `assets/icons` o uno genérico. */
+export declare function IconoHerramienta({ codigo, rutaIcono, activo, className, }: PropsIconoHerramienta): import("react").JSX.Element;
+/** Aspa (X): cerrar paneles y modales. */
+export declare function IconoCerrar({ className }: PropsIcono): import("react").JSX.Element;
+/** Círculo con "i": ilustra el aviso de una modal de alerta. */
+export declare function IconoAlerta({ className }: PropsIcono): import("react").JSX.Element;
+/** Flechas circulares: restablece la medición en curso. */
+export declare function IconoRestablecerMedida({ className }: PropsIcono): import("react").JSX.Element;
+/** Flechas verticales opuestas: intercambia origen y destino. */
+export declare function IconoIntercambiar({ className }: PropsIcono): import("react").JSX.Element;
+/** Pin de ubicación: marca en el mapa el punto de coordenadas escrito. */
+export declare function IconoMarcarPunto({ className }: PropsIcono): import("react").JSX.Element;
+/** Barra tenue: asa para arrastrar una modal. */
+export declare function IconoArrastrar({ className }: PropsIcono): import("react").JSX.Element;
+/** Flecha hacia la izquierda: volver a la vista anterior. */
+export declare function IconoRegresar({ className }: PropsIcono): import("react").JSX.Element;
+/** Tabla con lupa: vuelve a ver la tabla de resultados sin repetir la búsqueda. */
+export declare function IconoVerTabla({ className }: PropsIcono): import("react").JSX.Element;
+/** Lupa con "+": encuadra el mapa a la extensión de la capa. */
+export declare function IconoZoomALaCapa({ className }: PropsIcono): import("react").JSX.Element;
+/** Flecha hacia una bandeja: descarga en GeoJSON lo visible de la capa. */
+export declare function IconoDescargar({ className }: PropsIcono): import("react").JSX.Element;
+/** Dos rectángulos superpuestos: copia un valor al portapapeles. */
+export declare function IconoCopiar({ className }: PropsIcono): import("react").JSX.Element;
+/** Palomita: confirma que el valor ya se copió al portapapeles. */
+export declare function IconoCopiado({ className }: PropsIcono): import("react").JSX.Element;
+/** Lupa: filtro de texto de un combo buscable. */
+export declare function IconoBuscar({ className }: PropsIcono): import("react").JSX.Element;
+/** Flecha "v": indicador de submenú desplegable. */
+export declare function IconoChevron({ className }: PropsIcono): import("react").JSX.Element;
+/** Bombillo con rayos: ícono del control de opacidad de las capas. */
+export declare function IconoOpacidad({ className }: PropsIcono): import("react").JSX.Element;
+/** Controles deslizantes: opciones de un servicio o capa. */
+export declare function IconoOpcionesCapa({ className }: PropsIcono): import("react").JSX.Element;
+/** Documento con líneas: fuente de información del servicio. */
+export declare function IconoFuenteInformacion({ className }: PropsIcono): import("react").JSX.Element;
+/** Ojo verde: indica que la capa está visible (activa). */
+export declare function IconoOjo({ className }: PropsIcono): import("react").JSX.Element;
+/** Ojo tachado: indica que la capa está oculta. */
+export declare function IconoOjoTachado({ className }: PropsIcono): import("react").JSX.Element;
+export {};

package/dist-lib/tipos/features/maps/context/alertas.context.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from "react";
+/**
+ * Aviso mostrado al usuario: informativo (un solo botón) o, con `alConfirmar`,
+ * de confirmación (dos botones, "No"/"Sí").
+ */
+export interface Alerta {
+    /** Identificador interno para quitarla de la cola. */
+    id: string;
+    /** Título breve de la cabecera. */
+    titulo: string;
+    /** Cuerpo del aviso; acepta ReactNode para resaltar parte del texto. */
+    mensaje: ReactNode;
+    /** Texto del botón principal. Por defecto "Entendido", o "Sí" en modo confirmación. */
+    textoBoton?: string;
+    /** Solo en modo confirmación: texto del botón secundario. Por defecto "No". */
+    textoCancelar?: string;
+    /** Con manejador, el aviso pasa a modo confirmación. Se llama al elegir el botón principal. */
+    alConfirmar?: () => void;
+    /** Solo en confirmación: se llama al declinar, antes de quitar el aviso. */
+    alCancelar?: () => void;
+}
+/** API para mostrar y cerrar avisos desde cualquier parte del árbol. */
+export interface ContextoAlertasValor {
+    /** Encola un aviso; ignora los repetidos (mismo `titulo` ya en cola). */
+    mostrar: (alerta: Omit<Alerta, "id">) => void;
+    /** Quita de la cola el aviso con ese `id`. */
+    cerrar: (id: string) => void;
+}
+/** Estado de los avisos compartido en el árbol de la app. */
+export declare const ContextoAlertas: import("react").Context<ContextoAlertasValor | null>;
+/** Accede a la API de avisos; debe usarse dentro de <ProveedorAlertas>. */
+export declare function useAlerta(): ContextoAlertasValor;

package/dist-lib/tipos/features/maps/context/configuracion.context.d.ts

@@ -0,0 +1,6 @@
+import type { RecursoAsync } from "../../../shared/hooks/useRecursoAsync";
+import type { ConfiguracionAplicacion } from "../types";
+/** Estado de la configuración compartida en el árbol de la app. */
+export declare const ContextoConfiguracion: import("react").Context<RecursoAsync<ConfiguracionAplicacion> | null>;
+/** Accede a la configuración cargada; debe usarse dentro de <ProveedorConfiguracion>. */
+export declare function useConfiguracionAplicacion(): RecursoAsync<ConfiguracionAplicacion>;

package/dist-lib/tipos/features/maps/hooks/useCoordenadasPuntero.d.ts

@@ -0,0 +1,11 @@
+import type { VistaMapa } from "../types";
+/** Coordenadas geográficas (longitud/latitud). */
+export interface CoordenadasPuntero {
+    longitud: number;
+    latitud: number;
+}
+/**
+ * Coordenadas geográficas bajo el puntero (conserva la última al salir del mapa).
+ * Se calcula una vez por `requestAnimationFrame` y solo si cambió.
+ */
+export declare function useCoordenadasPuntero(vista: VistaMapa | null): CoordenadasPuntero | null;

package/dist-lib/tipos/features/maps/hooks/useCoordenadasSeleccion.d.ts

@@ -0,0 +1,4 @@
+import type { VistaMapa } from "../types";
+import type { CoordenadasPuntero } from "./useCoordenadasPuntero";
+/** Coordenadas WGS84 del último clic mientras `activa`, con un punto de referencia. */
+export declare function useCoordenadasSeleccion(vista: VistaMapa | null, activa: boolean): CoordenadasPuntero | null;

package/dist-lib/tipos/features/maps/hooks/useElevarSuperficies.d.ts

@@ -0,0 +1,10 @@
+import { type PointerEvent } from "react";
+/**
+ * Orden de apilamiento de las superficies por `z-index`, con contadores separados
+ * para ancladas y flotantes. `raizRef` va en el contenedor.
+ */
+export declare function useElevarSuperficies<Elemento extends HTMLElement>(): {
+    raizRef: import("react").RefObject<Elemento | null>;
+    elevarModal: (evento: PointerEvent<HTMLElement>) => void;
+    elevarSuperficie: (clave: string) => void;
+};

package/dist-lib/tipos/features/maps/hooks/useEstadosCapas.d.ts

@@ -0,0 +1,16 @@
+import type { GestorCapasMapa } from "../services/layers/gestor-capas";
+import type { EstadosCapas, ServicioGis } from "../types";
+/** Valor devuelto por `useEstadosCapas`. */
+interface ControlEstadosCapas {
+    estados: EstadosCapas;
+    onCambioServicio: (nombre: string, visible: boolean) => void;
+    onCambioOpacidad: (nombre: string, opacidad: number) => void;
+    onCambioOpacidadCapa: (nombre: string, identificador: string, opacidad: number) => void;
+    onCambioCapa: (nombre: string, identificador: string, visible: boolean) => void;
+}
+/**
+ * Estado del panel de capas sincronizado con el gestor imperativo de ArcGIS:
+ * cada cambio actualiza React y aplica la operación sobre `gestorRef.current`.
+ */
+export declare function useEstadosCapas(servicios: readonly ServicioGis[], gestorRef: React.RefObject<GestorCapasMapa | null>): ControlEstadosCapas;
+export {};

package/dist-lib/tipos/features/maps/hooks/useGestorCapas.d.ts

@@ -0,0 +1,16 @@
+import type { CapaServicio, ServicioGis, VistaMapa } from "../types";
+import { GestorCapasMapa, type FalloServicio } from "../services/layers/gestor-capas";
+/** Subcapas descubiertas en runtime, indexadas por nombre de servicio. */
+export type CapasDescubiertas = ReadonlyMap<string, readonly CapaServicio[]>;
+/** Valor devuelto por `useGestorCapas`. */
+interface GestorCapas {
+    gestorRef: React.RefObject<GestorCapasMapa | null>;
+    /** Subcapas leídas de la metadata del servidor para servicios que no las declaran. */
+    capasDescubiertas: CapasDescubiertas;
+}
+/**
+ * Instancia el gestor de capas cuando la vista está lista y lo destruye al
+ * desmontar. Devuelve su ref y las subcapas descubiertas en runtime.
+ */
+export declare function useGestorCapas(vista: VistaMapa | null, servicios: readonly ServicioGis[], reportarFallos?: (fallos: readonly FalloServicio[]) => void): GestorCapas;
+export {};

package/dist-lib/tipos/features/maps/hooks/useHerramientaActiva.d.ts

@@ -0,0 +1,14 @@
+import type { HerramientaMapa, VistaMapa } from "../types";
+/** Valor devuelto por `useHerramientaActiva`. */
+interface EstadoHerramienta {
+    codigoActivo: string | undefined;
+    codigoPadreActivo: string | undefined;
+    alternar: (codigo: string) => void;
+    alternarSubHerramienta: (subCodigo: string) => void;
+}
+/**
+ * Gestiona qué herramienta está activa y monta/desmonta su controlador de
+ * ArcGIS, reutilizándolo cuando solo cambia la sub-herramienta del mismo grupo.
+ */
+export declare function useHerramientaActiva(vista: VistaMapa | null, herramientas: readonly HerramientaMapa[], obtenerContenedorUI: () => HTMLDivElement | null): EstadoHerramienta;
+export {};

package/dist-lib/tipos/features/maps/hooks/useListbox.d.ts

@@ -0,0 +1,53 @@
+import { type KeyboardEvent } from "react";
+/** Posición de un panel flotante, anclado por un solo borde (el otro va en `null`). */
+export interface CajaPanel {
+    top: number | null;
+    bottom: number | null;
+    left: number;
+    width: number;
+}
+/** Configura `manejarTeclado` para lo que cada disparador tiene de propio. */
+export interface AccionesTeclado {
+    /** Teclas extra (aparte de las flechas) que abren el panel estando cerrado. */
+    teclasQueAbren?: readonly string[];
+    /** Reemplaza `abrir()` al abrir por teclado (ej. para reiniciar un filtro). */
+    alAbrir?: () => void;
+    /** Enter (y Espacio, si `espacioConfirma`) con el panel abierto. */
+    onEnter: () => void;
+    /** Espacio también confirma como Enter; no usar si el disparador es un campo de texto. */
+    espacioConfirma?: boolean;
+    /** Reemplaza el cierre por defecto (`cerrar`) al presionar Escape. */
+    onEscape?: () => void;
+    /** Reemplaza el cierre por defecto (`cerrar`) al presionar Tab. */
+    onTab?: () => void;
+    /** Habilita Home/End para saltar a la primera/última opción. */
+    primeraUltima?: readonly [primero: number, ultimo: number];
+}
+/** Opciones de `useListbox`. */
+interface OpcionesListbox {
+    /** Mide el disparador (getter en vez de `ref`: quien lo crea lo mide). */
+    medir: () => DOMRect | undefined;
+    /** Cuántas opciones tiene ahora la lista, para acotar el resaltado. */
+    total: number;
+    /** Opción a dejar resaltada al abrir (por defecto, la primera). */
+    indiceInicial?: number;
+    /** Se llama al cerrar sin elegir de la lista (permite confirmar texto escrito). */
+    alCerrar?: () => void;
+}
+/**
+ * Mecánica compartida de los selectores con listado en portal (`SelectorDesplegable`,
+ * `ComboBuscable`): posición del panel, resaltado y cierre. No sabe qué es una opción;
+ * los `ref` los posee quien monta el disparador y el panel.
+ */
+export declare function useListbox(disparadorRef: React.RefObject<HTMLElement | null>, panelRef: React.RefObject<HTMLUListElement | null>, { medir, total, indiceInicial, alCerrar }: OpcionesListbox): {
+    abierto: boolean;
+    caja: CajaPanel | null;
+    indiceActivo: number;
+    abrir: (indice?: number) => void;
+    cerrar: () => void;
+    ocultar: () => void;
+    moverIndice: (salto: number) => void;
+    setIndiceActivo: import("react").Dispatch<import("react").SetStateAction<number>>;
+    manejarTeclado: (evento: KeyboardEvent<HTMLElement>, acciones: AccionesTeclado) => void;
+};
+export {};

package/dist-lib/tipos/features/maps/hooks/useMarcadorPunto.d.ts

@@ -0,0 +1,15 @@
+import type Point from "@arcgis/core/geometry/Point";
+import SimpleMarkerSymbol from "@arcgis/core/symbols/SimpleMarkerSymbol";
+import type { VistaMapa } from "../types";
+/** Símbolo del punto de referencia, compartido con `useCoordenadasSeleccion`. */
+export declare const SIMBOLO_MARCADOR_PUNTO: SimpleMarkerSymbol;
+/** Valor devuelto por `useMarcadorPunto`. */
+interface MarcadorPunto {
+    /** Coloca (o mueve, si ya existe) el punto de referencia en `vista.graphics`. */
+    marcar: (punto: Point) => void;
+    /** Quita el punto de referencia de la vista. */
+    quitar: () => void;
+}
+/** Marca un único punto en la vista (lo añade una vez y luego lo mueve); se quita al desmontar. */
+export declare function useMarcadorPunto(vista: VistaMapa): MarcadorPunto;
+export {};

package/dist-lib/tipos/features/maps/hooks/useModalArrastrable.d.ts

@@ -0,0 +1,33 @@
+/** Punto en coordenadas del viewport. */
+interface Posicion {
+    readonly x: number;
+    readonly y: number;
+}
+/** Parámetros de `useModalArrastrable`. */
+interface OpcionesModalArrastrable {
+    /** Ancho fijo del elemento flotante (px). */
+    readonly ancho: number;
+    /** Alto estimado (px) hasta medir el real con `ref`. */
+    readonly alto: number;
+    /** Separación mínima con el borde de la ventana (px). Por defecto `8`. */
+    readonly margen?: number;
+    /** Reserva inferior (px) para no tapar la barra de herramientas. Por defecto, `margen`. */
+    readonly margenInferior?: number;
+    /** Reserva inferior usada solo al ubicar la modal por primera vez. */
+    readonly margenInferiorInicial?: number;
+}
+/** Valor devuelto por `useModalArrastrable`. */
+interface ModalArrastrable {
+    /** Posición actual, siempre dentro de la ventana. */
+    readonly posicion: Posicion;
+    /** `onPointerDown` del asa de arrastre. */
+    readonly alArrastrar: (evento: React.PointerEvent<HTMLElement>) => void;
+    /** `ref` del contenedor: acota el arrastre con su alto real. */
+    readonly ref: (nodo: HTMLElement | null) => void;
+}
+/**
+ * Posiciona un elemento flotante y lo hace arrastrable sin salir de la ventana,
+ * con captura de puntero para que siga al cursor y no se quede pegado.
+ */
+export declare function useModalArrastrable({ ancho, alto, margen, margenInferior, margenInferiorInicial, }: OpcionesModalArrastrable): ModalArrastrable;
+export {};

package/dist-lib/tipos/features/maps/hooks/useModoResponsive.d.ts

@@ -0,0 +1,14 @@
+/** Valor devuelto por `useModoResponsive`. */
+interface ModoResponsive<T extends HTMLElement> {
+    /** `ref` callback a enlazar en el contenedor del mapa (normalmente su `<section>` raíz). */
+    readonly ref: (elemento: T | null) => void;
+    /** Ancho medido del contenedor (px), `null` hasta la primera medición. */
+    readonly ancho: number | null;
+    /** Alto medido del contenedor (px), `null` hasta la primera medición. */
+    readonly alto: number | null;
+    /** `true` si el contenedor es más angosto que el mínimo; sin medición, se asume escritorio. */
+    readonly responsive: boolean;
+}
+/** Modo de layout según el ancho del contenedor (no del viewport); expone también el alto. */
+export declare function useModoResponsive<T extends HTMLElement>(): ModoResponsive<T>;
+export {};

package/dist-lib/tipos/features/maps/hooks/usePanelesInferiores.d.ts

@@ -0,0 +1,10 @@
+/** Valor devuelto por `usePanelesInferiores`. */
+interface PanelesInferiores {
+    readonly panelCapasAbierto: boolean;
+    readonly panelBaseMapAbierto: boolean;
+    readonly togglePanelCapas: () => void;
+    readonly togglePanelBaseMap: () => void;
+}
+/** Paneles "Capas" y "Mapa base": independientes en escritorio, excluyentes en responsive. */
+export declare function usePanelesInferiores(modoResponsive: boolean): PanelesInferiores;
+export {};

package/dist-lib/tipos/features/maps/hooks/useRenovacionToken.d.ts

@@ -0,0 +1,3 @@
+import type { ConfiguracionAplicacion } from "../types";
+/** Renueva los tokens GIS antes de que venzan y devuelve la configuración actualizada. */
+export declare function useRenovacionToken(datosBase: ConfiguracionAplicacion | undefined, cargar: () => Promise<ConfiguracionAplicacion>): ConfiguracionAplicacion | undefined;

package/dist-lib/tipos/features/maps/hooks/useResaltadoConsulta.d.ts

@@ -0,0 +1,19 @@
+import type Graphic from "@arcgis/core/Graphic";
+import type { VistaMapa } from "../types";
+/** Valor devuelto por `useResaltadoConsulta`. */
+interface ResaltadoConsulta {
+    /** Reemplaza el resaltado de una clave de capa sin afectar el de las demás (ej. Línea y Torre a la vez). */
+    mostrarCapa: (clave: string, graficos: readonly Graphic[]) => void;
+    /** Quita del resaltado solo los clones de una clave (cerrar su pestaña). */
+    quitarCapa: (clave: string) => void;
+    /** Repinta todas las entidades resaltadas según qué filas están marcadas. */
+    sincronizarSeleccion: (seleccionados: ReadonlySet<Graphic>) => void;
+    /** Vacía el resaltado (acción "clear" o al cerrar los resultados). */
+    limpiar: () => void;
+}
+/**
+ * Capa de resaltado de Consultar en `vista.map` (no en `vista.graphics`, que usan
+ * otras herramientas). La selección vive en `MapaView`.
+ */
+export declare function useResaltadoConsulta(vista: VistaMapa | null): ResaltadoConsulta;
+export {};

package/dist-lib/tipos/features/maps/hooks/useResultadosConsulta.d.ts

@@ -0,0 +1,31 @@
+import type Graphic from "@arcgis/core/Graphic";
+import type { CapaConsultable, ResultadoConsultaCapa, ResultadosConsultaCapas, VistaMapa } from "../types";
+import type { useResaltadoConsulta } from "./useResaltadoConsulta";
+/** Valor devuelto por `useResultadosConsulta`. */
+interface ResultadosConsulta {
+    resultados: ResultadosConsultaCapas;
+    /** Filas marcadas (checkbox) de la pestaña activa. Un único `Set` global
+     * (no uno por capa): los `Graphic` de capas distintas nunca son el mismo
+     * objeto, así que no hay ambigüedad. */
+    seleccionados: ReadonlySet<Graphic>;
+    /** Agrega o actualiza la pestaña de esa capa sin tocar las demás. */
+    onResultado: (resultado: ResultadoConsultaCapa, capa: CapaConsultable) => void;
+    /** Cierra una pestaña de resultados sin afectar las demás. */
+    onQuitarPestana: (clave: string) => void;
+    /** Cambia la pestaña activa y centra el mapa en esa capa. */
+    onCambiarPestana: (clave: string) => void;
+    /** Marca/desmarca una fila; acerca la vista a la entidad al marcarla. */
+    onAlternarFila: (grafico: Graphic) => void;
+    /** Lupa por fila: acerca la vista sin alterar la selección. */
+    onZoomFila: (grafico: Graphic) => void;
+    /** Checkbox "marcar todas" de la pestaña activa. */
+    onAlternarTodos: () => void;
+    /** Vacía todos los resultados, la selección y su resaltado en el mapa. */
+    limpiar: () => void;
+}
+/**
+ * Estado de "Consultar": una pestaña por capa, filas marcadas y resaltado. Vive en
+ * `MapaView` para sobrevivir al cierre del formulario.
+ */
+export declare function useResultadosConsulta(vista: VistaMapa | null, resaltadoConsulta: ReturnType<typeof useResaltadoConsulta>): ResultadosConsulta;
+export {};

package/dist-lib/tipos/features/maps/hooks/useVistaArcgis.d.ts

@@ -0,0 +1,17 @@
+import type { ConfiguracionVisualMapa, VistaMapa } from "../types";
+/** Valor devuelto por `useVistaArcgis`. */
+interface VistaArcgis {
+    contenedorRef: React.RefObject<HTMLDivElement | null>;
+    vista: VistaMapa | null;
+    /** Error de inicialización del mapa; `null` mientras carga o si tuvo éxito. */
+    error: Error | null;
+    cambiarBasemap: (codigo: string) => void;
+    /** Regresa el mapa al viewpoint con el que se inicializó. */
+    irAInicio: () => void;
+}
+/**
+ * Crea y destruye la vista de ArcGIS (`MapView` o `SceneView`, cargado en diferido),
+ * conservando el encuadre al alternar y aplicando el cambio de mapa base.
+ */
+export declare function useVistaArcgis(configuracion: ConfiguracionVisualMapa | undefined, tridimensional: boolean): VistaArcgis;
+export {};

package/dist-lib/tipos/features/maps/providers/ProveedorAlertas.d.ts

@@ -0,0 +1,3 @@
+import type { PropsConHijos } from "../../../shared/types";
+/** Cola de avisos que muestra el primero con `ModalAlerta`; se usa con `useAlerta().mostrar(...)`. */
+export declare function ProveedorAlertas({ children }: PropsConHijos): import("react").JSX.Element;

package/dist-lib/tipos/features/maps/providers/ProveedorConfiguracion.d.ts

@@ -0,0 +1,14 @@
+import type { PropsConHijos } from "../../../shared/types";
+import { type ProveedorTokenAcceso } from "../services/configuracion-aplicacion";
+interface ProveedorConfiguracionProps extends PropsConHijos {
+    /** Identifica la aplicación anfitriona ante el backend. */
+    clientId: string;
+    /** Emite el JWT del contrato frontend/backend para `clientId`. */
+    getAccessToken: ProveedorTokenAcceso;
+}
+/**
+ * Carga una única vez la configuración del visor y la expone al árbol.
+ * Es el único componente que conoce el servicio de configuración.
+ */
+export declare function ProveedorConfiguracion({ children, clientId, getAccessToken, }: ProveedorConfiguracionProps): import("react").JSX.Element;
+export {};

package/dist-lib/tipos/features/maps/services/configuracion-aplicacion.d.ts

@@ -0,0 +1,10 @@
+import type { ConfiguracionAplicacion } from "../types";
+/** Entrega un JWT para `clientId` (demo: `firmarToken`; librería: controlador del anfitrión). */
+export type ProveedorTokenAcceso = (clientId: string) => Promise<string>;
+/** Devuelve el vencimiento más próximo de los tokens GIS (epoch ms). */
+export declare function validateToken(configuracion: ConfiguracionAplicacion): number | undefined;
+/**
+ * Obtiene la configuración del visor del backend (JWT Bearer) y normaliza tipos y
+ * URLs de servicios. Requiere `apiBaseUrl` en el entorno (`configurarEntorno`).
+ */
+export declare function obtenerConfiguracionAplicacion(clientId: string, getAccessToken: ProveedorTokenAcceso): Promise<ConfiguracionAplicacion>;

package/dist-lib/tipos/features/maps/services/entorno.d.ts

@@ -0,0 +1,8 @@
+import { type EntornoMapa } from "../../../shared/entorno";
+export type { EntornoMapa } from "../../../shared/entorno";
+export { obtenerEntorno } from "../../../shared/entorno";
+/**
+ * Configura el visor en tiempo de ejecución: guarda la URL del backend y
+ * aplica al SDK de ArcGIS la API key y la ruta de assets, si vienen.
+ */
+export declare function configurarEntorno(cambios: EntornoMapa): void;

package/dist-lib/tipos/features/maps/services/formato-coordenadas.d.ts

@@ -0,0 +1,4 @@
+/** Coordenadas geográficas en grados/minutos/segundos: `longitud / latitud`. */
+export declare function formatearCoordenadas(longitud: number, latitud: number): string;
+/** Un eje WGS84 (EPSG:4326) individual en grados decimales, p. ej. `4.570868°`. */
+export declare function formatearGradosDecimales(valor: number, decimales?: number): string;

package/dist-lib/tipos/features/maps/services/layers/arcgis.factory.d.ts

@@ -0,0 +1,8 @@
+import type { ServicioGis } from "../../types";
+import type { CapasServicioConstruidas } from "./types";
+/** ARCGIS_MAP: un único MapImageLayer con subcapas opcionales. */
+export declare function crearMapaImagen(servicio: ServicioGis): CapasServicioConstruidas;
+/** ARCGIS_FEATURE: una FeatureLayer por cada capa configurada. */
+export declare function crearFeatures(servicio: ServicioGis): CapasServicioConstruidas;
+/** ARCGIS_TILE: exactamente una capa cacheada por servicio. */
+export declare function crearTileCachedo(servicio: ServicioGis): CapasServicioConstruidas;

package/dist-lib/tipos/features/maps/services/layers/consulta-arcgis.d.ts

@@ -0,0 +1,20 @@
+import type SpatialReference from "@arcgis/core/geometry/SpatialReference";
+import type FeatureLayer from "@arcgis/core/layers/FeatureLayer";
+import type { CampoConsulta, FiltroConsulta, ParametrosConsulta, ResultadoConsultaCapa, ValoresDistintosCampo } from "../../types";
+/**
+ * Traduce el filtro a un `where` de ArcGIS REST: `LIKE` usa `UPPER(...) LIKE UPPER(...)`
+ * y los demás comillan el valor si el campo no es numérico.
+ */
+export declare function armarWhereArcgis(filtro: FiltroConsulta, campos: readonly CampoConsulta[]): string;
+/** Campos consultables de una `FeatureLayer` individual (`ARCGIS_FEATURE`). */
+export declare function camposArcgisFeature(capa: FeatureLayer): Promise<CampoConsulta[]>;
+/** Campos consultables de una subcapa de `MapImageLayer`, vía su metadata REST. */
+export declare function camposArcgisRest(url: string, token?: string): Promise<CampoConsulta[]>;
+/** Valores distintos de un campo (combo buscable de "Valores"), acotados a `topeValoresConsulta`. */
+export declare function valoresDistintosArcgis(url: string, campo: string, parametros: ParametrosConsulta, token?: string): Promise<ValoresDistintosCampo>;
+/** Resultado crudo de una consulta ArcGIS; `total` son las entidades devueltas. */
+export type ResultadoConsultaArcgis = Omit<ResultadoConsultaCapa, "campos" | "filasDevueltas"> & {
+    total: number;
+};
+/** Ejecuta la consulta por atributos y resuelve, en paralelo, su extensión real. */
+export declare function ejecutarConsultaArcgis(url: string, where: string, parametros: ParametrosConsulta, outSpatialReference?: SpatialReference, token?: string): Promise<ResultadoConsultaArcgis>;

package/dist-lib/tipos/features/maps/services/layers/consulta-capa-activa.d.ts

@@ -0,0 +1,56 @@
+import Extent from "@arcgis/core/geometry/Extent";
+import type SpatialReference from "@arcgis/core/geometry/SpatialReference";
+import type { CampoConsulta, FiltroConsulta, ItemLeyenda, ParametrosConsulta, ParametrosDescarga, ResultadoConsultaCapa, ServicioGis, ValoresDistintosCampo } from "../../types";
+import { type ResultadoDescargaCapa } from "./descarga-capa";
+import type { CapasServicioConstruidas } from "./types";
+/**
+ * Operaciones sobre una capa activa ya construida (extent, descarga, leyenda,
+ * campos, valores y consulta). Separada de `GestorCapasMapa`, que maneja el ciclo
+ * de vida de las capas; mantiene sus propias cachés de solo lectura.
+ */
+export declare class ConsultaCapaActiva {
+    private readonly capabilitiesWms;
+    private readonly legendCacheArcgis;
+    /**
+     * Extensión para "zoom a la capa", según el servicio:
+     * - FeatureServer: extensión real de las entidades.
+     * - Servicio de mapa ArcGIS: extensión real de la subcapa por su URL REST.
+     * - WMS: bbox de la capa en el GetCapabilities.
+     * Si nada aplica, usa la extensión del servicio; `null` si no hay ninguna.
+     */
+    extentDeCapa(servicio: ServicioGis, construidas: CapasServicioConstruidas, identificador: string, outSpatialReference?: SpatialReference): Promise<Extent | null>;
+    /**
+     * Descarga en GeoJSON los elementos de una subcapa dentro de `extent`: por
+     * `query` REST en ArcGIS o por WFS en GeoServer (puede lanzar
+     * `DescargaNoSoportadaError`). `parametros` son los límites y tiempos de BD.
+     */
+    descargarCapa(servicio: ServicioGis, construidas: CapasServicioConstruidas, identificador: string, extent: Extent, parametros: ParametrosDescarga, 
+    /** Solo WFS: pregunta si continuar cuando el conteo previo indica una zona densa. */
+    onDescargaGrande?: (cantidad: number) => Promise<boolean>): Promise<ResultadoDescargaCapa>;
+    /**
+     * Leyenda de una capa activa (`/legend` REST, `renderer` o `GetLegendGraphic`).
+     * `[]` si no hay mecanismo o falla. `etiquetaCapa` es el texto de respaldo.
+     * Con `identificador` vacío arma la leyenda del servicio completo.
+     */
+    leyendaDeCapa(servicio: ServicioGis, construidas: CapasServicioConstruidas, identificador: string, etiquetaCapa: string): Promise<ItemLeyenda[]>;
+    /**
+     * Campos consultables de una capa activa (`fields`, metadata REST o
+     * `DescribeFeatureType`). `[]` si no hay mecanismo o falla.
+     */
+    camposDeCapa(servicio: ServicioGis, construidas: CapasServicioConstruidas, identificador: string): Promise<CampoConsulta[]>;
+    /** Valores distintos de un campo de una capa activa, acotados a los topes de BD. */
+    valoresDistintosDeCampo(servicio: ServicioGis, construidas: CapasServicioConstruidas, identificador: string, campo: string, parametros: ParametrosConsulta): Promise<ValoresDistintosCampo>;
+    /**
+     * Ejecuta una consulta por atributos y devuelve entidades, extensión y si el
+     * servidor recortó el resultado. El filtro va como `where` o `CQL_FILTER` (WFS).
+     */
+    ejecutarConsulta(servicio: ServicioGis, construidas: CapasServicioConstruidas, identificador: string, filtro: FiltroConsulta, parametros: ParametrosConsulta, outSpatialReference?: SpatialReference): Promise<ResultadoConsultaCapa>;
+    /** GetCapabilities WMS parseado y cacheado por URL (también los fallos). `null` si falla. */
+    private capabilitiesWmsDe;
+    /** Resuelve cómo hablarle a una subcapa (ver `MecanismoCapa`). */
+    private mecanismoDe;
+    /** Purga las cachés del servicio al cambiar la credencial. */
+    invalidarCache(urlServicio: string): void;
+    /** Vacía ambas cachés (al retirar todas las capas administradas). */
+    limpiarCache(): void;
+}

package/dist-lib/tipos/features/maps/services/layers/consulta-wfs.d.ts

@@ -0,0 +1,20 @@
+import type { CampoConsulta, FiltroConsulta, ParametrosConsulta, ResultadoConsultaCapa, ServicioGis, ValoresDistintosCampo } from "../../types";
+/**
+ * Traduce el filtro a `CQL_FILTER`: `LIKE` usa `ILIKE` (sin distinguir mayúsculas);
+ * los demás comillan el valor si el campo no es numérico.
+ */
+export declare function armarCqlGeoserver(filtro: FiltroConsulta, campos: readonly CampoConsulta[]): string;
+/** Campos consultables de una capa WFS vía `DescribeFeatureType` (GeoServer WFS 2.0). */
+export declare function describeFeatureTypeWfs(servicio: ServicioGis, identificador: string): Promise<CampoConsulta[]>;
+/**
+ * Valores distintos de un campo vía `GetFeature` sin geometría, deduplicados en
+ * cliente (WFS no tiene `DISTINCT`); pueden quedar incompletos si se trunca.
+ * Se piden `topeCrudoValoresWfs` entidades y se muestran hasta `topeValoresConsulta`.
+ */
+export declare function valoresDistintosWfs(servicio: ServicioGis, identificador: string, campo: string, parametros: ParametrosConsulta): Promise<ValoresDistintosCampo>;
+/** Resultado crudo de una consulta WFS; `total` son las entidades devueltas. */
+export type ResultadoConsultaWfs = Omit<ResultadoConsultaCapa, "campos" | "filasDevueltas"> & {
+    total: number;
+};
+/** Consulta por atributos vía `GetFeature` con `CQL_FILTER`; la salida va en WGS84. */
+export declare function ejecutarConsultaWfs(servicio: ServicioGis, identificador: string, cqlFilter: string, parametros: ParametrosConsulta): Promise<ResultadoConsultaWfs>;

package/dist-lib/tipos/features/maps/services/layers/consulta.constantes.d.ts

@@ -0,0 +1,5 @@
+import type { CampoConsulta, FiltroConsulta } from "../../types";
+/** Traduce el filtro al lenguaje del backend; solo cambia el operador `LIKE`. */
+export declare function armarFiltro(filtro: FiltroConsulta, campos: readonly CampoConsulta[], 
+/** Expresión para el operador `LIKE`. */
+like: (campo: string, valor: string) => string): string;

package/dist-lib/tipos/features/maps/services/layers/descarga-capa.d.ts

@@ -0,0 +1,46 @@
+import type Extent from "@arcgis/core/geometry/Extent";
+import type { ParametrosDescarga, ServicioGis } from "../../types";
+/** Colección GeoJSON mínima que produce este módulo. */
+export interface ColeccionGeoJson {
+    readonly type: "FeatureCollection";
+    readonly features: readonly Record<string, unknown>[];
+    readonly [clave: string]: unknown;
+}
+/** Resultado de descargar una capa: el GeoJSON y si se recortó por el límite. */
+export interface ResultadoDescargaCapa {
+    readonly geojson: ColeccionGeoJson;
+    readonly incompleta: boolean;
+}
+/** El servicio no admite descargar sus datos (p. ej. WMS sin WFS habilitado). */
+export declare class DescargaNoSoportadaError extends Error {
+}
+/** La descarga WFS superó `tiempoEsperaDescargaWfsMs` y se canceló. */
+export declare class DescargaDemasiadoLentaError extends Error {
+    /** Tope de espera que se superó (ms), para informarlo al usuario. */
+    readonly tiempoMaximoMs: number;
+    constructor(mensaje: string, tiempoMaximoMs: number);
+}
+/** Falló la descarga WFS y el conteo supera el umbral: probablemente fue rechazada por pesada. */
+export declare class DescargaMuyPesadaError extends Error {
+}
+/** El usuario no confirmó tras el aviso de descarga grande y se abortó la descarga WFS. */
+export declare class DescargaCanceladaError extends Error {
+}
+/**
+ * Descarga por `query` REST (ArcGIS) los elementos dentro de `extent` en GeoJSON
+ * (WGS84). Sirve para `FeatureLayer` y subcapas de `MapImageLayer`. Pagina con
+ * `resultOffset` avanzando según lo recibido, no lo pedido, para no dejar huecos.
+ */
+export declare function descargarCapaArcgisRest(url: string, extent: Extent, parametros: ParametrosDescarga, token?: string): Promise<ResultadoDescargaCapa>;
+/**
+ * Descarga por WFS `GetFeature` (GeoServer) los elementos dentro de `extent`.
+ * En paralelo cuenta las entidades y, si superan `umbralAvisoDescargaWfs`,
+ * pregunta vía `onDescargaGrande` si continuar. Errores:
+ * - `DescargaCanceladaError`: el usuario no quiso continuar.
+ * - `DescargaDemasiadoLentaError`: se superó `tiempoEsperaDescargaWfsMs`.
+ * - `DescargaMuyPesadaError`: falló y el conteo supera el umbral.
+ * - `DescargaNoSoportadaError`: cualquier otra falla (p. ej. WMS sin WFS).
+ */
+export declare function descargarCapaWfs(servicio: ServicioGis, identificador: string, extent: Extent, parametros: ParametrosDescarga, 
+/** Se llama si el conteo supera el umbral; resuelve si continuar (sin manejador, sí). */
+onDescargaGrande?: (cantidad: number) => Promise<boolean>): Promise<ResultadoDescargaCapa>;

package/dist-lib/tipos/features/maps/services/layers/error-servicio.d.ts

@@ -0,0 +1,2 @@
+/** Convierte un fallo técnico de carga en el mensaje visible del servicio. */
+export declare function mensajeErrorServicio(fallo: unknown): string;

package/dist-lib/tipos/features/maps/services/layers/geoserver.d.ts

@@ -0,0 +1,5 @@
+/** Utilidades de GeoServer/WFS compartidas por la descarga y la consulta de capas. */
+/** Endpoint WFS de un servicio: `.../wms` pasa a `.../ows` (despachador genérico); lo demás no se toca. */
+export declare function endpointWfsDe(urlServicio: string): string;
+/** Parámetros comunes de una petición WFS (versión, protocolo y token) más su `complemento`. */
+export declare function parametrosWfs(complemento: Record<string, unknown>, token?: string): Record<string, unknown>;