refactor: extract filter methods to separate file

Author: Slartibartfass2

src/lib/components/composites/paper-components/paper-view/cards/ReferencesAndCitationsCardContent.svelte

@@ -1,10 +1,10 @@
 <script lang="ts">
     import NamedList from "$lib/components/composites/list/NamedList.svelte";
     import SearchBar from "$lib/components/composites/search-bar/SearchBar.svelte";
-    import { Fzf } from "fzf";
     import PaperListEntry from "../../PaperListEntry.svelte";
     import PaperListEntrySkeleton from "../../PaperListEntrySkeleton.svelte";
     import type { Paper } from "$lib/model/api/paper";
+    import { filterPapers } from "$lib/filters";
 
     export interface ReferencesAndCitationsCardContentProps {
         backwardReferencedPapers: Promise<Paper[]>;
@@ -19,14 +19,6 @@
     let backwardReferencedPapers = $state<Promise<Paper[]>>(allBackwardReferencedPapers);
     let forwardReferencedPapers = $state<Promise<Paper[]>>(allForwardReferencedPapers);
 
-    function filterPapers(allPapers: Paper[], searchText: string) {
-        const fzf = new Fzf(allPapers, {
-            selector: (paper) => `#${paper!.id} ${paper!.title}`,
-            casing: "case-insensitive",
-        });
-        return fzf.find(searchText).map((result) => result.item);
-    }
-
     function filterBackwardReferencedPapers(searchText: string) {
         backwardReferencedPapers = allBackwardReferencedPapers.then((allPapers) =>
             filterPapers(allPapers, searchText),

src/lib/components/composites/project-components/CreateProjectDialog.svelte

@@ -8,14 +8,14 @@
     import { cn } from "$lib/utils/shadcn-helper";
     import ChipsInput from "$lib/components/composites/input/ChipsInput.svelte";
     import { onMount } from "svelte";
-    import { Fzf } from "fzf";
     import { goto } from "$app/navigation";
     import { getName, getNames } from "$lib/utils/common-helper";
     import type { ValidationResult } from "$lib/model/general";
     import ErrorAlert from "$lib/components/composites/ErrorAlert.svelte";
     import { backendService } from "$lib/grpc-api";
     import { Nothing } from "$lib/model/api/base";
     import type { User } from "$lib/model/api/user";
+    import { filterUsers } from "$lib/filters";
 
     // at the beginning the dialog should not be open
     let open: boolean = $state(false);
@@ -60,8 +60,9 @@
      * @returns list of "name \<email\>" (sorted) representations of users that can be invited
      */
     function filterPossibleMembers(input: string): string[] {
-        const fzf = new Fzf(possibleMembers.map((user) => `${getName(user)} <${user.email}>`));
-        return fzf.find(input.toLowerCase()).map((result) => result.item);
+        return filterUsers(possibleMembers, input).map(
+            (member) => `${getName(member)} <${member.email}>`,
+        );
     }
 
     /**

src/lib/filters.ts

@@ -0,0 +1,59 @@
+import { Fzf, type Selector } from "fzf";
+import type { Paper } from "./model/api/paper";
+import { getName, getNames } from "./utils/common-helper";
+import type { User } from "./model/api/user";
+
+/**
+ * Generic filter function using Fzf.
+ *
+ * @param items - List of items to filter
+ * @param selector - Function to extract the string to match against
+ * @param searchText - Search text
+ * @returns List of items that match the search text
+ */
+function filter<T>(items: T[], selector: (item: T) => string, searchText: string) {
+    // Here we case the items to string[] and selector to Selector<string> because we can't just use a selector
+    // with a generic type. This is weird but it's the only way to make it work.
+    const fzf = new Fzf(items as string[], {
+        selector: selector as Selector<string>,
+        casing: "case-insensitive",
+    });
+    return fzf.find(searchText).map((result) => result.item) as T[];
+}
+
+/**
+ * Filters papers based on search text and sorts them by best match.
+ *
+ * The search text is matched against the following fields:
+ * - Paper ID
+ * - Paper Title
+ * - Paper Authors
+ *
+ * @param allPapers - List of all papers
+ * @param searchText - Search text
+ * @returns List of papers that match the search text
+ */
+function filterPapers(allPapers: Paper[], searchText: string) {
+    return filter(
+        allPapers,
+        (paper) => `#${paper.id} ${paper.title} ${getNames(paper.authors)}`,
+        searchText,
+    );
+}
+
+/**
+ * Filter users based on search text and sorts them by best match.
+ *
+ * The search text is matched against the following fields:
+ * - User Name
+ * - User Email
+ *
+ * @param allUsers - List of all users
+ * @param searchText - Search text
+ * @returns List of users that match the search text
+ */
+function filterUsers(allUsers: User[], searchText: string) {
+    return filter(allUsers, (user) => `${getName(user)} ${user.email}`, searchText);
+}
+
+export { filterPapers, filterUsers };