add filterObjectsByWords utility function

dist/index.js

@@ -314,22 +314,6 @@
   function createTimestamp() {
     return (/* @__PURE__ */ new Date()).toISOString();
   }
-  var HandlerManager = class {
-    handlers = /* @__PURE__ */ new Set();
-    // manage
-    addHandler = (handler) => {
-      this.handlers.add(handler);
-    };
-    deleteHandler = (handler) => {
-      this.handlers.delete(handler);
-    };
-    // trigger
-    trigger = (item) => {
-      for (const handler of this.handlers) {
-        handler(item);
-      }
-    };
-  };
   function checkDoesObjectMatchReference(reference, stringEntryObject) {
     reference_entry_loop: for (const referenceEntry of Object.entries(
       reference
@@ -369,6 +353,22 @@
     }
     return [...values.values()].sort(localeCompare);
   }
+  var HandlerManager = class {
+    handlers = /* @__PURE__ */ new Set();
+    // manage
+    addHandler = (handler) => {
+      this.handlers.add(handler);
+    };
+    deleteHandler = (handler) => {
+      this.handlers.delete(handler);
+    };
+    // trigger
+    trigger = (item) => {
+      for (const handler of this.handlers) {
+        handler(item);
+      }
+    };
+  };
   var IndexManager = class {
     itemToString;
     sortedStrings = [];

src/Model/Utility/utility.ts

@@ -5,35 +5,12 @@ export function createTimestamp(): string {
   return new Date().toISOString();
 }
 
-// handlers
+// filters etc
-export type Handler<T> = (item: T) => void;
-
-export class HandlerManager<T> {
-  handlers: Set<Handler<T>> = new Set();
-
-  // manage
-  addHandler = (handler: Handler<T>): void => {
-    this.handlers.add(handler);
-  };
-
-  deleteHandler = (handler: Handler<T>): void => {
-    this.handlers.delete(handler);
-  };
-
-  // trigger
-  trigger = (item: T): void => {
-    for (const handler of this.handlers) {
-      handler(item);
-    }
-  };
-}
-
-// objects
 export type StringEntryObject = { [key: string]: string | undefined };
 
 export function filterObjectsByStringEntries<T>(
   reference: StringEntryObject,
-  converter: (T) => StringEntryObject,
+  converter: (object: T) => StringEntryObject,
   objects: T[]
 ): Set<T> {
   const matches: Set<T> = new Set();
@@ -116,6 +93,80 @@ export function collectObjectValuesForKey<T>(
   return [...values.values()].sort(localeCompare);
 }
 
+export function filterObjectsByWords<T>(
+  query: string,
+  getStringsOfObject: (object: T) => string[],
+  objects: T[]
+): Set<T> {
+  const matches: Set<T> = new Set();
+
+  object_loop: for (const object of objects) {
+    const doesMatch: boolean = checkIfMatchesFilter(
+      query,
+      getStringsOfObject,
+      object
+    );
+    if (doesMatch) matches.add(object);
+  }
+
+  return matches;
+}
+
+export function checkIfMatchesFilter<T>(
+  query: string,
+  getStringsOfObject: (object: T) => string[],
+  object: T
+): boolean {
+  if (query == "") return true;
+
+  const stringsInObject: string[] = getStringsOfObject(object);
+  const wordsInObject: string[] = [];
+  for (const string of stringsInObject) {
+    const lowercaseWordsInString = string.toLocaleLowerCase().split(" ");
+    wordsInObject.push(...lowercaseWordsInString);
+  }
+
+  const lowercaseWordsInQuery = query.toLowerCase().split(" ");
+  for (const queryWord of lowercaseWordsInQuery) {
+    if (queryWord[0] == "-") {
+      // exclusion
+      const wordContent = queryWord.substring(1);
+      if (wordsInObject.includes(wordContent)) {
+        return false;
+      }
+    } else {
+      if (wordsInObject.includes(queryWord) == false) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+// handlers
+export type Handler<T> = (item: T) => void;
+
+export class HandlerManager<T> {
+  handlers: Set<Handler<T>> = new Set();
+
+  // manage
+  addHandler = (handler: Handler<T>): void => {
+    this.handlers.add(handler);
+  };
+
+  deleteHandler = (handler: Handler<T>): void => {
+    this.handlers.delete(handler);
+  };
+
+  // trigger
+  trigger = (item: T): void => {
+    for (const handler of this.handlers) {
+      handler(item);
+    }
+  };
+}
+
 // sorting
 export class IndexManager<T> {
   private itemToString: (item: T) => string;