diff --git a/scripts/entornos.env b/scripts/entornos.env index 181f51f..fc56986 100644 --- a/scripts/entornos.env +++ b/scripts/entornos.env @@ -9,4 +9,5 @@ prototipo-yb01=/administrador master=/administrador feat-busqueda-tolerante=/administrador +feat-busqueda-fuzzy=/administrador # prototipo-yb01-ef=/administrador diff --git a/src/App.jsx b/src/App.jsx index c359bc3..06a4e78 100644 --- a/src/App.jsx +++ b/src/App.jsx @@ -12,7 +12,7 @@ import BotonProponerArriba from "./components/BotonProponerArriba.jsx"; import ModalPasarela from "./components/ModalPasarela.jsx"; import BarraFiltros from "./components/BarraFiltros.jsx"; import EstadoVacioLista from "./components/EstadoVacioLista.jsx"; -import { coincideBusqueda } from "./utils/busqueda.js"; +import { coincideBusqueda, buscarLocales } from "./utils/busqueda.js"; import useFavoritos from "./hooks/useFavoritos.js"; import useUbicacion from "./hooks/useUbicacion.js"; @@ -188,13 +188,23 @@ export default function App() { guardarPropuesta(posibleDuplicado.lat, posibleDuplicado.lng); }; + // Búsqueda en cascada (exacta -> prefijo -> aproximada). Las puntuaciones + // se usan para (a) filtrar y (b) ordenar por relevancia; `aproximada` + // avisa en la barra de que los resultados vienen de la etapa fuzzy. + const { puntuaciones: puntuacionesBusqueda, aproximada } = buscarLocales(locales, busqueda); + const localesFiltrados = locales - .filter((l) => coincideBusqueda(l, busqueda) + .filter((l) => puntuacionesBusqueda.has(l.id) && (!filtroCategoria || l.categoria === filtroCategoria) && (!filtroSubcat || l.subcategoria === filtroSubcat) && (!filtroProvincia || l.provincia === filtroProvincia) && (!soloFavoritos || esFavorito(l.id))) .sort((a, b) => { + // Con consulta, primero lo más relevante (exacto > prefijo > aproximado) + // y el orden elegido como desempate. + const porRelevancia = (puntuacionesBusqueda.get(b.id) || 0) - (puntuacionesBusqueda.get(a.id) || 0); + if (porRelevancia !== 0) return porRelevancia; + if (orden === "distancia" && ubicacion) { const da = a.lat && a.lng ? calcularDistanciaKm(ubicacion.lat, ubicacion.lng, a.lat, a.lng) : Infinity; const db = b.lat && b.lng ? calcularDistanciaKm(ubicacion.lat, ubicacion.lng, b.lat, b.lng) : Infinity; @@ -317,6 +327,7 @@ export default function App() { ubicacion={ubicacion} buscandoUbicacion={buscandoUbicacion} errorUbicacion={errorUbicacion} pedirUbicacion={pedirUbicacion} limpiarUbicacion={limpiarUbicacion} totalResultados={localesFiltrados.length} totalLocales={locales.length} + aproximada={Boolean(busqueda) && aproximada} onLimpiar={limpiarFiltros} /> diff --git a/src/components/BarraFiltros.jsx b/src/components/BarraFiltros.jsx index c95454c..95fe267 100644 --- a/src/components/BarraFiltros.jsx +++ b/src/components/BarraFiltros.jsx @@ -38,7 +38,7 @@ export default function BarraFiltros({ orden, setOrden, soloFavoritos, setSoloFavoritos, ubicacion, buscandoUbicacion, errorUbicacion, pedirUbicacion, limpiarUbicacion, - totalResultados, totalLocales, onLimpiar, + totalResultados, totalLocales, onLimpiar, aproximada = false, }) { const conteosCat = NOMBRES_CATEGORIAS.reduce((acc, c) => { acc[c] = locales.filter((l) => l.categoria === c).length; return acc; }, {}); const opcionesOrden = ubicacion ? [...OPCIONES_ORDEN, OPCION_ORDEN_DISTANCIA] : OPCIONES_ORDEN; @@ -47,9 +47,11 @@ export default function BarraFiltros({ // Feedback de la búsqueda: sin esto el usuario no sabe si la consulta se // aplicó o si simplemente no hay nada. Solo cuenta como "N de M" cuando hay - // un filtro activo que pueda reducir el listado (ordenar no reduce). + // un filtro activo que pueda reducir el listado (ordenar no reduce). Si los + // resultados vienen de la etapa fuzzy, se dice explícitamente. const textoConteo = () => { if (totalLocales === 0) return "Todavía no hay locales publicados"; + if (aproximada) return `${totalResultados} de ${totalLocales} · búsqueda aproximada`; if (filtrando && totalResultados !== totalLocales) return `${totalResultados} de ${totalLocales} locales`; return `${totalLocales} ${totalLocales === 1 ? "local" : "locales"}`; }; @@ -121,7 +123,12 @@ export default function BarraFiltros({

{textoConteo()}

diff --git a/src/utils/busqueda.js b/src/utils/busqueda.js index 5932785..e7295af 100644 --- a/src/utils/busqueda.js +++ b/src/utils/busqueda.js @@ -1,12 +1,19 @@ -// Búsqueda libre del directorio, tolerante a tildes, mayúsculas y espacios. +// Búsqueda libre del directorio: tolerante a tildes, mayúsculas, palabras +// incompletas y erratas, en cascada y sin dependencias. // -// Reglas (deliberadamente simples y sin dependencias): -// - Se compara por palabras: TODAS las palabras de la consulta deben -// aparecer en algún campo del local ("bar toledo" no casa con un local de -// Toledo que no sea un bar). -// - Los campos participantes son los que anuncia la barra de filtros: -// nombre, provincia, categoría, subcategoría y dirección. -// - Consulta vacía -> todo casa (así el filtro no altera el listado). +// Dos etapas: +// 1. EXACTA — todas las palabras de la consulta aparecen en el índice del +// local. Dentro de esta etapa se ordena por relevancia: 3 si además cada +// palabra empieza una palabra del índice ("bar" en «Bar Torrijos»), 2 si +// sólo aparece a mitad de palabra ("bar" en «Albardón»). +// 2. APROXIMADA (fuzzy) — sólo si la etapa 1 no devolvió NADA: cada palabra +// está a distancia de edición corta de alguna palabra del índice +// ("peluquera" → Peluquería). Así el fuzzy nunca ensucia los resultados +// normales, y la UI puede avisar de que son aproximados. +// +// Nota: no hace falta una etapa de "prefijo" separada — un prefijo de una +// palabra ya es una subcadena del índice, así que la etapa 1 lo cubre y sólo +// se usa para puntuar mejor los aciertos desde el principio de palabra. import { normalizar, palabras } from "./texto.js"; export const CAMPOS_BUSQUEDA = [ @@ -17,6 +24,10 @@ export const CAMPOS_BUSQUEDA = [ "direccion", ]; +export const PUNTUACION_PRINCIPIO_PALABRA = 3; +export const PUNTUACION_A_MITAD_PALABRA = 2; +export const PUNTUACION_APROXIMADA = 1; + // Texto normalizado de un local con todos sus campos buscables juntos. Se // calcula por consulta: el directorio es pequeño y así no hay caché que // invalidar cuando el admin edita un local. @@ -24,11 +35,104 @@ export function indiceBusqueda(local) { return normalizar(CAMPOS_BUSQUEDA.map((campo) => local?.[campo] || "").join(" ")); } +// Palabras del índice, para comprobar si un término empieza palabra. +function palabrasIndice(indice) { + return indice ? indice.split(" ") : []; +} + // ¿Casa el local con la consulta? "malaga" encuentra "Málaga", "peluqueria" // encuentra "Peluquería" y "la escalera" encuentra "Bar la escalera". +// Sólo etapa exacta: la cascada completa vive en buscarLocales(). export function coincideBusqueda(local, consulta) { const terminos = palabras(consulta); if (terminos.length === 0) return true; const indice = indiceBusqueda(local); return terminos.every((termino) => indice.includes(termino)); } + +// Distancia de edición máxima tolerada para un término. Los términos cortos +// (< 4 letras) no admiten erratas: "bar" no debería parecerse a "bur". +export function distanciaMaxima(termino) { + if (termino.length >= 7) return 2; + if (termino.length >= 4) return 1; + return 0; +} + +// Levenshtein con corte temprano: si la distancia supera `max`, devuelve +// max + 1 sin terminar de calcular (suficiente para descartar). +export function distanciaEdicion(a, b, max = Infinity) { + if (a === b) return 0; + if (Math.abs(a.length - b.length) > max) return max + 1; + + let previa = []; + for (let j = 0; j <= b.length; j += 1) previa[j] = j; + + for (let i = 1; i <= a.length; i += 1) { + const actual = [i]; + let minimoFila = i; + for (let j = 1; j <= b.length; j += 1) { + const coste = a[i - 1] === b[j - 1] ? 0 : 1; + actual[j] = Math.min(previa[j] + 1, actual[j - 1] + 1, previa[j - 1] + coste); + if (actual[j] < minimoFila) minimoFila = actual[j]; + } + if (minimoFila > max) return max + 1; + previa = actual; + } + + return previa[b.length]; +} + +// Puntuación de la etapa exacta: null si alguna palabra no aparece. +function puntuarExacta({ indice, palabrasDelIndice }, terminos) { + if (!terminos.every((termino) => indice.includes(termino))) return null; + const todasAlPrincipio = terminos.every((termino) => + palabrasDelIndice.some((palabra) => palabra.startsWith(termino)), + ); + return todasAlPrincipio ? PUNTUACION_PRINCIPIO_PALABRA : PUNTUACION_A_MITAD_PALABRA; +} + +// Puntuación de la etapa aproximada: null si alguna palabra está demasiado +// lejos de todas las del índice. +function puntuarAproximada({ indice, palabrasDelIndice }, terminos) { + const casa = terminos.every((termino) => { + const max = distanciaMaxima(termino); + if (max === 0) return indice.includes(termino); + return palabrasDelIndice.some((palabra) => distanciaEdicion(termino, palabra, max) <= max); + }); + return casa ? PUNTUACION_APROXIMADA : null; +} + +// Busca en el directorio y devuelve, para cada local que casa, su puntuación +// de relevancia (3 empieza palabra, 2 a mitad de palabra, 1 aproximada). +// `aproximada` indica que los resultados salen de la etapa fuzzy y la UI debe +// avisarlo. +export function buscarLocales(locales, consulta) { + const terminos = palabras(consulta); + const puntuaciones = new Map(); + + if (terminos.length === 0) { + locales.forEach((local) => puntuaciones.set(local.id, PUNTUACION_PRINCIPIO_PALABRA)); + return { puntuaciones, aproximada: false }; + } + + const indices = locales.map((local) => { + const indice = indiceBusqueda(local); + return { local, indice, palabrasDelIndice: palabrasIndice(indice) }; + }); + + for (const { local, ...resto } of indices) { + const puntuacion = puntuarExacta(resto, terminos); + if (puntuacion !== null) puntuaciones.set(local.id, puntuacion); + } + + // El fuzzy sólo entra si la búsqueda normal no devolvió absolutamente nada. + if (puntuaciones.size === 0) { + for (const { local, ...resto } of indices) { + const puntuacion = puntuarAproximada(resto, terminos); + if (puntuacion !== null) puntuaciones.set(local.id, puntuacion); + } + return { puntuaciones, aproximada: puntuaciones.size > 0 }; + } + + return { puntuaciones, aproximada: false }; +} diff --git a/tests/component/BarraFiltros.spec.jsx b/tests/component/BarraFiltros.spec.jsx index 2373fdb..2c9bb3b 100644 --- a/tests/component/BarraFiltros.spec.jsx +++ b/tests/component/BarraFiltros.spec.jsx @@ -150,6 +150,11 @@ describe("BarraFiltros", () => { renderBarra({ totalResultados: 0, totalLocales: 0 }); expect(screen.getByRole("status").textContent).toMatch(/todavía no hay locales publicados/i); + cleanup(); + + // Resultados de la etapa fuzzy: se avisa explícitamente + renderBarra({ busqueda: "peluquera", totalResultados: 1, aproximada: true }); + expect(screen.getByRole("status").textContent).toBe("1 de 4 · búsqueda aproximada"); }); it("El ✕ del buscador aparece solo con texto y borra únicamente la consulta", () => { diff --git a/tests/unit/busqueda.spec.js b/tests/unit/busqueda.spec.js index bf41659..1cc314b 100644 --- a/tests/unit/busqueda.spec.js +++ b/tests/unit/busqueda.spec.js @@ -1,7 +1,17 @@ // Búsqueda tolerante: tildes, mayúsculas, palabras múltiples y campos. import { describe, expect, it } from "vitest"; -import { coincideBusqueda, indiceBusqueda, CAMPOS_BUSQUEDA } from "../../src/utils/busqueda.js"; +import { + buscarLocales, + coincideBusqueda, + distanciaEdicion, + distanciaMaxima, + indiceBusqueda, + CAMPOS_BUSQUEDA, + PUNTUACION_APROXIMADA, + PUNTUACION_A_MITAD_PALABRA, + PUNTUACION_PRINCIPIO_PALABRA, +} from "../../src/utils/busqueda.js"; import { normalizar, palabras } from "../../src/utils/texto.js"; const BAR = { @@ -101,3 +111,91 @@ describe("indiceBusqueda", () => { expect(CAMPOS_BUSQUEDA).toHaveLength(5); }); }); + +describe("distanciaMaxima", () => { + it("no tolera erratas en términos cortos y sí en los largos", () => { + expect(distanciaMaxima("bar")).toBe(0); + expect(distanciaMaxima("bars")).toBe(1); + expect(distanciaMaxima("torrijos")).toBe(2); + }); +}); + +describe("distanciaEdicion", () => { + it("calcula la distancia mínima de edición", () => { + expect(distanciaEdicion("torrijos", "torrijos")).toBe(0); + expect(distanciaEdicion("torrjos", "torrijos")).toBe(1); + expect(distanciaEdicion("peluquera", "peluqueria")).toBe(1); + }); + + it("corta en cuanto supera el máximo pedido", () => { + expect(distanciaEdicion("abc", "xyz", 1)).toBe(2); // max + 1: descartado + }); +}); + +describe("buscarLocales — cascada exacta y aproximada", () => { + const ALBARDON = { + id: "3", + nombre: "El Albardón", + provincia: "Madrid", + categoria: "Restauración", + subcategoria: "", + direccion: "", + }; + const TORRIJOS = { + id: "4", + nombre: "Bar Torrijos", + provincia: "Guadalajara", + categoria: "Restauración", + subcategoria: "Tapas y raciones", + direccion: "", + }; + const TODOS = [BAR, PELUQUERIA, ALBARDON, TORRIJOS]; + + it("sin consulta devuelve todo con la puntuación máxima", () => { + const { puntuaciones, aproximada } = buscarLocales(TODOS, " "); + expect(puntuaciones.size).toBe(4); + expect([...puntuaciones.values()].every((p) => p === PUNTUACION_PRINCIPIO_PALABRA)).toBe(true); + expect(aproximada).toBe(false); + }); + + it("puntúa mejor cuando la palabra empieza palabra", () => { + const { puntuaciones, aproximada } = buscarLocales(TODOS, "bar"); + // "Bar la escalera" empieza por "bar"; "El Albardón" sólo lo contiene + expect(puntuaciones.get(BAR.id)).toBe(PUNTUACION_PRINCIPIO_PALABRA); + expect(puntuaciones.get(ALBARDON.id)).toBe(PUNTUACION_A_MITAD_PALABRA); + expect(puntuaciones.has(PELUQUERIA.id)).toBe(false); + expect(aproximada).toBe(false); + }); + + it("no activa el fuzzy si la búsqueda exacta encuentra algo", () => { + const { puntuaciones, aproximada } = buscarLocales(TODOS, "peluqueria"); + expect(puntuaciones.size).toBe(1); + expect(puntuaciones.get(PELUQUERIA.id)).toBe(PUNTUACION_PRINCIPIO_PALABRA); + expect(aproximada).toBe(false); + }); + + it("tolera erratas cuando no hay ninguna coincidencia exacta", () => { + const { puntuaciones, aproximada } = buscarLocales(TODOS, "peluquera"); + expect(puntuaciones.get(PELUQUERIA.id)).toBe(PUNTUACION_APROXIMADA); + expect(aproximada).toBe(true); + }); + + it("tolera erratas en una palabra de una consulta de varias", () => { + const { puntuaciones, aproximada } = buscarLocales(TODOS, "bar torrjos"); + expect(puntuaciones.get(TORRIJOS.id)).toBe(PUNTUACION_APROXIMADA); + expect(puntuaciones.has(BAR.id)).toBe(false); // "escalera" no está cerca de "torrjos" + expect(aproximada).toBe(true); + }); + + it("no hace fuzzy con términos cortos (evita falsos positivos)", () => { + const { puntuaciones, aproximada } = buscarLocales(TODOS, "br"); + expect(puntuaciones.size).toBe(0); + expect(aproximada).toBe(false); + }); + + it("sin coincidencias devuelve un mapa vacío y no marca aproximada", () => { + const { puntuaciones, aproximada } = buscarLocales(TODOS, "zapateria"); + expect(puntuaciones.size).toBe(0); + expect(aproximada).toBe(false); + }); +});