initiall commit

apps/frontend/src/utils/search.ts

@@ -0,0 +1,214 @@
+/**
+ * Search and filter utilities
+ */
+
+/**
+ * Fuzzy search implementation
+ */
+export function fuzzySearch(query: string, text: string): boolean {
+  const queryLower = query.toLowerCase();
+  const textLower = text.toLowerCase();
+  
+  let queryIndex = 0;
+  let textIndex = 0;
+  
+  while (queryIndex < queryLower.length && textIndex < textLower.length) {
+    if (queryLower[queryIndex] === textLower[textIndex]) {
+      queryIndex++;
+    }
+    textIndex++;
+  }
+  
+  return queryIndex === queryLower.length;
+}
+
+/**
+ * Calculate fuzzy match score (0-1, higher is better)
+ */
+export function fuzzyScore(query: string, text: string): number {
+  const queryLower = query.toLowerCase();
+  const textLower = text.toLowerCase();
+  
+  if (textLower.includes(queryLower)) {
+    // Exact substring match gets high score
+    return 1 - (textLower.indexOf(queryLower) / textLower.length) * 0.3;
+  }
+  
+  let score = 0;
+  let queryIndex = 0;
+  let textIndex = 0;
+  let consecutiveMatches = 0;
+  
+  while (queryIndex < queryLower.length && textIndex < textLower.length) {
+    if (queryLower[queryIndex] === textLower[textIndex]) {
+      score += 1 + consecutiveMatches * 0.5; // Bonus for consecutive matches
+      consecutiveMatches++;
+      queryIndex++;
+    } else {
+      consecutiveMatches = 0;
+    }
+    textIndex++;
+  }
+  
+  if (queryIndex < queryLower.length) {
+    return 0; // Didn't match all query characters
+  }
+  
+  return score / (queryLower.length + textLower.length);
+}
+
+/**
+ * Search multiple fields in an object
+ */
+export function searchObject<T extends Record<string, any>>(
+  obj: T,
+  query: string,
+  fields: (keyof T)[]
+): boolean {
+  const queryLower = query.toLowerCase();
+  
+  return fields.some(field => {
+    const value = obj[field];
+    if (value == null) return false;
+    return String(value).toLowerCase().includes(queryLower);
+  });
+}
+
+/**
+ * Filter array by search query across multiple fields
+ */
+export function filterBySearch<T extends Record<string, any>>(
+  items: T[],
+  query: string,
+  fields: (keyof T)[]
+): T[] {
+  if (!query.trim()) return items;
+  
+  return items.filter(item => searchObject(item, query, fields));
+}
+
+/**
+ * Sort items by relevance to search query
+ */
+export function sortByRelevance<T extends Record<string, any>>(
+  items: T[],
+  query: string,
+  fields: (keyof T)[]
+): T[] {
+  if (!query.trim()) return items;
+  
+  return items
+    .map(item => {
+      const scores = fields.map(field => {
+        const value = item[field];
+        if (value == null) return 0;
+        return fuzzyScore(query, String(value));
+      });
+      const maxScore = Math.max(...scores);
+      return { item, score: maxScore };
+    })
+    .filter(({ score }) => score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map(({ item }) => item);
+}
+
+/**
+ * Highlight matching text in a string
+ */
+export function highlightMatches(text: string, query: string): string {
+  if (!query.trim()) return text;
+  
+  const regex = new RegExp(`(${escapeRegex(query)})`, "gi");
+  return text.replace(regex, "<mark>$1</mark>");
+}
+
+/**
+ * Escape special regex characters
+ */
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Debounce function for search input
+ */
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+  
+  return function executedFunction(...args: Parameters<T>) {
+    const later = () => {
+      timeout = null;
+      func(...args);
+    };
+    
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+  };
+}
+
+/**
+ * Create a search index for faster lookups
+ */
+export class SearchIndex<T> {
+  private items: T[];
+  private index: Map<string, Set<number>>;
+  private getSearchableText: (item: T) => string;
+  
+  constructor(items: T[], getSearchableText: (item: T) => string) {
+    this.items = items;
+    this.getSearchableText = getSearchableText;
+    this.index = new Map();
+    this.buildIndex();
+  }
+  
+  private buildIndex() {
+    this.items.forEach((item, idx) => {
+      const text = this.getSearchableText(item).toLowerCase();
+      const words = text.split(/\s+/);
+      
+      words.forEach(word => {
+        if (!this.index.has(word)) {
+          this.index.set(word, new Set());
+        }
+        this.index.get(word)!.add(idx);
+      });
+    });
+  }
+  
+  search(query: string): T[] {
+    const words = query.toLowerCase().split(/\s+/).filter(w => w.length > 0);
+    if (words.length === 0) return this.items;
+    
+    // Find items that match all words
+    const matchingSets = words.map(word => {
+      // Find all index entries that start with this word
+      const matches = new Set<number>();
+      for (const [indexWord, indices] of this.index.entries()) {
+        if (indexWord.startsWith(word)) {
+          indices.forEach(idx => matches.add(idx));
+        }
+      }
+      return matches;
+    });
+    
+    // Intersect all sets
+    const intersection = matchingSets.reduce((acc, set) => {
+      const result = new Set<number>();
+      acc.forEach(idx => {
+        if (set.has(idx)) result.add(idx);
+      });
+      return result;
+    });
+    
+    return Array.from(intersection).map(idx => this.items[idx]);
+  }
+  
+  update(items: T[]) {
+    this.items = items;
+    this.index.clear();
+    this.buildIndex();
+  }
+}