@forcecalendar/core 2.1.64 → 2.1.66

package/core/events/EventStore.js

@@ -29,6 +29,7 @@ export class EventStore {
       /** @type {Map<string, Set<string>>} Status -> Set of event IDs */
       byStatus: new Map()
     };
+    this.eventIndexRefs = new Map();
 
     // Timezone manager for conversions (use singleton to share cache)
     this.timezoneManager = TimezoneManager.getInstance();
@@ -334,9 +335,6 @@ export class EventStore {
   getEventsForDate(date, timezone = null) {
     timezone = timezone || this.defaultTimezone;
 
-    // Use local date string for the query date (in the calendar's timezone)
-    const dateStr = DateUtils.getLocalDateString(date);
-
     // Collect candidate event IDs from indices
     const candidateIds = new Set();
 
@@ -409,23 +407,40 @@ export class EventStore {
 
     // Collect all events from those dates
     const checkedIds = new Set();
-    dates.forEach(date => {
-      // Use getLocalDateString to match the index key format (YYYY-MM-DD)
-      const dateStr = DateUtils.getLocalDateString(date);
-      const eventIds = this.indices.byDate.get(dateStr) || new Set();
+    const addCandidateIds = eventIds => {
+      if (!eventIds) return;
 
       eventIds.forEach(id => {
         if (!checkedIds.has(id) && id !== excludeId) {
           checkedIds.add(id);
-          const event = this.events.get(id);
-
-          if (event && event.overlaps({ start, end })) {
-            overlapping.push(event);
-          }
         }
       });
+    };
+
+    dates.forEach(date => {
+      // Use getLocalDateString to match the index key format (YYYY-MM-DD)
+      const dateStr = DateUtils.getLocalDateString(date);
+      addCandidateIds(this.indices.byDate.get(dateStr));
     });
 
+    // Lazy-indexed long events may not have every day in byDate. Use month
+    // buckets as candidates and rely on precise overlap filtering below.
+    const currentMonth = new Date(startDate.getFullYear(), startDate.getMonth(), 1);
+    const endMonth = new Date(endDate.getFullYear(), endDate.getMonth(), 1);
+    while (currentMonth <= endMonth) {
+      const monthKey = `${currentMonth.getFullYear()}-${String(currentMonth.getMonth() + 1).padStart(2, '0')}`;
+      addCandidateIds(this.indices.byMonth.get(monthKey));
+      currentMonth.setMonth(currentMonth.getMonth() + 1);
+    }
+
+    for (const id of checkedIds) {
+      const event = this.events.get(id);
+
+      if (event && event.overlaps({ start, end })) {
+        overlapping.push(event);
+      }
+    }
+
     return overlapping.sort((a, b) => a.start - b.start);
   }
 
@@ -647,6 +662,7 @@ export class EventStore {
     this.indices.recurring.clear();
     this.indices.byCategory.clear();
     this.indices.byStatus.clear();
+    this.eventIndexRefs.clear();
 
     this._notifyChange({
       type: 'clear',
@@ -687,6 +703,8 @@ export class EventStore {
    * @private
    */
   _indexEvent(event) {
+    this._createIndexRefs(event.id);
+
     // Check if should use lazy indexing for large date ranges
     if (this.optimizer.shouldUseLazyIndexing(event)) {
       this._indexEventLazy(event);
@@ -706,26 +724,14 @@ export class EventStore {
 
     dates.forEach(date => {
       const dateStr = DateUtils.getLocalDateString(date);
-
-      if (!this.indices.byDate.has(dateStr)) {
-        this.indices.byDate.set(dateStr, new Set());
-      }
-      this.indices.byDate.get(dateStr).add(event.id);
+      this._addToKeyedIndex('byDate', dateStr, event.id);
     });
 
-    // Index by month(s) using UTC
-    const startMonth = `${startDate.getFullYear()}-${String(startDate.getMonth() + 1).padStart(2, '0')}`;
-    const endMonth = `${endDate.getFullYear()}-${String(endDate.getMonth() + 1).padStart(2, '0')}`;
-
     // Add to all months the event spans
     const currentMonth = new Date(startDate.getFullYear(), startDate.getMonth(), 1);
     while (currentMonth <= endDate) {
       const monthKey = `${currentMonth.getFullYear()}-${String(currentMonth.getMonth() + 1).padStart(2, '0')}`;
-
-      if (!this.indices.byMonth.has(monthKey)) {
-        this.indices.byMonth.set(monthKey, new Set());
-      }
-      this.indices.byMonth.get(monthKey).add(event.id);
+      this._addToKeyedIndex('byMonth', monthKey, event.id);
 
       currentMonth.setMonth(currentMonth.getMonth() + 1);
     }
@@ -733,24 +739,19 @@ export class EventStore {
     // Index by categories
     if (event.categories && event.categories.length > 0) {
       event.categories.forEach(category => {
-        if (!this.indices.byCategory.has(category)) {
-          this.indices.byCategory.set(category, new Set());
-        }
-        this.indices.byCategory.get(category).add(event.id);
+        this._addToKeyedIndex('byCategory', category, event.id);
       });
     }
 
     // Index by status
     if (event.status) {
-      if (!this.indices.byStatus.has(event.status)) {
-        this.indices.byStatus.set(event.status, new Set());
-      }
-      this.indices.byStatus.get(event.status).add(event.id);
+      this._addToKeyedIndex('byStatus', event.status, event.id);
     }
 
     // Index recurring events
     if (event.recurring) {
       this.indices.recurring.add(event.id);
+      this.eventIndexRefs.get(event.id).recurring = true;
     }
   }
 
@@ -759,8 +760,7 @@ export class EventStore {
    * @private
    */
   _indexEventLazy(event) {
-    // Create lazy index markers
-    const markers = this.optimizer.createLazyIndexMarkers(event);
+    this.optimizer.createLazyIndexMarkers(event);
 
     // Index only the boundaries initially (in event's local timezone)
     const eventStartLocal = event.getStartInTimezone(event.timeZone);
@@ -779,10 +779,7 @@ export class EventStore {
 
     firstWeekDates.forEach(date => {
       const dateStr = DateUtils.getLocalDateString(date);
-      if (!this.indices.byDate.has(dateStr)) {
-        this.indices.byDate.set(dateStr, new Set());
-      }
-      this.indices.byDate.get(dateStr).add(event.id);
+      this._addToKeyedIndex('byDate', dateStr, event.id);
     });
 
     // Index last week if different from first
@@ -796,10 +793,7 @@ export class EventStore {
 
       lastWeekDates.forEach(date => {
         const dateStr = DateUtils.getLocalDateString(date);
-        if (!this.indices.byDate.has(dateStr)) {
-          this.indices.byDate.set(dateStr, new Set());
-        }
-        this.indices.byDate.get(dateStr).add(event.id);
+        this._addToKeyedIndex('byDate', dateStr, event.id);
       });
     }
 
@@ -807,33 +801,53 @@ export class EventStore {
     const currentMonth = new Date(startDate.getFullYear(), startDate.getMonth(), 1);
     while (currentMonth <= endDate) {
       const monthKey = `${currentMonth.getFullYear()}-${String(currentMonth.getMonth() + 1).padStart(2, '0')}`;
-      if (!this.indices.byMonth.has(monthKey)) {
-        this.indices.byMonth.set(monthKey, new Set());
-      }
-      this.indices.byMonth.get(monthKey).add(event.id);
+      this._addToKeyedIndex('byMonth', monthKey, event.id);
       currentMonth.setMonth(currentMonth.getMonth() + 1);
     }
 
     // Index other properties normally
     if (event.categories && event.categories.length > 0) {
       event.categories.forEach(category => {
-        if (!this.indices.byCategory.has(category)) {
-          this.indices.byCategory.set(category, new Set());
-        }
-        this.indices.byCategory.get(category).add(event.id);
+        this._addToKeyedIndex('byCategory', category, event.id);
       });
     }
 
     if (event.status) {
-      if (!this.indices.byStatus.has(event.status)) {
-        this.indices.byStatus.set(event.status, new Set());
-      }
-      this.indices.byStatus.get(event.status).add(event.id);
+      this._addToKeyedIndex('byStatus', event.status, event.id);
     }
 
     if (event.recurring) {
       this.indices.recurring.add(event.id);
+      this.eventIndexRefs.get(event.id).recurring = true;
+    }
+  }
+
+  /**
+   * Create reverse index references for an event.
+   * @private
+   */
+  _createIndexRefs(eventId) {
+    this.eventIndexRefs.set(eventId, {
+      byDate: new Set(),
+      byMonth: new Set(),
+      byCategory: new Set(),
+      byStatus: new Set(),
+      recurring: false
+    });
+  }
+
+  /**
+   * Add an event to a keyed index and record the reverse reference.
+   * @private
+   */
+  _addToKeyedIndex(indexName, key, eventId) {
+    const index = this.indices[indexName];
+    if (!index.has(key)) {
+      index.set(key, new Set());
     }
+
+    index.get(key).add(eventId);
+    this.eventIndexRefs.get(eventId)?.[indexName].add(key);
   }
 
   /**
@@ -841,6 +855,22 @@ export class EventStore {
    * @private
    */
   _unindexEvent(event) {
+    const refs = this.eventIndexRefs.get(event.id);
+
+    if (refs) {
+      this._removeFromReferencedIndex('byDate', refs.byDate, event.id);
+      this._removeFromReferencedIndex('byMonth', refs.byMonth, event.id);
+      this._removeFromReferencedIndex('byCategory', refs.byCategory, event.id);
+      this._removeFromReferencedIndex('byStatus', refs.byStatus, event.id);
+
+      if (refs.recurring) {
+        this.indices.recurring.delete(event.id);
+      }
+
+      this.eventIndexRefs.delete(event.id);
+      return;
+    }
+
     // Remove from date indices
     for (const [dateStr, eventIds] of this.indices.byDate) {
       eventIds.delete(event.id);
@@ -877,6 +907,24 @@ export class EventStore {
     this.indices.recurring.delete(event.id);
   }
 
+  /**
+   * Remove an event from only the keys it was indexed into.
+   * @private
+   */
+  _removeFromReferencedIndex(indexName, keys, eventId) {
+    const index = this.indices[indexName];
+
+    for (const key of keys) {
+      const eventIds = index.get(key);
+      if (!eventIds) continue;
+
+      eventIds.delete(eventId);
+      if (eventIds.size === 0) {
+        index.delete(key);
+      }
+    }
+  }
+
   /**
    * Notify listeners of changes
    * @private
@@ -938,6 +986,18 @@ export class EventStore {
             Array.from(this.indices.byStatus.entries()).map(([k, v]) => [k, new Set(v)])
           )
         },
+        eventIndexRefs: new Map(
+          Array.from(this.eventIndexRefs.entries()).map(([eventId, refs]) => [
+            eventId,
+            {
+              byDate: new Set(refs.byDate),
+              byMonth: new Set(refs.byMonth),
+              byCategory: new Set(refs.byCategory),
+              byStatus: new Set(refs.byStatus),
+              recurring: refs.recurring
+            }
+          ])
+        ),
         version: this.version
       };
     }
@@ -981,6 +1041,7 @@ export class EventStore {
     if (this.batchBackup) {
       this.events = this.batchBackup.events;
       this.indices = this.batchBackup.indices;
+      this.eventIndexRefs = this.batchBackup.eventIndexRefs;
       this.version = this.batchBackup.version;
       this.batchBackup = null;
 
@@ -1154,7 +1215,6 @@ export class EventStore {
       cutoffDate.setMonth(cutoffDate.getMonth() - 6); // Default: 6 months ago
     }
 
-    const cutoffStr = cutoffDate.toDateString();
     let removed = 0;
 
     // Clean up date indices
@@ -1172,13 +1232,15 @@ export class EventStore {
         }
 
         if (!stillNeeded) {
+          for (const eventId of eventIds) {
+            this.eventIndexRefs.get(eventId)?.byDate.delete(dateStr);
+          }
           this.indices.byDate.delete(dateStr);
           removed++;
         }
       }
     }
 
-    console.log(`Optimized indices: removed ${removed} old date entries`);
     return removed;
   }
 

package/core/index.js

@@ -28,7 +28,7 @@ export { RRuleParser } from './events/RRuleParser.js';
 export { EnhancedCalendar } from './integration/EnhancedCalendar.js';
 
 // Version — keep in sync with package.json
-export const VERSION = '2.1.64';
+export const VERSION = '2.1.66';
 
 // Default export
 export { Calendar as default } from './calendar/Calendar.js';

package/core/search/SearchWorkerManager.js

@@ -9,6 +9,8 @@ export class SearchWorkerManager {
     this.workerSupported = typeof Worker !== 'undefined';
     this.worker = null;
     this.indexReady = false;
+    this.indexMode = 'none';
+    this.workerExpectedCount = 0;
     this.pendingSearches = [];
 
     // Fallback to main thread if workers not available
@@ -19,7 +21,8 @@ export class SearchWorkerManager {
       chunkSize: 100, // Events per indexing batch
       maxWorkers: 4, // Max parallel workers
       indexThreshold: 1000, // Use workers above this event count
-      cacheSize: 50 // LRU cache for search results
+      cacheSize: 50, // LRU cache for search results
+      searchTimeout: 10000 // Worker search timeout in milliseconds
     };
 
     // Search result cache
@@ -35,7 +38,7 @@ export class SearchWorkerManager {
   initializeWorker() {
     if (!this.workerSupported) {
       // Use InvertedIndex as fallback
-      this.fallbackIndex = new InvertedIndex();
+      this.ensureFallbackIndex();
       return;
     }
 
@@ -51,13 +54,14 @@ export class SearchWorkerManager {
                     events[event.id] = event;
 
                     // Index each field
-                    const fields = ['title', 'description', 'location', 'category'];
+                    const fields = ['title', 'description', 'location', 'category', 'categories'];
                     for (const field of fields) {
                         const value = event[field];
                         if (!value) continue;
 
                         // Tokenize and index
-                        const tokens = tokenize(value.toLowerCase());
+                        const values = Array.isArray(value) ? value : [value];
+                        const tokens = values.flatMap(item => tokenize(String(item).toLowerCase()));
                         for (const token of tokens) {
                             if (!index[token]) {
                                 index[token] = new Set();
@@ -163,11 +167,19 @@ export class SearchWorkerManager {
             };
         `;
 
-    // Create worker from blob
-    const blob = new Blob([workerCode], { type: 'application/javascript' });
-    const workerUrl = URL.createObjectURL(blob);
-
+    let workerUrl = null;
     try {
+      if (
+        typeof Blob === 'undefined' ||
+        typeof URL === 'undefined' ||
+        typeof URL.createObjectURL !== 'function'
+      ) {
+        throw new Error('Blob workers are not supported in this environment');
+      }
+
+      // Create worker from blob
+      const blob = new Blob([workerCode], { type: 'application/javascript' });
+      workerUrl = URL.createObjectURL(blob);
       this.worker = new Worker(workerUrl);
       this.setupWorkerHandlers();
 
@@ -180,10 +192,24 @@ export class SearchWorkerManager {
       // Clean up blob URL
       URL.revokeObjectURL(workerUrl);
     } catch (error) {
+      if (workerUrl) {
+        URL.revokeObjectURL(workerUrl);
+      }
       console.warn('Worker creation failed, falling back to main thread:', error);
       this.workerSupported = false;
+      this.ensureFallbackIndex();
+    }
+  }
+
+  /**
+   * Ensure a fallback index exists.
+   * @private
+   */
+  ensureFallbackIndex() {
+    if (!this.fallbackIndex) {
       this.fallbackIndex = new InvertedIndex();
     }
+    return this.fallbackIndex;
   }
 
   /**
@@ -191,7 +217,7 @@ export class SearchWorkerManager {
    */
   setupWorkerHandlers() {
     this.worker.onmessage = e => {
-      const { type, data } = e.data;
+      const { type } = e.data;
 
       switch (type) {
         case 'ready':
@@ -200,8 +226,10 @@ export class SearchWorkerManager {
           break;
 
         case 'indexed':
-          // Process pending searches
-          this.processPendingSearches();
+          if (e.data.count >= this.workerExpectedCount) {
+            this.indexMode = 'worker';
+            this.processPendingSearches();
+          }
           break;
 
         case 'results':
@@ -212,9 +240,12 @@ export class SearchWorkerManager {
 
     this.worker.onerror = error => {
       console.error('Worker error:', error);
+      this.rejectPendingSearches(new Error('Search worker failed'));
       // Fallback to main thread
       this.workerSupported = false;
-      this.fallbackIndex = new InvertedIndex();
+      this.worker = null;
+      this.ensureFallbackIndex().buildIndex(this.eventStore.getAllEvents());
+      this.indexMode = 'fallback';
     };
   }
 
@@ -223,17 +254,26 @@ export class SearchWorkerManager {
    */
   async indexEvents() {
     const events = this.eventStore.getAllEvents();
+    this.searchCache.clear();
+    this.cacheOrder = [];
 
     // Use main thread for small datasets
     if (events.length < this.config.indexThreshold) {
-      if (this.fallbackIndex) {
-        this.fallbackIndex.buildIndex(events);
+      this.ensureFallbackIndex().buildIndex(events);
+      this.indexMode = 'fallback';
+
+      if (this.worker && this.indexReady) {
+        this.worker.postMessage({ type: 'clear' });
       }
       return;
     }
 
     // Chunk events for worker
     if (this.worker && this.indexReady) {
+      this.indexMode = 'worker-indexing';
+      this.workerExpectedCount = events.length;
+      this.worker.postMessage({ type: 'clear' });
+
       for (let i = 0; i < events.length; i += this.config.chunkSize) {
         const chunk = events.slice(i, i + this.config.chunkSize);
         this.worker.postMessage({
@@ -241,7 +281,11 @@ export class SearchWorkerManager {
           data: { events: chunk }
         });
       }
+      return;
     }
+
+    this.ensureFallbackIndex().buildIndex(events);
+    this.indexMode = 'fallback';
   }
 
   /**
@@ -257,9 +301,13 @@ export class SearchWorkerManager {
 
     // Use appropriate search method
     let results;
-    if (this.worker && this.indexReady) {
-      results = await this.workerSearch(query, options);
-    } else if (this.fallbackIndex) {
+    if (this.worker && this.indexMode === 'worker') {
+      try {
+        results = await this.workerSearch(query, options);
+      } catch {
+        results = this.directSearch(query, options);
+      }
+    } else if (this.fallbackIndex && this.indexMode === 'fallback') {
       results = this.fallbackIndex.search(query, options);
     } else {
       // Direct search as last resort
@@ -276,14 +324,20 @@ export class SearchWorkerManager {
    * Search using worker
    */
   workerSearch(query, options) {
-    return new Promise(resolve => {
+    return new Promise((resolve, reject) => {
       const searchId = Date.now() + Math.random();
+      const timeoutId = setTimeout(() => {
+        this.pendingSearches = this.pendingSearches.filter(search => search.id !== searchId);
+        reject(new Error('Search worker timed out'));
+      }, options.timeout || this.config.searchTimeout);
 
       this.pendingSearches.push({
         id: searchId,
         query,
         options,
-        resolve
+        resolve,
+        reject,
+        timeoutId
       });
 
       this.worker.postMessage({
@@ -309,14 +363,23 @@ export class SearchWorkerManager {
       let score = 0;
 
       // Check each field
-      const fields = options.fields || ['title', 'description', 'location'];
+      const fields = options.fields || [
+        'title',
+        'description',
+        'location',
+        'category',
+        'categories'
+      ];
       for (const field of fields) {
         const value = event[field];
         if (!value) continue;
 
-        const valueLower = value.toLowerCase();
-        if (valueLower.includes(queryLower)) {
-          score += field === 'title' ? 20 : 10;
+        const values = Array.isArray(value) ? value : [value];
+        for (const item of values) {
+          const valueLower = String(item).toLowerCase();
+          if (valueLower.includes(queryLower)) {
+            score += field === 'title' ? 20 : 10;
+          }
         }
       }
 
@@ -340,6 +403,7 @@ export class SearchWorkerManager {
   handleSearchResults(data) {
     const pending = this.pendingSearches.find(s => s.id === data.id);
     if (pending) {
+      clearTimeout(pending.timeoutId);
       pending.resolve(data.results);
       this.pendingSearches = this.pendingSearches.filter(s => s.id !== data.id);
     }
@@ -366,6 +430,10 @@ export class SearchWorkerManager {
    * Cache search results with LRU eviction
    */
   cacheResults(key, results) {
+    if (this.searchCache.has(key)) {
+      this.cacheOrder = this.cacheOrder.filter(existingKey => existingKey !== key);
+    }
+
     // Add to cache
     this.searchCache.set(key, results);
     this.cacheOrder.push(key);
@@ -383,6 +451,9 @@ export class SearchWorkerManager {
   clear() {
     this.searchCache.clear();
     this.cacheOrder = [];
+    this.indexMode = 'none';
+    this.workerExpectedCount = 0;
+    this.rejectPendingSearches(new Error('Search index was cleared'));
 
     if (this.worker) {
       this.worker.postMessage({ type: 'clear' });
@@ -402,6 +473,18 @@ export class SearchWorkerManager {
     }
     this.clear();
   }
+
+  /**
+   * Reject all pending worker searches.
+   * @private
+   */
+  rejectPendingSearches(error) {
+    for (const search of this.pendingSearches) {
+      clearTimeout(search.timeoutId);
+      search.reject(error);
+    }
+    this.pendingSearches = [];
+  }
 }
 
 /**
@@ -416,7 +499,8 @@ export class InvertedIndex {
       title: 2.0,
       description: 1.0,
       location: 1.5,
-      category: 1.5
+      category: 1.5,
+      categories: 1.5
     };
   }
 
@@ -434,7 +518,8 @@ export class InvertedIndex {
         const value = event[field];
         if (!value) continue;
 
-        const tokens = this.tokenize(value);
+        const values = Array.isArray(value) ? value : [value];
+        const tokens = values.flatMap(item => this.tokenize(String(item)));
         for (const token of tokens) {
           if (!this.index.has(token)) {
             this.index.set(token, new Map());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forcecalendar/core",
-  "version": "2.1.64",
+  "version": "2.1.66",
   "type": "module",
   "private": false,
   "description": "A modern, lightweight, framework-agnostic calendar engine optimized for Salesforce",