use weighting system

Author: Rich-Harris

packages/site-kit/src/lib/search/search.ts

@@ -44,73 +44,71 @@ export function init(blocks: Block[]) {
 	inited = true;
 }
 
+const CURRENT_SECTION_BOOST = 2;
+const EXACT_MATCH_BOOST = 10;
+const WORD_MATCH_BOOST = 4;
+const NEAR_MATCH_BOOST = 2;
+const BREADCRUMB_LENGTH_BOOST = 0.2;
+
 /**
  * Search for a given query in the existing index
  */
 export function search(query: string, path: string): BlockGroup[] {
 	const escaped = query.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-	const regex = new RegExp(`(^|\\b)${escaped}`, 'i');
+	const exact_match = new RegExp(`^${escaped}$`, 'i');
+	const word_match = new RegExp(`(^|\\b)${escaped}($|\\b)`, 'i');
+	const near_match = new RegExp(`(^|\\b)${escaped}`, 'i');
 
 	const parts = path.split('/');
 
 	const blocks = indexes
 		.flatMap((index) => index.search(query))
 		// @ts-expect-error flexsearch types are wrong i think?
 		.map(lookup)
-		.map((block, rank) => ({ block: block as Block, rank }))
-		.sort((a, b) => {
+		.map((block) => {
+			const block_parts = block.href.split('/');
+
 			// prioritise current section
-			const a_parts = a.block.href.split('/');
-			const b_parts = b.block.href.split('/');
-
-			for (let i = 0; i < parts.length; i += 1) {
-				const a_part_matches = a_parts[i] === parts[i];
-				const b_part_matches = b_parts[i] === parts[i];
-
-				if (!a_part_matches || !b_part_matches) {
-					if (a_part_matches !== b_part_matches) {
-						if (i > 1) {
-							console.log('here', a, b);
-						}
-						return a_part_matches ? -1 : 1;
-					}
-
-					break;
-				}
+			let score = block_parts.findIndex((part, i) => part !== parts[i]);
+			if (score === -1) score = block_parts.length;
+			score *= CURRENT_SECTION_BOOST;
+
+			if (block.breadcrumbs.some((text) => exact_match.test(text))) {
+				console.log('EXACT MATCH', block.breadcrumbs);
+				score += EXACT_MATCH_BOOST;
+			} else if (block.breadcrumbs.some((text) => word_match.test(text))) {
+				score += WORD_MATCH_BOOST;
+			} else if (block.breadcrumbs.some((text) => near_match.test(text))) {
+				score += NEAR_MATCH_BOOST;
 			}
 
-			const a_title_matches = regex.test(a.block.breadcrumbs.at(-1)!);
-			const b_title_matches = regex.test(b.block.breadcrumbs.at(-1)!);
-
-			// massage the order a bit, so that title matches
-			// are given higher priority
-			if (a_title_matches !== b_title_matches) {
-				return a_title_matches ? -1 : 1;
-			}
+			// prioritise branches over leaves
+			score -= block.breadcrumbs.length * BREADCRUMB_LENGTH_BOOST;
 
-			return a.block.breadcrumbs.length - b.block.breadcrumbs.length || a.rank - b.rank;
-		})
-		.map(({ block }) => block);
+			return { block, score };
+		});
 
 	const groups: Record<string, BlockGroup> = {};
 
-	for (const block of blocks) {
+	for (const { score, block } of blocks) {
 		const breadcrumbs = block.breadcrumbs.slice(0, 2);
 
 		const group = (groups[breadcrumbs.join('::')] ??= {
 			breadcrumbs,
-			blocks: []
+			blocks: [],
+			score: 0
 		});
 
+		group.score = Math.max(score, group.score);
 		group.blocks.push(block);
 	}
 
-	return Object.values(groups);
+	return Object.values(groups).sort((a, b) => b.score - a.score);
 }
 
 /**
  * Get a block with details by its href
  */
 export function lookup(href: string) {
-	return map.get(href);
+	return map.get(href)!;
 }

packages/site-kit/src/lib/search/types.d.ts

@@ -8,4 +8,5 @@ export interface Block {
 export interface BlockGroup {
 	breadcrumbs: string[];
 	blocks: Block[];
+	score: number;
 }