@nomideusz/svelte-search 0.1.3 → 0.2.1

package/dist/core/engine.js

@@ -12,7 +12,7 @@
 // Dialect support:
 //   - 'sqlite' (default): FTS5 MATCH, custom trigram tables, rowid joins
 //   - 'postgres': tsvector/tsquery @@, pg_trgm similarity(), PK joins
-import { normalize, trigrams, trigramSimilarity, levenshteinSimilarity, hasGeoIntent, stripGeoIntent } from './normalize.js';
+import { normalize, trigrams, trigramSimilarity, levenshteinSimilarity, bestWordSimilarity, hasGeoIntent, stripGeoIntent } from './normalize.js';
 import { haversineKm, walkingMinutes, boundingBox } from './geo.js';
 // ── Query timeout helper ───────────────────────────────────
 function withTimeout(promise, ms, fallback) {
@@ -36,7 +36,7 @@ function ph(index, dialect) {
 }
 // ── Create search engine ───────────────────────────────────
 export function createSearchEngine(config) {
-    const { db, adapter, locale, dialect = 'sqlite', ftsTimeoutMs = 5000, fuzzyTimeoutMs = 3000, primaryRadiusKm = 15, nearbyRadiusKm = 30, maxNearby = 5, qualityThreshold = 0.75, maxFtsTerms = 6, } = config;
+    const { db, adapter, locale, dialect = 'sqlite', ftsTimeoutMs = 5000, fuzzyTimeoutMs = 3000, primaryRadiusKm = 15, nearbyRadiusKm = 30, maxNearby = 5, qualityThreshold = 0.75, maxFtsTerms = 6, ftsColumnWeights, } = config;
     const { tables, columns, trigramColumns } = adapter;
     // ── Main search ────────────────────────────────────────
     async function search(params) {
@@ -72,11 +72,13 @@ export function createSearchEngine(config) {
         // Merge, score, and rank
         const merged = deduplicateById([...ftsResults, ...fuzzyResults]);
         const scored = scoreResults(merged, normalized, lat, lng, geoIntent);
-        // Quality gate — fuzzy-only results need high Levenshtein similarity
+        // Quality gate — fuzzy-only results need high Levenshtein similarity.
+        // Per-word: a typo of one word in a multi-word name ("triranta" for
+        // "Triratna Warszawa ...") must qualify against the word, not the field.
         const qualified = scored.filter(r => {
             if (r._hasFts)
                 return true;
-            const best = Math.max(levenshteinSimilarity(normalized, r._nameN || '', locale), levenshteinSimilarity(normalized, r._locationN || '', locale), levenshteinSimilarity(normalized, r._categoriesN || '', locale));
+            const best = Math.max(bestWordSimilarity(normalized, r._nameN || '', locale), bestWordSimilarity(normalized, r._locationN || '', locale), bestWordSimilarity(normalized, r._categoriesN || '', locale));
             return best >= qualityThreshold;
         });
         qualified.sort((a, b) => b.score - a.score);
@@ -128,11 +130,15 @@ export function createSearchEngine(config) {
         return ftsSearchSqlite(ftsQuery, locationSlug, categorySlug, limit);
     }
     async function ftsSearchSqlite(ftsQuery, locationSlug, categorySlug, limit) {
-        let sql = `
-      SELECT s.*, fts.rank AS _ftsRank
-      FROM ${tables.fts} fts
-      JOIN ${tables.entities} s ON s.rowid = fts.rowid
-      WHERE ${tables.fts} MATCH ?
+        // Weighted bm25 when configured — same semantics as rank (lower = better)
+        const rankExpr = ftsColumnWeights?.length
+            ? `bm25(${tables.fts}, ${ftsColumnWeights.join(', ')})`
+            : 'fts.rank';
+        let sql = `
+      SELECT s.*, ${rankExpr} AS _ftsRank
+      FROM ${tables.fts} fts
+      JOIN ${tables.entities} s ON s.rowid = fts.rowid
+      WHERE ${tables.fts} MATCH ?
     `;
         const args = [ftsQuery];
         if (locationSlug && columns.locationSlug) {
@@ -144,7 +150,7 @@ export function createSearchEngine(config) {
             sql += ` AND s.${columns.categoriesNormalized} LIKE ?`;
             args.push(`%${catName}%`);
         }
-        sql += ' ORDER BY fts.rank LIMIT ?';
+        sql += ' ORDER BY _ftsRank LIMIT ?';
         args.push(limit);
         const result = await db.execute({ sql, args });
         return result.rows;
@@ -155,10 +161,10 @@ export function createSearchEngine(config) {
         const tsCol = tables.fts; // e.g. "search_vector"
         const args = [ftsQuery];
         let argIdx = 2;
-        let sql = `
-      SELECT s.*, ts_rank(s.${tsCol}, to_tsquery('simple', ${ph(1, dialect)})) AS "_ftsRank"
-      FROM ${tables.entities} s
-      WHERE s.${tsCol} @@ to_tsquery('simple', ${ph(1, dialect)})
+        let sql = `
+      SELECT s.*, ts_rank(s.${tsCol}, to_tsquery('simple', ${ph(1, dialect)})) AS "_ftsRank"
+      FROM ${tables.entities} s
+      WHERE s.${tsCol} @@ to_tsquery('simple', ${ph(1, dialect)})
     `;
         if (locationSlug && columns.locationSlug) {
             sql += ` AND s.${columns.locationSlug} = ${ph(argIdx, dialect)}`;
@@ -188,12 +194,12 @@ export function createSearchEngine(config) {
         if (queryTrigrams.length === 0)
             return [];
         const phs = queryTrigrams.map(() => '?').join(',');
-        let sql = `
-      SELECT s.*, NULL AS _ftsRank,
-             (COUNT(DISTINCT t.${trigramColumns.trigram}) * 1.0 / ?) AS _fuzzyScore
-      FROM ${tables.trigrams} t
-      JOIN ${tables.entities} s ON s.${columns.id} = t.${trigramColumns.entityId}
-      WHERE t.${trigramColumns.trigram} IN (${phs})
+        let sql = `
+      SELECT s.*, NULL AS _ftsRank,
+             (COUNT(DISTINCT t.${trigramColumns.trigram}) * 1.0 / ?) AS _fuzzyScore
+      FROM ${tables.trigrams} t
+      JOIN ${tables.entities} s ON s.${columns.id} = t.${trigramColumns.entityId}
+      WHERE t.${trigramColumns.trigram} IN (${phs})
     `;
         const args = [queryTrigrams.length, ...queryTrigrams];
         if (locationSlug && columns.locationSlug) {
@@ -222,10 +228,10 @@ export function createSearchEngine(config) {
         const simExpr = simCols.length === 1
             ? `similarity(${simCols[0]}, ${ph(1, dialect)})`
             : `GREATEST(${simCols.map(c => `similarity(COALESCE(${c}, ''), ${ph(1, dialect)})`).join(', ')})`;
-        let sql = `
-      SELECT s.*, NULL AS "_ftsRank", ${simExpr} AS "_fuzzyScore"
-      FROM ${tables.entities} s
-      WHERE ${simExpr} > 0.1
+        let sql = `
+      SELECT s.*, NULL AS "_ftsRank", ${simExpr} AS "_fuzzyScore"
+      FROM ${tables.entities} s
+      WHERE ${simExpr} > 0.1
     `;
         if (locationSlug && columns.locationSlug) {
             sql += ` AND s.${columns.locationSlug} = ${ph(argIdx, dialect)}`;

package/dist/core/indexer.js

@@ -141,15 +141,27 @@ export function createIndexer(config) {
      * Call after changing the normalize() function or locale.
      */
     async function renormalizeAll(updateRow) {
-        const result = await db.execute({ sql: `SELECT * FROM ${tables.entities}`, args: [] });
+        // Page the scan: a single SELECT * of the whole table can exceed the
+        // libsql/sqld HTTP response-size cap once the table grows past ~1.5k rows.
+        const PAGE = 500;
         let count = 0;
-        for (const row of result.rows) {
-            await updateRow(db, row);
-            if (dialect === 'sqlite') {
-                const id = row[columns.id];
-                await indexTrigrams(id, row);
+        for (let offset = 0;; offset += PAGE) {
+            const result = await db.execute({
+                sql: `SELECT * FROM ${tables.entities} ORDER BY ${columns.id} LIMIT ${PAGE} OFFSET ${offset}`,
+                args: [],
+            });
+            if (result.rows.length === 0)
+                break;
+            for (const row of result.rows) {
+                await updateRow(db, row);
+                if (dialect === 'sqlite') {
+                    const id = row[columns.id];
+                    await indexTrigrams(id, row);
+                }
+                count++;
             }
-            count++;
+            if (result.rows.length < PAGE)
+                break;
         }
         if (dialect === 'sqlite') {
             await rebuildFts();

package/dist/core/normalize.d.ts

@@ -11,6 +11,13 @@ export declare function trigramSimilarity(a: string, b: string, locale?: SearchL
 export declare function levenshtein(a: string, b: string): number;
 /** Normalized Levenshtein similarity. 0..1, higher = more similar. */
 export declare function levenshteinSimilarity(a: string, b: string, locale?: SearchLocale): number;
+/**
+ * Best Levenshtein similarity of `query` against a multi-word field: the max
+ * of whole-field similarity and per-word similarity. A typo of one word in a
+ * long field ("triranta" vs "triratna warszawa buddyzm...") scores near 0
+ * against the whole field but 0.75 against the word it matches.
+ */
+export declare function bestWordSimilarity(query: string, field: string, locale?: SearchLocale): number;
 /** Detect postcode format: XX-XXX or XXXXX (Polish default, override via locale). */
 export declare function isPostcode(text: string): boolean;
 /** Detect "near me" intent using locale geo patterns. */

package/dist/core/normalize.js

@@ -75,6 +75,22 @@ export function levenshteinSimilarity(a, b, locale) {
     const max = Math.max(na.length, nb.length);
     return max === 0 ? 1 : 1 - levenshtein(na, nb) / max;
 }
+/**
+ * Best Levenshtein similarity of `query` against a multi-word field: the max
+ * of whole-field similarity and per-word similarity. A typo of one word in a
+ * long field ("triranta" vs "triratna warszawa buddyzm...") scores near 0
+ * against the whole field but 0.75 against the word it matches.
+ */
+export function bestWordSimilarity(query, field, locale) {
+    if (!field)
+        return 0;
+    let best = levenshteinSimilarity(query, field, locale);
+    for (const w of normalize(field, locale).split(' ')) {
+        if (w)
+            best = Math.max(best, levenshteinSimilarity(query, w, locale));
+    }
+    return best;
+}
 /** Detect postcode format: XX-XXX or XXXXX (Polish default, override via locale). */
 export function isPostcode(text) {
     return /^\d{2}-?\d{3}$/.test(text.trim());

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export type { SqlDialect, DatabaseClient, SchemaAdapter, SearchParams, SearchResult, SearchResponse, AutocompleteResult, SearchLocale, ResolverContext, ResolverLookups, ResolverAction, TrackSearchEvent, } from './core/types.js';
 export { haversineKm, walkingMinutes, boundingBox, formatDistance, formatWalkingTime, walkingRoute, } from './core/geo.js';
-export { normalize, stripDiacriticsGeneric, trigrams, trigramSimilarity, levenshtein, levenshteinSimilarity, isPostcode, hasGeoIntent, stripGeoIntent, stripStopWords, MIN_SEARCH_TOKEN_LENGTH, } from './core/normalize.js';
+export { normalize, stripDiacriticsGeneric, trigrams, trigramSimilarity, levenshtein, levenshteinSimilarity, bestWordSimilarity, isPostcode, hasGeoIntent, stripGeoIntent, stripStopWords, MIN_SEARCH_TOKEN_LENGTH, } from './core/normalize.js';
 export { createSearchEngine, type SearchEngineConfig } from './core/engine.js';
 export { createIndexer, createLookupsLoader, type IndexerConfig, type LoadLookupsConfig } from './core/indexer.js';
 export { parseQuery, findMatchingArea, findNearestLocationWithEntities, type ParsedQuery } from './core/resolver.js';

package/dist/index.js

@@ -3,7 +3,7 @@
 // Geo utilities
 export { haversineKm, walkingMinutes, boundingBox, formatDistance, formatWalkingTime, walkingRoute, } from './core/geo.js';
 // Normalization & similarity
-export { normalize, stripDiacriticsGeneric, trigrams, trigramSimilarity, levenshtein, levenshteinSimilarity, isPostcode, hasGeoIntent, stripGeoIntent, stripStopWords, MIN_SEARCH_TOKEN_LENGTH, } from './core/normalize.js';
+export { normalize, stripDiacriticsGeneric, trigrams, trigramSimilarity, levenshtein, levenshteinSimilarity, bestWordSimilarity, isPostcode, hasGeoIntent, stripGeoIntent, stripStopWords, MIN_SEARCH_TOKEN_LENGTH, } from './core/normalize.js';
 // Search engine
 export { createSearchEngine } from './core/engine.js';
 // Indexer