@forcecalendar/core 2.1.0 → 2.1.2

package/core/search/EventSearch.js

@@ -4,473 +4,465 @@
  */
 
 export class EventSearch {
-    constructor(eventStore) {
-        this.eventStore = eventStore;
+  constructor(eventStore) {
+    this.eventStore = eventStore;
+
+    // Search index for performance
+    this.searchIndex = new Map();
+    this.indexFields = ['title', 'description', 'location', 'category'];
+
+    // Build initial index
+    this.rebuildIndex();
+  }
+
+  /**
+   * Search events by query string
+   * @param {string} query - Search query
+   * @param {Object} options - Search options
+   * @returns {Array} Matching events
+   */
+  search(query, options = {}) {
+    const {
+      fields = this.indexFields, // Fields to search in
+      fuzzy = true, // Fuzzy matching
+      caseSensitive = false, // Case sensitive search
+      limit = null, // Max results
+      sortBy = 'relevance' // Sort results
+    } = options;
+
+    if (!query || query.trim() === '') {
+      return [];
+    }
 
-        // Search index for performance
-        this.searchIndex = new Map();
-        this.indexFields = ['title', 'description', 'location', 'category'];
+    // Normalize query
+    const normalizedQuery = caseSensitive ? query : query.toLowerCase();
+    const queryTerms = this.tokenize(normalizedQuery);
+
+    // Search through events
+    const results = [];
+    const events = this.eventStore.getAllEvents();
+
+    for (const event of events) {
+      const score = this.calculateMatchScore(event, queryTerms, fields, {
+        fuzzy,
+        caseSensitive
+      });
+
+      if (score > 0) {
+        results.push({
+          event,
+          score,
+          matches: this.getMatchDetails(event, queryTerms, fields, { caseSensitive })
+        });
+      }
+    }
 
-        // Build initial index
-        this.rebuildIndex();
+    // Sort results
+    this.sortResults(results, sortBy);
+
+    // Apply limit
+    const limited = limit ? results.slice(0, limit) : results;
+
+    // Return just the events (not the scoring metadata)
+    return limited.map(r => r.event);
+  }
+
+  /**
+   * Filter events by criteria
+   * @param {Object} filters - Filter criteria
+   * @returns {Array} Filtered events
+   */
+  filter(filters) {
+    const {
+      dateRange = null,
+      categories = null,
+      locations = null,
+      attendees = null,
+      status = null,
+      allDay = null,
+      recurring = null,
+      hasReminders = null,
+      custom = null // Custom filter function
+    } = filters;
+
+    let events = this.eventStore.getAllEvents();
+
+    // Date range filter
+    if (dateRange) {
+      events = events.filter(event => {
+        const eventStart = event.start;
+        const eventEnd = event.end || event.start;
+        return (
+          (eventStart >= dateRange.start && eventStart <= dateRange.end) ||
+          (eventEnd >= dateRange.start && eventEnd <= dateRange.end) ||
+          (eventStart <= dateRange.start && eventEnd >= dateRange.end)
+        );
+      });
     }
 
-    /**
-     * Search events by query string
-     * @param {string} query - Search query
-     * @param {Object} options - Search options
-     * @returns {Array} Matching events
-     */
-    search(query, options = {}) {
-        const {
-            fields = this.indexFields,    // Fields to search in
-            fuzzy = true,                  // Fuzzy matching
-            caseSensitive = false,         // Case sensitive search
-            limit = null,                  // Max results
-            sortBy = 'relevance'          // Sort results
-        } = options;
-
-        if (!query || query.trim() === '') {
-            return [];
+    // Category filter
+    if (categories && categories.length > 0) {
+      const categorySet = new Set(categories);
+      events = events.filter(event => {
+        // Handle both single category and categories array
+        if (event.category) {
+          return categorySet.has(event.category);
         }
-
-        // Normalize query
-        const normalizedQuery = caseSensitive ? query : query.toLowerCase();
-        const queryTerms = this.tokenize(normalizedQuery);
-
-        // Search through events
-        const results = [];
-        const events = this.eventStore.getAllEvents();
-
-        for (const event of events) {
-            const score = this.calculateMatchScore(event, queryTerms, fields, {
-                fuzzy,
-                caseSensitive
-            });
-
-            if (score > 0) {
-                results.push({
-                    event,
-                    score,
-                    matches: this.getMatchDetails(event, queryTerms, fields, { caseSensitive })
-                });
-            }
+        if (event.categories && Array.isArray(event.categories)) {
+          return event.categories.some(cat => categorySet.has(cat));
         }
+        return false;
+      });
+    }
 
-        // Sort results
-        this.sortResults(results, sortBy);
-
-        // Apply limit
-        const limited = limit ? results.slice(0, limit) : results;
+    // Location filter
+    if (locations && locations.length > 0) {
+      const locationSet = new Set(locations.map(l => l.toLowerCase()));
+      events = events.filter(event => {
+        if (!event.location) return false;
+        return locationSet.has(event.location.toLowerCase());
+      });
+    }
 
-        // Return just the events (not the scoring metadata)
-        return limited.map(r => r.event);
+    // Attendees filter
+    if (attendees && attendees.length > 0) {
+      const attendeeEmails = new Set(
+        attendees.map(a => (typeof a === 'string' ? a.toLowerCase() : a.email?.toLowerCase()))
+      );
+      events = events.filter(event => {
+        if (!event.attendees || event.attendees.length === 0) return false;
+        return event.attendees.some(attendee => {
+          const email = attendee.email || attendee;
+          return attendeeEmails.has(email.toLowerCase());
+        });
+      });
     }
 
-    /**
-     * Filter events by criteria
-     * @param {Object} filters - Filter criteria
-     * @returns {Array} Filtered events
-     */
-    filter(filters) {
-        const {
-            dateRange = null,
-            categories = null,
-            locations = null,
-            attendees = null,
-            status = null,
-            allDay = null,
-            recurring = null,
-            hasReminders = null,
-            custom = null  // Custom filter function
-        } = filters;
-
-        let events = this.eventStore.getAllEvents();
-
-        // Date range filter
-        if (dateRange) {
-            events = events.filter(event => {
-                const eventStart = event.start;
-                const eventEnd = event.end || event.start;
-                return (
-                    (eventStart >= dateRange.start && eventStart <= dateRange.end) ||
-                    (eventEnd >= dateRange.start && eventEnd <= dateRange.end) ||
-                    (eventStart <= dateRange.start && eventEnd >= dateRange.end)
-                );
-            });
-        }
+    // Status filter
+    if (status) {
+      const statusSet = new Set(Array.isArray(status) ? status : [status]);
+      events = events.filter(event => statusSet.has(event.status));
+    }
 
-        // Category filter
-        if (categories && categories.length > 0) {
-            const categorySet = new Set(categories);
-            events = events.filter(event => {
-                // Handle both single category and categories array
-                if (event.category) {
-                    return categorySet.has(event.category);
-                }
-                if (event.categories && Array.isArray(event.categories)) {
-                    return event.categories.some(cat => categorySet.has(cat));
-                }
-                return false;
-            });
-        }
+    // All-day filter
+    if (allDay !== null) {
+      events = events.filter(event => event.allDay === allDay);
+    }
 
-        // Location filter
-        if (locations && locations.length > 0) {
-            const locationSet = new Set(locations.map(l => l.toLowerCase()));
-            events = events.filter(event => {
-                if (!event.location) return false;
-                return locationSet.has(event.location.toLowerCase());
-            });
-        }
+    // Recurring filter
+    if (recurring !== null) {
+      events = events.filter(event => {
+        const hasRecurrence = !!event.recurrence;
+        return recurring ? hasRecurrence : !hasRecurrence;
+      });
+    }
 
-        // Attendees filter
-        if (attendees && attendees.length > 0) {
-            const attendeeEmails = new Set(attendees.map(a =>
-                typeof a === 'string' ? a.toLowerCase() : a.email?.toLowerCase()
-            ));
-            events = events.filter(event => {
-                if (!event.attendees || event.attendees.length === 0) return false;
-                return event.attendees.some(attendee => {
-                    const email = attendee.email || attendee;
-                    return attendeeEmails.has(email.toLowerCase());
-                });
-            });
-        }
+    // Reminders filter
+    if (hasReminders !== null) {
+      events = events.filter(event => {
+        const hasRem = event.reminders && event.reminders.length > 0;
+        return hasReminders ? hasRem : !hasRem;
+      });
+    }
 
-        // Status filter
-        if (status) {
-            const statusSet = new Set(Array.isArray(status) ? status : [status]);
-            events = events.filter(event => statusSet.has(event.status));
-        }
+    // Custom filter function
+    if (custom && typeof custom === 'function') {
+      events = events.filter(custom);
+    }
 
-        // All-day filter
-        if (allDay !== null) {
-            events = events.filter(event => event.allDay === allDay);
-        }
+    return events;
+  }
+
+  /**
+   * Advanced search combining text search and filters
+   * @param {string} query - Search query
+   * @param {Object} filters - Filter criteria
+   * @param {Object} options - Search options
+   * @returns {Array} Matching events
+   */
+  advancedSearch(query, filters = {}, options = {}) {
+    // First apply filters
+    let events = this.filter(filters);
+
+    // Then search within filtered results if query provided
+    if (query && query.trim() !== '') {
+      const searchResults = this.search(query, {
+        ...options,
+        limit: null // Don't limit during filtering phase
+      });
+      const searchIds = new Set(searchResults.map(e => e.id));
+      events = events.filter(e => searchIds.has(e.id));
+    }
 
-        // Recurring filter
-        if (recurring !== null) {
-            events = events.filter(event => {
-                const hasRecurrence = !!event.recurrence;
-                return recurring ? hasRecurrence : !hasRecurrence;
-            });
-        }
+    // Apply final limit if specified
+    if (options.limit) {
+      events = events.slice(0, options.limit);
+    }
 
-        // Reminders filter
-        if (hasReminders !== null) {
-            events = events.filter(event => {
-                const hasRem = event.reminders && event.reminders.length > 0;
-                return hasReminders ? hasRem : !hasRem;
-            });
-        }
+    return events;
+  }
 
-        // Custom filter function
-        if (custom && typeof custom === 'function') {
-            events = events.filter(custom);
-        }
+  /**
+   * Get search suggestions/autocomplete
+   * @param {string} partial - Partial search term
+   * @param {Object} options - Suggestion options
+   * @returns {Array} Suggested terms
+   */
+  getSuggestions(partial, options = {}) {
+    const { field = 'title', limit = 10, minLength = 2 } = options;
 
-        return events;
+    if (!partial || partial.length < minLength) {
+      return [];
     }
 
-    /**
-     * Advanced search combining text search and filters
-     * @param {string} query - Search query
-     * @param {Object} filters - Filter criteria
-     * @param {Object} options - Search options
-     * @returns {Array} Matching events
-     */
-    advancedSearch(query, filters = {}, options = {}) {
-        // First apply filters
-        let events = this.filter(filters);
-
-        // Then search within filtered results if query provided
-        if (query && query.trim() !== '') {
-            const searchResults = this.search(query, {
-                ...options,
-                limit: null // Don't limit during filtering phase
-            });
-            const searchIds = new Set(searchResults.map(e => e.id));
-            events = events.filter(e => searchIds.has(e.id));
-        }
+    const normalizedPartial = partial.toLowerCase();
+    const suggestions = new Set();
+    const events = this.eventStore.getAllEvents();
 
-        // Apply final limit if specified
-        if (options.limit) {
-            events = events.slice(0, options.limit);
-        }
+    for (const event of events) {
+      const value = event[field];
+      if (!value) continue;
 
-        return events;
+      const normalizedValue = value.toLowerCase();
+      if (normalizedValue.includes(normalizedPartial)) {
+        suggestions.add(value);
+        if (suggestions.size >= limit) break;
+      }
     }
 
-    /**
-     * Get search suggestions/autocomplete
-     * @param {string} partial - Partial search term
-     * @param {Object} options - Suggestion options
-     * @returns {Array} Suggested terms
-     */
-    getSuggestions(partial, options = {}) {
-        const {
-            field = 'title',
-            limit = 10,
-            minLength = 2
-        } = options;
-
-        if (!partial || partial.length < minLength) {
-            return [];
+    return Array.from(suggestions);
+  }
+
+  /**
+   * Get unique values for a field (for filter dropdowns)
+   * @param {string} field - Field name
+   * @returns {Array} Unique values
+   */
+  getUniqueValues(field) {
+    const values = new Set();
+    const events = this.eventStore.getAllEvents();
+
+    for (const event of events) {
+      // Special handling for category/categories
+      if (field === 'category') {
+        // Check both single category and categories array
+        if (event.category) {
+          values.add(event.category);
         }
-
-        const normalizedPartial = partial.toLowerCase();
-        const suggestions = new Set();
-        const events = this.eventStore.getAllEvents();
-
-        for (const event of events) {
-            const value = event[field];
-            if (!value) continue;
-
-            const normalizedValue = value.toLowerCase();
-            if (normalizedValue.includes(normalizedPartial)) {
-                suggestions.add(value);
-                if (suggestions.size >= limit) break;
-            }
+        if (event.categories && Array.isArray(event.categories)) {
+          event.categories.forEach(cat => values.add(cat));
         }
-
-        return Array.from(suggestions);
+      } else {
+        const value = event[field];
+        if (value !== undefined && value !== null && value !== '') {
+          if (Array.isArray(value)) {
+            value.forEach(v => values.add(v));
+          } else {
+            values.add(value);
+          }
+        }
+      }
     }
 
-    /**
-     * Get unique values for a field (for filter dropdowns)
-     * @param {string} field - Field name
-     * @returns {Array} Unique values
-     */
-    getUniqueValues(field) {
-        const values = new Set();
-        const events = this.eventStore.getAllEvents();
-
-        for (const event of events) {
-            // Special handling for category/categories
-            if (field === 'category') {
-                // Check both single category and categories array
-                if (event.category) {
-                    values.add(event.category);
-                }
-                if (event.categories && Array.isArray(event.categories)) {
-                    event.categories.forEach(cat => values.add(cat));
-                }
-            } else {
-                const value = event[field];
-                if (value !== undefined && value !== null && value !== '') {
-                    if (Array.isArray(value)) {
-                        value.forEach(v => values.add(v));
-                    } else {
-                        values.add(value);
-                    }
-                }
-            }
-        }
+    return Array.from(values).sort();
+  }
+
+  /**
+   * Group events by a field
+   * @param {string} field - Field to group by
+   * @param {Object} options - Grouping options
+   * @returns {Object} Grouped events
+   */
+  groupBy(field, options = {}) {
+    const { sortGroups = true, sortEvents = false, includeEmpty = false } = options;
+
+    const groups = new Map();
+    const events = this.eventStore.getAllEvents();
+
+    for (const event of events) {
+      const value = event[field] || (includeEmpty ? `(No ${field})` : null);
+      if (value === null) continue;
+
+      if (!groups.has(value)) {
+        groups.set(value, []);
+      }
+      groups.get(value).push(event);
+    }
 
-        return Array.from(values).sort();
+    // Sort events within groups if requested
+    if (sortEvents) {
+      for (const [key, eventList] of groups) {
+        eventList.sort((a, b) => a.start - b.start);
+      }
     }
 
-    /**
-     * Group events by a field
-     * @param {string} field - Field to group by
-     * @param {Object} options - Grouping options
-     * @returns {Object} Grouped events
-     */
-    groupBy(field, options = {}) {
-        const {
-            sortGroups = true,
-            sortEvents = false,
-            includeEmpty = false
-        } = options;
-
-        const groups = new Map();
-        const events = this.eventStore.getAllEvents();
-
-        for (const event of events) {
-            const value = event[field] || (includeEmpty ? `(No ${  field  })` : null);
-            if (value === null) continue;
-
-            if (!groups.has(value)) {
-                groups.set(value, []);
-            }
-            groups.get(value).push(event);
-        }
+    // Convert to object and sort keys if requested
+    const result = {};
+    const keys = Array.from(groups.keys());
+    if (sortGroups) keys.sort();
 
-        // Sort events within groups if requested
-        if (sortEvents) {
-            for (const [key, eventList] of groups) {
-                eventList.sort((a, b) => a.start - b.start);
-            }
-        }
+    for (const key of keys) {
+      result[key] = groups.get(key);
+    }
 
-        // Convert to object and sort keys if requested
-        const result = {};
-        const keys = Array.from(groups.keys());
-        if (sortGroups) keys.sort();
+    return result;
+  }
 
-        for (const key of keys) {
-            result[key] = groups.get(key);
-        }
+  /**
+   * Calculate match score for an event
+   * @private
+   */
+  calculateMatchScore(event, queryTerms, fields, options) {
+    let totalScore = 0;
+    const { fuzzy, caseSensitive } = options;
 
-        return result;
-    }
+    for (const field of fields) {
+      const value = event[field];
+      if (!value) continue;
+
+      const normalizedValue = caseSensitive ? value : value.toLowerCase();
 
-    /**
-     * Calculate match score for an event
-     * @private
-     */
-    calculateMatchScore(event, queryTerms, fields, options) {
-        let totalScore = 0;
-        const { fuzzy, caseSensitive } = options;
-
-        for (const field of fields) {
-            const value = event[field];
-            if (!value) continue;
-
-            const normalizedValue = caseSensitive ? value : value.toLowerCase();
-
-            for (const term of queryTerms) {
-                // Exact match gets highest score
-                if (normalizedValue.includes(term)) {
-                    totalScore += 10;
-                }
-                // Fuzzy match if enabled
-                else if (fuzzy) {
-                    const distance = this.levenshteinDistance(term, normalizedValue);
-                    if (distance <= 2) {
-                        totalScore += (5 - distance);
-                    }
-                }
-            }
-
-            // Boost score for title matches
-            if (field === 'title') {
-                totalScore *= 2;
-            }
+      for (const term of queryTerms) {
+        // Exact match gets highest score
+        if (normalizedValue.includes(term)) {
+          totalScore += 10;
         }
+        // Fuzzy match if enabled
+        else if (fuzzy) {
+          const distance = this.levenshteinDistance(term, normalizedValue);
+          if (distance <= 2) {
+            totalScore += 5 - distance;
+          }
+        }
+      }
 
-        return totalScore;
+      // Boost score for title matches
+      if (field === 'title') {
+        totalScore *= 2;
+      }
     }
 
-    /**
-     * Get match details for highlighting
-     * @private
-     */
-    getMatchDetails(event, queryTerms, fields, options) {
-        const matches = {};
-        const { caseSensitive } = options;
-
-        for (const field of fields) {
-            const value = event[field];
-            if (!value) continue;
-
-            const normalizedValue = caseSensitive ? value : value.toLowerCase();
-            const fieldMatches = [];
-
-            for (const term of queryTerms) {
-                let index = normalizedValue.indexOf(term);
-                while (index !== -1) {
-                    fieldMatches.push({
-                        start: index,
-                        end: index + term.length,
-                        term
-                    });
-                    index = normalizedValue.indexOf(term, index + 1);
-                }
-            }
-
-            if (fieldMatches.length > 0) {
-                matches[field] = fieldMatches;
-            }
+    return totalScore;
+  }
+
+  /**
+   * Get match details for highlighting
+   * @private
+   */
+  getMatchDetails(event, queryTerms, fields, options) {
+    const matches = {};
+    const { caseSensitive } = options;
+
+    for (const field of fields) {
+      const value = event[field];
+      if (!value) continue;
+
+      const normalizedValue = caseSensitive ? value : value.toLowerCase();
+      const fieldMatches = [];
+
+      for (const term of queryTerms) {
+        let index = normalizedValue.indexOf(term);
+        while (index !== -1) {
+          fieldMatches.push({
+            start: index,
+            end: index + term.length,
+            term
+          });
+          index = normalizedValue.indexOf(term, index + 1);
         }
+      }
 
-        return matches;
+      if (fieldMatches.length > 0) {
+        matches[field] = fieldMatches;
+      }
     }
 
-    /**
-     * Tokenize search query
-     * @private
-     */
-    tokenize(query) {
-        // Simple tokenization - split by spaces and remove empty strings
-        return query.split(/\s+/).filter(term => term.length > 0);
+    return matches;
+  }
+
+  /**
+   * Tokenize search query
+   * @private
+   */
+  tokenize(query) {
+    // Simple tokenization - split by spaces and remove empty strings
+    return query.split(/\s+/).filter(term => term.length > 0);
+  }
+
+  /**
+   * Calculate Levenshtein distance for fuzzy matching
+   * @private
+   */
+  levenshteinDistance(a, b) {
+    if (a.length === 0) return b.length;
+    if (b.length === 0) return a.length;
+
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+      matrix[i] = [i];
     }
-
-    /**
-     * Calculate Levenshtein distance for fuzzy matching
-     * @private
-     */
-    levenshteinDistance(a, b) {
-        if (a.length === 0) return b.length;
-        if (b.length === 0) return a.length;
-
-        const matrix = [];
-        for (let i = 0; i <= b.length; i++) {
-            matrix[i] = [i];
-        }
-        for (let j = 0; j <= a.length; j++) {
-            matrix[0][j] = j;
-        }
-
-        for (let i = 1; i <= b.length; i++) {
-            for (let j = 1; j <= a.length; j++) {
-                if (b.charAt(i - 1) === a.charAt(j - 1)) {
-                    matrix[i][j] = matrix[i - 1][j - 1];
-                } else {
-                    matrix[i][j] = Math.min(
-                        matrix[i - 1][j - 1] + 1,
-                        matrix[i][j - 1] + 1,
-                        matrix[i - 1][j] + 1
-                    );
-                }
-            }
-        }
-
-        return matrix[b.length][a.length];
+    for (let j = 0; j <= a.length; j++) {
+      matrix[0][j] = j;
     }
 
-    /**
-     * Sort search results
-     * @private
-     */
-    sortResults(results, sortBy) {
-        switch (sortBy) {
-            case 'relevance':
-                results.sort((a, b) => b.score - a.score);
-                break;
-            case 'date':
-                results.sort((a, b) => a.event.start - b.event.start);
-                break;
-            case 'title':
-                results.sort((a, b) => a.event.title.localeCompare(b.event.title));
-                break;
-            default:
-                // Keep original order
-                break;
+    for (let i = 1; i <= b.length; i++) {
+      for (let j = 1; j <= a.length; j++) {
+        if (b.charAt(i - 1) === a.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1];
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            matrix[i][j - 1] + 1,
+            matrix[i - 1][j] + 1
+          );
         }
+      }
     }
 
-    /**
-     * Rebuild search index
-     */
-    rebuildIndex() {
-        this.searchIndex.clear();
-        const events = this.eventStore.getAllEvents();
-
-        for (const event of events) {
-            for (const field of this.indexFields) {
-                const value = event[field];
-                if (!value) continue;
-
-                const tokens = this.tokenize(value.toLowerCase());
-                for (const token of tokens) {
-                    if (!this.searchIndex.has(token)) {
-                        this.searchIndex.set(token, new Set());
-                    }
-                    this.searchIndex.get(token).add(event.id);
-                }
-            }
+    return matrix[b.length][a.length];
+  }
+
+  /**
+   * Sort search results
+   * @private
+   */
+  sortResults(results, sortBy) {
+    switch (sortBy) {
+      case 'relevance':
+        results.sort((a, b) => b.score - a.score);
+        break;
+      case 'date':
+        results.sort((a, b) => a.event.start - b.event.start);
+        break;
+      case 'title':
+        results.sort((a, b) => a.event.title.localeCompare(b.event.title));
+        break;
+      default:
+        // Keep original order
+        break;
+    }
+  }
+
+  /**
+   * Rebuild search index
+   */
+  rebuildIndex() {
+    this.searchIndex.clear();
+    const events = this.eventStore.getAllEvents();
+
+    for (const event of events) {
+      for (const field of this.indexFields) {
+        const value = event[field];
+        if (!value) continue;
+
+        const tokens = this.tokenize(value.toLowerCase());
+        for (const token of tokens) {
+          if (!this.searchIndex.has(token)) {
+            this.searchIndex.set(token, new Set());
+          }
+          this.searchIndex.get(token).add(event.id);
         }
+      }
     }
-}
+  }
+}