Files
localesp/src/utils/busqueda.js
T
edgar.friendly 232ef3fcda
deploy-branch / deploy (push) Successful in 2m59s
deploy-branch / teardown (push) Skipped
tests / Unitarias + componente + build (push) Successful in 3m25s
tests / Integración (Nominatim real, opt-in) (push) Skipped
tests / Unitarias + componente + build (pull_request) Successful in 3m14s
tests / Integración (Nominatim real, opt-in) (pull_request) Skipped
feat(busqueda): búsqueda fuzzy por erratas, sólo como rescate
El fuzzy entra únicamente cuando la búsqueda normal no devuelve NADA, para no
ensuciar los resultados con falsos positivos.

- src/utils/busqueda.js: buscarLocales() en dos etapas.
  1. Exacta (todas las palabras aparecen), con puntuación de relevancia:
     3 si empiezan palabra ("bar" en «Bar Torrijos»), 2 si van a mitad
     ("bar" en «Albardón»).
  2. Aproximada, sólo si la 1 no devolvió nada: cada palabra a distancia de
     edición corta de alguna palabra del índice (Levenshtein con corte
     temprano). Umbral: sin fuzzy por debajo de 4 letras, 1 edición hasta 6,
     2 a partir de 7. "peluquera" → Peluquería, "torrjos" → Torrijos.
- App: filtra por el mapa de puntuaciones y ordena por relevancia primero,
  dejando el orden elegido como desempate.
- BarraFiltros: cuando los resultados son aproximados lo dice
  («1 de 4 · búsqueda aproximada») en el mismo role=status anunciado.
- scripts/entornos.env: alta del entorno de la rama.

Tests: 195/195 (10 nuevos) — umbrales, distancia con corte, cascada,
relevancia y que el fuzzy no se activa si hay coincidencias exactas.
2026-11-01 14:01:52 +01:00

139 lines
5.4 KiB
JavaScript

// Búsqueda libre del directorio: tolerante a tildes, mayúsculas, palabras
// incompletas y erratas, en cascada y sin dependencias.
//
// 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 = [
"nombre",
"provincia",
"categoria",
"subcategoria",
"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.
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 };
}