feat(propuesta): pasarela paso a paso con autodetección de ubicación y FAB
deploy-branch / deploy (push) Failing after 6s
deploy-branch / teardown (push) Skipped

- Campo universal de ubicación (Google Maps/Waze/OSM/coordenadas/dirección)
  sobre proveedores extensibles (src/utils/ubicacion) con resolver e inferencia
  inversa Nominatim (nombre/provincia pre-rellenados, alias cooficiales)
- FAB flotante abajo a la derecha que abre la pasarela en un modal accesible
  (Escape, foco contenido, responsive); sin descripción ni puntuación;
  avisos de duplicado y filtro de palabras dentro del modal
- Aviso PWA reposicionado: tarjeta abajo a la izquierda en móvil,
  botón compacto arriba a la izquierda en PC (no tapa el FAB)
- Suite de pruebas: 88 unitarias/componente (vitest + RTL, offline) y
  10 de integración (supertest + SQLite :memory: y Nominatim real opt-in)
- CI: workflow de Gitea Actions con npm test + build en push/PR e
  integración manual
This commit is contained in:
2026-08-16 01:35:02 +02:00
parent d48b74cbd4
commit 003b1e209f
53 changed files with 4896 additions and 253 deletions
+4 -28
View File
@@ -1,21 +1,7 @@
// Utilidades de geolocalización: extraer coordenadas de un enlace de Google Maps
// o geocodificar una dirección de texto mediante Nominatim (OpenStreetMap).
export function parsearEnlaceGoogleMaps(url) {
try {
let coincidencia = url.match(/@(-?\d+\.\d+),(-?\d+\.\d+)/);
if (coincidencia) return { lat: parseFloat(coincidencia[1]), lng: parseFloat(coincidencia[2]) };
coincidencia = url.match(/!3d(-?\d+\.\d+)!4d(-?\d+\.\d+)/);
if (coincidencia) return { lat: parseFloat(coincidencia[1]), lng: parseFloat(coincidencia[2]) };
coincidencia = url.match(/[?&]q=(-?\d+\.\d+),(-?\d+\.\d+)/);
if (coincidencia) return { lat: parseFloat(coincidencia[1]), lng: parseFloat(coincidencia[2]) };
} catch {
// URL malformada: se ignora y se devuelve null más abajo
}
return null;
}
// Utilidades de geolocalización usadas por las tarjetas y el mapa: enlaces
// para abrir un local en Google Maps o Waze, distancias y búsqueda de lugares.
// La extracción de coordenadas de enlaces y la geocodificación por texto viven
// ahora en los proveedores de src/utils/ubicacion/.
// Enlaces para abrir la ubicación de un local directamente en Google Maps o Waze,
// usando las coordenadas si existen (más preciso) o si no, el texto de la dirección.
@@ -47,16 +33,6 @@ export function formatearDistancia(km) {
return km < 1 ? `${Math.round(km * 1000)} m` : `${km.toFixed(1)} km`;
}
export async function geocodificarDireccion(direccion) {
const query = encodeURIComponent(`${direccion}, España`);
const url = `https://nominatim.openstreetmap.org/search?q=${query}&format=json&limit=1&countrycodes=es`;
const respuesta = await fetch(url, { headers: { "Accept-Language": "es", "User-Agent": "LocalesEspanoles/1.0" } });
const datos = await respuesta.json();
if (datos?.length) {
return { lat: parseFloat(datos[0].lat), lng: parseFloat(datos[0].lon), displayName: datos[0].display_name };
}
return null;
}
// Busca lugares/negocios por nombre (autocompletar). Usa Nominatim (OpenStreetMap),
// que no requiere clave de API. Nota: no es el autocompletar "de Google" (eso exigiría
+103
View File
@@ -0,0 +1,103 @@
// Clase base de los proveedores de ubicación: define el contrato común que
// implementan todas las integraciones con backends de mapas (Google Maps,
// Waze, OpenStreetMap, coordenadas sueltas y Nominatim como fallback de
// texto). JS no tiene interfaces nativas, así que el contrato se documenta
// aquí y se comprueba al registrar cada instancia (ver index.js).
//
// Contrato de cada proveedor:
// - id: identificador estable del proveedor. Se copia al resultado para
// que la UI pueda etiquetar el origen de la ubicación.
// - detecta(entrada) → boolean: ¿esta entrada parece pertenecer a este
// proveedor? Debe ser barato y síncrono (normalmente un regex).
// - extrae(entrada) → Promise<Resultado|null>: extrae la información
// disponible y devuelve { proveedor, lat, lng, ...extras } o null
// si no se pudo extraer nada. Los errores de red se degradan a un
// fallo controlado (null), nunca se lanzan al consumidor.
//
// El resultado es deliberadamente extensible: los consumidores leen solo los
// campos que conocen (hoy lat/lng/nombre/provincia/direccion), de modo que
// añadir campos nuevos en el futuro (teléfono, horarios…) no rompe nada.
import { PROVINCIAS } from "../../constants/provincias.js";
export default class ProveedorUbicacion {
// Identificador del proveedor; cada subclase debe sobrescribirlo.
id = "proveedor";
// Nombres cooficiales (normalizados y sin artículo) → provincia canónica.
// Nominatim puede devolver "Bizkaia", "Girona" o "Ourense" según el idioma
// negociado; sin este mapa la provincia quedaría vacía innecesariamente.
static ALIAS_PROVINCIAS = {
bizkaia: "Vizcaya",
gipuzkoa: "Guipúzcoa",
araba: "Álava",
girona: "Gerona",
lleida: "Lérida",
ourense: "Orense",
coruna: "La Coruña",
"illes balears": "Islas Baleares",
asturies: "Asturias",
};
// ¿Reconoce esta entrada? La base no reconoce nada.
detecta(entrada) {
return false;
}
// Extrae la ubicación de la entrada. Método "abstracto": la base lanza para
// que una subclase registrada sin implementarlo falle rápido.
async extrae(entrada) {
throw new Error("sin implementar");
}
// ── Helpers compartidos por todos los proveedores ────────────────────────
// Normaliza un texto: minúsculas, sin tildes y sin espacios extremos. Se usa
// para comparar provincias y etiquetas sin depender de acentos.
static normalizar(texto) {
return (texto || "")
.toLowerCase()
.normalize("NFD")
.replace(/[\u0300-\u036f]/g, "")
.trim();
}
normalizar(texto) {
return ProveedorUbicacion.normalizar(texto);
}
// Empareja un texto libre contra el listado canónico de PROVINCIAS,
// insensible a acentos y mayúsculas y tolerante con artículos ("Comunidad
// de Madrid" → "Madrid", "A Coruña" → "La Coruña"). Devuelve "" si no casa
// con ninguna, para que la UI fuerce la selección manual (mismo
// comportamiento que tenía AutocompletarLocal).
emparejarProvincia(texto) {
const t = this.normalizar(texto);
if (!t) return "";
const sinArticulo = (s) => s.replace(/^(el|la|los|las|a|o)\s+/, "");
const tSin = sinArticulo(t);
const directa = PROVINCIAS.find((p) => {
const np = ProveedorUbicacion.normalizar(p);
const npSin = sinArticulo(np);
return t === np || t.includes(np) || tSin === npSin || tSin.includes(npSin);
});
if (directa) return directa;
// Alias de nombres cooficiales: Nominatim puede responder en euskera,
// catalán o gallego según el idioma negociado (D12 del diseño).
return ProveedorUbicacion.ALIAS_PROVINCIAS[tSin] || "";
}
// fetch a Nominatim con las cabeceras adecuadas y manejo de errores: si la
// red o el servicio fallan devuelve null (fallo controlado) en vez de
// lanzar, para que la pasarela nunca se rompa por un error de proveedor.
async fetchNominatim(url) {
try {
const respuesta = await fetch(url, {
headers: { "Accept-Language": "es", "User-Agent": "LocalesEspanoles/1.0" },
});
if (!respuesta.ok) return null;
return await respuesta.json();
} catch {
return null;
}
}
}
+75
View File
@@ -0,0 +1,75 @@
// Punto de entrada del sistema de proveedores de ubicación.
//
// Registro abierto/cerrado: añadir un backend nuevo consiste en crear una
// clase que implemente el contrato de ProveedorUbicacion (id/detecta/extrae)
// y sumar una instancia a PROVEEDORES. Ni resolverUbicacion, ni los demás
// proveedores, ni la pasarela necesitan cambiar.
import ProveedorCoordenadas from "./proveedorCoordenadas.js";
import ProveedorGoogleMaps from "./proveedorGoogleMaps.js";
import ProveedorWaze from "./proveedorWaze.js";
import ProveedorOSM from "./proveedorOSM.js";
import ProveedorNominatim from "./proveedorNominatim.js";
// Comprueba que una instancia cumple el contrato antes de registrarla:
// fallo rápido si un proveedor nuevo olvida implementar la interfaz.
function registrar(proveedor) {
if (!proveedor?.id || typeof proveedor.detecta !== "function" || typeof proveedor.extrae !== "function") {
throw new Error(`Proveedor inválido: falta id, detecta() o extrae() en ${proveedor?.constructor?.name || "proveedor"}`);
}
return proveedor;
}
// Proveedores ordenados por prioridad: lo más específico primero y el texto
// de dirección (Nominatim) siempre al final como fallback.
export const PROVEEDORES = [
registrar(new ProveedorCoordenadas()),
registrar(new ProveedorGoogleMaps()),
registrar(new ProveedorWaze()),
registrar(new ProveedorOSM()),
registrar(new ProveedorNominatim()),
];
// Etiquetas legibles por id de proveedor, para los chips de la UI.
export const ETIQUETAS_PROVEEDOR = {
coordenadas: "Coordenadas",
"google-maps": "Google Maps",
waze: "Waze",
osm: "OpenStreetMap",
nominatim: "Dirección (OpenStreetMap)",
};
// Resuelve una entrada libre usando el primer proveedor que la reconozca y
// logre extraer datos. Devuelve { proveedor, lat, lng, ...extras } o null si
// ningún proveedor la entiende. Los errores de cada proveedor se degradan
// (se registran en consola y se continúa con el siguiente), nunca se lanzan
// al consumidor.
export async function resolverUbicacion(entrada) {
const texto = (entrada || "").trim();
if (!texto) return null;
for (const proveedor of PROVEEDORES) {
try {
if (!proveedor.detecta(texto)) continue;
const resultado = await proveedor.extrae(texto);
if (resultado && Number.isFinite(resultado.lat) && Number.isFinite(resultado.lng)) {
return resultado;
}
} catch (e) {
console.error(`[ubicacion] el proveedor ${proveedor.id} falló:`, e);
}
}
return null;
}
// Geocodificación inversa: de coordenadas a { nombre, provincia, direccion }
// con la provincia normalizada al listado canónico. Devuelve null si falla;
// la UI avisa y permite continuar sin inferencia.
export async function inferirDesdeCoords(lat, lng) {
const nominatim = PROVEEDORES.find((p) => p.id === "nominatim");
if (!nominatim) return null;
try {
return await nominatim.reverse(lat, lng);
} catch (e) {
console.error("[ubicacion] la inferencia falló:", e);
return null;
}
}
@@ -0,0 +1,32 @@
// Proveedor de coordenadas geográficas sueltas: "41.3851, 2.1734".
// Acepta signo, espacios alrededor del separador y coma o punto como
// separador decimal (incluido el par con decimales españoles "41,38, 2,17").
import ProveedorUbicacion from "./ProveedorUbicacion.js";
// Par separado por coma o punto y coma: "41.3851, 2.1734", "-3,70;40,41"
const PATRON_PAR_COMA = /^\s*(-?\d{1,3}(?:[.,]\d+))\s*[,;]\s*(-?\d{1,3}(?:[.,]\d+))\s*$/;
// Par separado por espacio con decimales obligatorios (evita falsos
// positivos con texto): "41,3851 2,1734"
const PATRON_PAR_ESPACIO = /^\s*(-?\d{1,3}[.,]\d{3,})\s+(-?\d{1,3}[.,]\d{3,})\s*$/;
const aNumero = (s) => parseFloat(String(s).replace(",", "."));
export default class ProveedorCoordenadas extends ProveedorUbicacion {
id = "coordenadas";
detecta(entrada) {
const t = entrada || "";
return PATRON_PAR_COMA.test(t) || PATRON_PAR_ESPACIO.test(t);
}
async extrae(entrada) {
const texto = (entrada || "").trim();
const par = texto.match(PATRON_PAR_COMA) || texto.match(PATRON_PAR_ESPACIO);
if (!par) return null;
const lat = aNumero(par[1]);
const lng = aNumero(par[2]);
// Sanidad: rangos válidos de coordenadas terrestres
if (Math.abs(lat) > 90 || Math.abs(lng) > 180) return null;
return { proveedor: this.id, lat, lng };
}
}
@@ -0,0 +1,38 @@
// Proveedor de enlaces de Google Maps. Migra la lógica de
// parsearEnlaceGoogleMaps (src/utils/geo.js) y reconoce los tres formatos con
// coordenadas en la URL:
// - @lat,lng → https://maps.google.com/@41.38,-2.17,15z
// - !3d…!4d… → https://google.com/maps/place/…/!3d41.38!4d-2.17
// - ?q=lat,lng → https://google.com/maps?q=41.38,-2.17
// Los enlaces acortados (maps.app.goo.gl) se detectan pero sin coordenadas en
// la URL devuelven null: la UI pide el enlace completo (unshorten pendiente).
import ProveedorUbicacion from "./ProveedorUbicacion.js";
const PATRONES_COORDS = [
/@(-?\d+\.\d+),(-?\d+\.\d+)/,
/!3d(-?\d+\.\d+)!4d(-?\d+\.\d+)/,
/[?&]q=(-?\d+\.\d+),(-?\d+\.\d+)/,
];
export default class ProveedorGoogleMaps extends ProveedorUbicacion {
id = "google-maps";
detecta(entrada) {
return /maps\.google\.|google\.[a-z.]+\/maps|maps\.app\.goo\.gl|goo\.gl\/maps/i.test(entrada || "");
}
async extrae(entrada) {
const texto = entrada || "";
for (const patron of PATRONES_COORDS) {
const m = texto.match(patron);
if (m) {
const lat = parseFloat(m[1]);
const lng = parseFloat(m[2]);
if (Math.abs(lat) <= 90 && Math.abs(lng) <= 180) {
return { proveedor: this.id, lat, lng };
}
}
}
return null;
}
}
+81
View File
@@ -0,0 +1,81 @@
// Proveedor de geocodificación por texto (Nominatim / OpenStreetMap). Actúa
// como fallback de último recurso: cuando la entrada no es un enlace
// reconocible ni un par de coordenadas, se trata como dirección y se busca
// su ubicación (/search, migra geocodificarDireccion de src/utils/geo.js).
// Además expone reverse(lat, lng) (/reverse) para la geocodificación
// inversa con la que la pasarela infiere nombre, provincia y dirección.
import ProveedorUbicacion from "./ProveedorUbicacion.js";
const BASE = "https://nominatim.openstreetmap.org";
export default class ProveedorNominatim extends ProveedorUbicacion {
id = "nominatim";
// Fallback de texto: acepta cualquier entrada con letras que no parezca una
// URL (un enlace que ningún proveedor supo extraer no debe buscarse como
// si fuera una dirección).
detecta(entrada) {
const t = (entrada || "").trim();
if (t.length < 3) return false;
if (/https?:\/\/|\bwww\.|\b[a-z0-9-]+\.(com|es|org|net|gl|io|app|edu|gob)\b/i.test(t)) return false;
return /[a-záéíóúüñ]/i.test(t);
}
// Búsqueda por texto (dirección o nombre de lugar). Devuelve el resultado
// con coordenadas y, si Nominatim las facilita, nombre/provincia/dirección.
async extrae(entrada) {
const q = (entrada || "").trim();
if (!q) return null;
const params = new URLSearchParams({
q: `${q}, España`,
format: "json",
addressdetails: "1",
namedetails: "1",
limit: "1",
countrycodes: "es",
});
const datos = await this.fetchNominatim(`${BASE}/search?${params}`);
if (!datos?.length) return null;
return this.desdeResultado(datos[0]);
}
// Geocodificación inversa: de coordenadas a { nombre, provincia, direccion }.
// Devuelve null si el servicio no responde (la UI avisa y sigue sin
// inferencia, sin bloquear la pasarela).
async reverse(lat, lng) {
const params = new URLSearchParams({
lat: String(lat),
lon: String(lng),
format: "jsonv2",
addressdetails: "1",
namedetails: "1",
"accept-language": "es",
});
const dato = await this.fetchNominatim(`${BASE}/reverse?${params}`);
if (!dato || dato.error) return null;
const r = this.desdeResultado(dato);
return { nombre: r.nombre, provincia: r.provincia, direccion: r.direccion };
}
// Convierte una respuesta de Nominatim (search o reverse) en el resultado
// extensible del proveedor. La provincia se normaliza al listado canónico
// de PROVINCIAS: si no casa con ninguna, queda vacía para que el usuario la
// seleccione manualmente.
desdeResultado(d) {
const addr = d.address || {};
const candidatos = [addr.county, addr.province, addr.state_district, addr.state, addr.city, addr.municipality, addr.city_district].filter(Boolean);
let provincia = "";
for (const candidato of candidatos) {
provincia = this.emparejarProvincia(candidato);
if (provincia) break;
}
return {
proveedor: this.id,
lat: parseFloat(d.lat),
lng: parseFloat(d.lon),
nombre: d.namedetails?.name || "",
provincia,
direccion: d.display_name || "",
};
}
}
+42
View File
@@ -0,0 +1,42 @@
// Proveedor de enlaces de openstreetmap.org. Extrae las coordenadas de los
// parámetros mlat/mlon (enlace de marcador) o del fragmento
// #map=zoom/lat/lng (posición actual del visor), p. ej.:
// https://www.openstreetmap.org/?mlat=41.38&mlon=2.17#map=15/41.38/2.17
import ProveedorUbicacion from "./ProveedorUbicacion.js";
const PATRON_MAPA = /#map=\d+(?:\.\d+)?\/(-?\d{1,3}\.\d+)\/(-?\d{1,3}\.\d+)/;
function comoUrl(entrada) {
const texto = (entrada || "").trim();
if (!texto) return null;
try {
return new URL(/:\/\//i.test(texto) ? texto : `https://${texto}`);
} catch {
return null;
}
}
export default class ProveedorOSM extends ProveedorUbicacion {
id = "osm";
detecta(entrada) {
return /openstreetmap\.org/i.test(entrada || "");
}
async extrae(entrada) {
const url = comoUrl(entrada);
if (!url) return null;
const mlat = parseFloat(url.searchParams.get("mlat"));
const mlon = parseFloat(url.searchParams.get("mlon"));
if (Number.isFinite(mlat) && Number.isFinite(mlon)) {
return { proveedor: this.id, lat: mlat, lng: mlon };
}
const mapa = (url.hash || "").match(PATRON_MAPA);
if (mapa) {
return { proveedor: this.id, lat: parseFloat(mapa[1]), lng: parseFloat(mapa[2]) };
}
return null;
}
}
+56
View File
@@ -0,0 +1,56 @@
// Proveedor de enlaces de Waze. Extrae las coordenadas del parámetro ll=
// (https://waze.com/ul?ll=41.38,2.17&navigate=yes). Si el enlace solo trae
// una búsqueda de texto (q=...), delega la resolución en la búsqueda por
// texto de Nominatim marcando el resultado como proveedor "waze".
import ProveedorUbicacion from "./ProveedorUbicacion.js";
import ProveedorNominatim from "./proveedorNominatim.js";
const PATRON_LL = /^(-?\d{1,3}(?:\.\d+)?),\s*(-?\d{1,3}(?:\.\d+)?)$/;
function comoUrl(entrada) {
const texto = (entrada || "").trim();
if (!texto) return null;
try {
return new URL(/:\/\//i.test(texto) ? texto : `https://${texto}`);
} catch {
return null;
}
}
export default class ProveedorWaze extends ProveedorUbicacion {
id = "waze";
// Instancia propia del resolvedor de texto (Waze no lo referencia desde el
// registro para evitar acoplamientos con index.js).
#nominatim = new ProveedorNominatim();
detecta(entrada) {
return /waze\.(com|to)/i.test(entrada || "");
}
async extrae(entrada) {
const url = comoUrl(entrada);
if (!url) return null;
const ll = url.searchParams.get("ll");
if (ll) {
const m = ll.match(PATRON_LL);
if (m) {
const lat = parseFloat(m[1]);
const lng = parseFloat(m[2]);
if (Math.abs(lat) <= 90 && Math.abs(lng) <= 180) {
return { proveedor: this.id, lat, lng };
}
}
return null; // ll= presente pero malformado
}
// Solo búsqueda de texto: delegar en Nominatim manteniendo el proveedor
const q = url.searchParams.get("q");
if (q) {
const resultado = await this.#nominatim.extrae(q);
if (resultado) return { ...resultado, proveedor: this.id };
}
return null;
}
}