// 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 }; }