118 lines
2.8 KiB
TypeScript
118 lines
2.8 KiB
TypeScript
export type FuzzyMatch = {
|
|
score: number;
|
|
indices: number[];
|
|
};
|
|
|
|
/**
|
|
* Subsequence fuzzy match with fzf-style scoring.
|
|
* All query characters must appear in order; higher scores rank first.
|
|
*/
|
|
export function fuzzyMatch(query: string, text: string): FuzzyMatch | null {
|
|
const q = query.trim().toLowerCase();
|
|
if (!q) return { score: 0, indices: [] };
|
|
|
|
const t = text.toLowerCase();
|
|
if (!t) return null;
|
|
|
|
// Fast path: contiguous substring
|
|
const substringIndex = t.indexOf(q);
|
|
if (substringIndex !== -1) {
|
|
const indices = Array.from({ length: q.length }, (_, i) => substringIndex + i);
|
|
// Prefer earlier matches and shorter haystacks
|
|
const score = 10_000 - substringIndex * 10 - (t.length - q.length);
|
|
return { score, indices };
|
|
}
|
|
|
|
let ti = 0;
|
|
const indices: number[] = [];
|
|
let score = 0;
|
|
let prevIndex = -1;
|
|
let consecutive = 0;
|
|
|
|
for (let qi = 0; qi < q.length; qi += 1) {
|
|
const ch = q[qi];
|
|
let found = -1;
|
|
for (; ti < t.length; ti += 1) {
|
|
if (t[ti] === ch) {
|
|
found = ti;
|
|
ti += 1;
|
|
break;
|
|
}
|
|
}
|
|
if (found === -1) return null;
|
|
|
|
indices.push(found);
|
|
|
|
// Consecutive bonus
|
|
if (prevIndex === found - 1) {
|
|
consecutive += 1;
|
|
score += 15 + consecutive * 5;
|
|
} else {
|
|
consecutive = 0;
|
|
score += 1;
|
|
}
|
|
|
|
// Word-boundary / start bonus
|
|
if (
|
|
found === 0 ||
|
|
t[found - 1] === ' ' ||
|
|
t[found - 1] === '-' ||
|
|
t[found - 1] === '_' ||
|
|
t[found - 1] === '&' ||
|
|
t[found - 1] === '/'
|
|
) {
|
|
score += 20;
|
|
}
|
|
|
|
// Prefer earlier matches
|
|
score -= found;
|
|
|
|
prevIndex = found;
|
|
}
|
|
|
|
// Prefer tighter overall spans
|
|
const span = indices[indices.length - 1] - indices[0] + 1;
|
|
score += Math.max(0, 50 - (span - q.length) * 2);
|
|
// Prefer shorter labels slightly
|
|
score -= Math.max(0, t.length - q.length) * 0.1;
|
|
|
|
return { score, indices };
|
|
}
|
|
|
|
/** Best fuzzy match across multiple strings (title, keywords, etc.). */
|
|
export function fuzzyMatchAny(
|
|
query: string,
|
|
texts: Array<string | undefined | null>,
|
|
): FuzzyMatch | null {
|
|
let best: FuzzyMatch | null = null;
|
|
texts.forEach((text) => {
|
|
if (!text) return;
|
|
const match = fuzzyMatch(query, text);
|
|
if (match && (!best || match.score > best.score)) {
|
|
best = match;
|
|
}
|
|
});
|
|
return best;
|
|
}
|
|
|
|
export function fuzzyFilter<T>(
|
|
items: T[],
|
|
query: string,
|
|
getTexts: (item: T) => Array<string | undefined | null>,
|
|
): Array<{ item: T; score: number }> {
|
|
const q = query.trim();
|
|
if (!q) {
|
|
return items.map((item) => ({ item, score: 0 }));
|
|
}
|
|
|
|
const results: Array<{ item: T; score: number }> = [];
|
|
items.forEach((item) => {
|
|
const match = fuzzyMatchAny(q, getTexts(item));
|
|
if (match) {
|
|
results.push({ item, score: match.score });
|
|
}
|
|
});
|
|
results.sort((a, b) => b.score - a.score);
|
|
return results;
|
|
}
|