feat(propuesta): pasarela paso a paso con autodetección de ubicación y FAB
- 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:
+4
-28
@@ -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
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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 || "",
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user