refactor(global-search): seperate matcher and filter

Author: elmarburke

plugins/global-search/src/utils/filter/execute-filter.ts

@@ -1,27 +1,33 @@
-import { assertNever } from "../assert"
 import type { IndexCollectionItemEntry, IndexEntry, IndexNodeEntry } from "../indexer/types"
 import { findRanges } from "./ranges"
-import { type Filter, FilterType, type Result, ResultType, type RootNodesFilter, type TextFilter } from "./types"
+import { type Filter, type Matcher, type Result, ResultType, type RootNodesFilter, type TextMatcher } from "./types"
 
 /** Execute a list of filters on a list of entries and return the results. */
-export function executeFilters(filters: readonly Filter[], index: readonly IndexEntry[]): Result[] {
+export function executeFilters(
+    /** The matchers to execute on the index. */
+    matchers: readonly Matcher[],
+    /** A filter to narrow down the results. */
+    filters: readonly Filter[],
+    /** The index to search on */
+    index: readonly IndexEntry[]
+): Result[] {
     const results: Result[] = []
 
     for (const entry of index) {
         let include = true
         let result: Result | undefined
 
-        for (const filter of filters) {
-            const filterResult = executeFilter(filter, entry)
+        for (const matcher of matchers) {
+            const matchResult = executeMatcher(matcher, entry)
 
-            if (typeof filterResult !== "boolean") {
-                result = filterResult
-            }
-
-            if (filterResult === false) {
+            if (matchResult === undefined) {
                 include = false
                 break
             }
+
+            if (filters.some(filter => executeFilter(filter, matchResult))) {
+                result = matchResult
+            }
         }
 
         if (include && result) {
@@ -32,30 +38,21 @@ export function executeFilters(filters: readonly Filter[], index: readonly Index
     return results
 }
 
-/** Execute a filter on a single entry and routes to the appropriate filter function. */
-function executeFilter(filter: Filter, entry: IndexEntry): FilterResult {
-    switch (filter.type) {
-        case FilterType.Text:
-            if (entry.type === "CollectionItem") {
-                return executeTextFilterForCollectionItems(filter, entry)
-            }
-            return executeTextFilterForNodes(filter, entry)
-        case FilterType.RootNodes:
-            return executeRootNodesFilter(filter, entry)
-        default:
-            assertNever(filter)
+/** Execute a matcher on a single entry and routes to the appropriate matcher function. */
+function executeMatcher(matcher: Matcher, entry: IndexEntry): Result | undefined {
+    // When more matchers are added, we can add more matcher functions here and use this as a router
+    if (entry.type === "CollectionItem") {
+        return executeTextMatcherForCollectionItems(matcher, entry)
     }
+    return executeTextMatcherForNodes(matcher, entry)
 }
 
-/** Internal type for filter execution. When result is `false`, the entry is excluded. When result is `true` or `Result`, the entry is included. */
-type FilterResult = Result | boolean
-
-function executeTextFilterForNodes(filter: TextFilter, entry: IndexNodeEntry): FilterResult {
+function executeTextMatcherForNodes(matcher: TextMatcher, entry: IndexNodeEntry): Result | undefined {
     const text = entry.text ?? entry.name
-    if (!text) return false
+    if (!text) return undefined
 
-    const ranges = findRanges(text, filter.query, filter.caseSensitive)
-    if (!ranges.length) return false
+    const ranges = findRanges(text, matcher.query, matcher.caseSensitive)
+    if (!ranges.length) return undefined
 
     return {
         id: entry.id,
@@ -66,11 +63,14 @@ function executeTextFilterForNodes(filter: TextFilter, entry: IndexNodeEntry): F
     }
 }
 
-function executeTextFilterForCollectionItems(filter: TextFilter, entry: IndexCollectionItemEntry): FilterResult {
+function executeTextMatcherForCollectionItems(
+    matcher: TextMatcher,
+    entry: IndexCollectionItemEntry
+): Result | undefined {
     // FIXME: This only returns the first matching field
     // Instead of having multiple fields in the index, we should have a single entry per field in the index
     for (const [field, text] of Object.entries(entry.fields)) {
-        const ranges = findRanges(text, filter.query, filter.caseSensitive)
+        const ranges = findRanges(text, matcher.query, matcher.caseSensitive)
         if (ranges.length) {
             return {
                 id: `${entry.id}-${field}`,
@@ -83,9 +83,15 @@ function executeTextFilterForCollectionItems(filter: TextFilter, entry: IndexCol
         }
     }
 
-    return false
+    return undefined
+}
+
+/** Execute a filter on a result and return true if the result should be included. */
+function executeFilter(filter: Filter, result: Result): boolean {
+    // When more filters are added, we can add more filter functions here and use this as a router
+    return executeRootNodesFilter(filter, result)
 }
 
-function executeRootNodesFilter(filter: RootNodesFilter, entry: IndexEntry): FilterResult {
-    return filter.rootNodes.includes(entry.rootNodeType)
+function executeRootNodesFilter(filter: RootNodesFilter, result: Result): boolean {
+    return filter.rootNodes.includes(result.entry.rootNodeType)
 }

plugins/global-search/src/utils/filter/types.ts

@@ -2,26 +2,27 @@ import type { IndexCollectionItemEntry, IndexEntry, IndexNodeEntry, RootNodeType
 import type { Range } from "./ranges"
 
 export const enum FilterType {
-    Text = "text",
     RootNodes = "rootNodes",
 }
 
-interface BaseFilter {
-    readonly type: FilterType
+export const enum MatcherType {
+    Text = "text",
 }
 
-export interface TextFilter extends BaseFilter {
-    readonly type: FilterType.Text
+// A matcher produces a result, while a filter can narrows down the results
+export interface TextMatcher {
+    readonly type: MatcherType.Text
     readonly query: string
     readonly caseSensitive: boolean
 }
 
-export interface RootNodesFilter extends BaseFilter {
+export interface RootNodesFilter {
     readonly type: FilterType.RootNodes
     readonly rootNodes: readonly RootNodeType[]
 }
 
-export type Filter = TextFilter | RootNodesFilter
+export type Matcher = TextMatcher
+export type Filter = RootNodesFilter
 
 export enum ResultType {
     CollectionItem = "CollectionItem",

plugins/global-search/src/utils/filter/useFilter.ts

@@ -3,7 +3,7 @@ import type { IndexEntry, RootNodeType } from "../indexer/types"
 import { executeFilters } from "./execute-filter"
 import type { ReadonlyGroupedResults } from "./group-results"
 import { groupResults } from "./group-results"
-import { type Filter, FilterType } from "./types"
+import { type Filter, FilterType, type Matcher, MatcherType } from "./types"
 
 export function useFilter(
     query: string,
@@ -14,18 +14,19 @@ export function useFilter(
 } {
     const deferredQuery = useDeferredValue(query)
 
+    const matchers = useMemo((): readonly Matcher[] => {
+        return [{ type: MatcherType.Text, query: deferredQuery, caseSensitive: false }]
+    }, [deferredQuery])
+
     const filters = useMemo((): readonly Filter[] => {
-        return [
-            { type: FilterType.Text, query: deferredQuery, caseSensitive: false },
-            { type: FilterType.RootNodes, rootNodes: searchOptions },
-        ]
-    }, [deferredQuery, searchOptions])
+        return [{ type: FilterType.RootNodes, rootNodes: searchOptions }]
+    }, [searchOptions])
 
     const results = useMemo(() => {
-        const items = executeFilters(filters, index)
+        const items = executeFilters(matchers, filters, index)
 
         return groupResults(items)
-    }, [filters, index])
+    }, [matchers, filters, index])
 
     return {
         results,