@forcecalendar/core 1.1.0 → 2.1.0

package/core/events/Event.js

@@ -15,11 +15,11 @@ export class Event {
   static normalize(data) {
     const normalized = { ...data };
 
-    // Ensure dates are Date objects
-    if (normalized.start && !(normalized.start instanceof Date)) {
+    // Always clone Date objects to avoid mutating caller's data
+    if (normalized.start) {
       normalized.start = new Date(normalized.start);
     }
-    if (normalized.end && !(normalized.end instanceof Date)) {
+    if (normalized.end) {
       normalized.end = new Date(normalized.end);
     }
 
@@ -29,6 +29,7 @@ export class Event {
     }
 
     // For all-day events, normalize times to midnight
+    // (safe to mutate now since we cloned above)
     if (normalized.allDay && normalized.start) {
       normalized.start.setHours(0, 0, 0, 0);
       if (normalized.end) {
@@ -373,7 +374,7 @@ export class Event {
    * @returns {boolean} True if event spans multiple days
    */
   get isMultiDay() {
-    if (!this._cache.hasOwnProperty('isMultiDay')) {
+    if (!Object.prototype.hasOwnProperty.call(this._cache, 'isMultiDay')) {
       const startDay = this.start.toDateString();
       const endDay = this.end.toDateString();
       this._cache.isMultiDay = startDay !== endDay;
@@ -416,10 +417,10 @@ export class Event {
       dayEnd.setHours(23, 59, 59, 999);
 
       return this.start <= dayEnd && this.end >= dayStart;
-    } else {
+    } 
       // Single day event: check if it's on the same day
       return startString === dateString;
-    }
+    
   }
 
   /**
@@ -435,9 +436,9 @@ export class Event {
     } else if (otherEvent && otherEvent.start && otherEvent.end) {
       // Allow checking against time ranges
       return !(this.end <= otherEvent.start || this.start >= otherEvent.end);
-    } else {
+    } 
       throw new Error('Parameter must be an Event instance or have start/end properties');
-    }
+    
   }
 
   /**

package/core/events/EventStore.js

@@ -226,12 +226,12 @@ export class EventStore {
     }
 
     // Filter by all-day events
-    if (filters.hasOwnProperty('allDay')) {
+    if (Object.prototype.hasOwnProperty.call(filters, 'allDay')) {
       results = results.filter(event => event.allDay === filters.allDay);
     }
 
     // Filter by recurring
-    if (filters.hasOwnProperty('recurring')) {
+    if (Object.prototype.hasOwnProperty.call(filters, 'recurring')) {
       results = results.filter(event => event.recurring === filters.recurring);
     }
 
@@ -250,7 +250,7 @@ export class EventStore {
     }
 
     // Filter by having attendees
-    if (filters.hasOwnProperty('hasAttendees')) {
+    if (Object.prototype.hasOwnProperty.call(filters, 'hasAttendees')) {
       results = results.filter(event => filters.hasAttendees ? event.hasAttendees : !event.hasAttendees);
     }
 

package/core/events/RRuleParser.js

@@ -265,6 +265,11 @@ export class RRuleParser {
         // By* rules
         if (rule.byDay && rule.byDay.length > 0) {
             const dayStr = rule.byDay.map(d => {
+                // Handle both string format ('MO', '2TU', '-1FR') from parseByDay
+                // and object format ({nth: 2, weekday: 'MO'})
+                if (typeof d === 'string') {
+                    return d;
+                }
                 return d.nth ? `${d.nth}${d.weekday}` : d.weekday;
             }).join(',');
             parts.push(`BYDAY=${dayStr}`);
@@ -374,17 +379,30 @@ export class RRuleParser {
             description += 's';
         }
 
-        // By day
+        // By day - handle both string format ('MO', '2TU') and object format ({nth, weekday})
         if (rule.byDay && rule.byDay.length > 0) {
+            // Helper to extract weekday and nth from string or object
+            const parseDay = (d) => {
+                if (typeof d === 'string') {
+                    const match = d.match(/^(-?\d+)?([A-Z]{2})$/);
+                    if (match) {
+                        return { nth: match[1] ? parseInt(match[1], 10) : null, weekday: match[2] };
+                    }
+                    return { nth: null, weekday: d };
+                }
+                return d;
+            };
+
             if (rule.freq === 'WEEKLY') {
-                const days = rule.byDay.map(d => weekdayMap[d.weekday]).join(', ');
+                const days = rule.byDay.map(d => weekdayMap[parseDay(d).weekday]).join(', ');
                 description += ` on ${days}`;
             } else if (rule.freq === 'MONTHLY' || rule.freq === 'YEARLY') {
                 const dayDescs = rule.byDay.map(d => {
-                    if (d.nth) {
-                        return `the ${nthMap[d.nth] || d.nth} ${weekdayMap[d.weekday]}`;
+                    const parsed = parseDay(d);
+                    if (parsed.nth) {
+                        return `the ${nthMap[parsed.nth] || parsed.nth} ${weekdayMap[parsed.weekday]}`;
                     }
-                    return weekdayMap[d.weekday];
+                    return weekdayMap[parsed.weekday];
                 }).join(', ');
                 description += ` on ${dayDescs}`;
             }

package/core/events/RecurrenceEngine.js

@@ -39,6 +39,11 @@ export class RecurrenceEngine {
     // Track DST transitions for proper timezone handling
     let lastOffset = tzManager.getTimezoneOffset(currentDate, eventTimezone);
 
+    // Track last date to detect infinite loop (date not advancing)
+    const lastDateTimestamp = null;
+    let stuckCount = 0;
+    const maxStuckIterations = 3;
+
     while (currentDate <= rangeEnd && count < maxOccurrences) {
       // Check if this occurrence is within the range
       if (currentDate >= rangeStart) {
@@ -68,9 +73,21 @@ export class RecurrenceEngine {
       }
 
       // Calculate next occurrence
+      const previousTimestamp = currentDate.getTime();
       currentDate = this.getNextOccurrence(currentDate, rule, eventTimezone);
       count++;
 
+      // Safeguard: detect if date is not advancing (infinite loop risk)
+      if (currentDate.getTime() === previousTimestamp) {
+        stuckCount++;
+        if (stuckCount >= maxStuckIterations) {
+          console.warn('RecurrenceEngine: Date not advancing, breaking to prevent infinite loop');
+          break;
+        }
+      } else {
+        stuckCount = 0;
+      }
+
       // Check COUNT limit
       if (rule.count && count >= rule.count) {
         break;
@@ -111,15 +128,17 @@ export class RecurrenceEngine {
           // Limit iterations to prevent infinite loop with malformed byDay
           const maxIterations = 8; // 7 days + 1 for safety
           let iterations = 0;
+          const originalDate = next.getDate();
           next.setDate(next.getDate() + 1);
           while (!this.matchesByDay(next, rule.byDay) && iterations < maxIterations) {
             next.setDate(next.getDate() + 1);
             iterations++;
           }
-          // If no match found, fall back to simple weekly interval
+          // If no match found, fall back to simple weekly interval from original date
           if (iterations >= maxIterations) {
             console.warn('RecurrenceEngine: Invalid byDay rule, falling back to weekly interval');
-            next.setDate(next.getDate() + (7 * rule.interval) - maxIterations);
+            // Reset to original and add weekly interval
+            next.setDate(originalDate + (7 * rule.interval));
           }
         } else {
           // Simple weekly recurrence
@@ -248,11 +267,11 @@ export class RecurrenceEngine {
           return Math.abs(exceptionDate.getTime() - dateTime) < 1000; // Within 1 second
         }
         return exceptionDate.toDateString() === dateStr;
-      } else {
+      } 
         // Simple date exception
         const exceptionDate = exDate instanceof Date ? exDate : new Date(exDate);
         return exceptionDate.toDateString() === dateStr;
-      }
+      
     });
   }
 
@@ -308,9 +327,9 @@ export class RecurrenceEngine {
 
       if (dateStr.endsWith('Z')) {
         return new Date(Date.UTC(year, month, day, hour, minute, second));
-      } else {
+      } 
         return new Date(year, month, day, hour, minute, second);
-      }
+      
     }
 
     // Fallback to standard date parsing

package/core/events/RecurrenceEngineV2.js

@@ -609,7 +609,7 @@ export class RecurrenceEngineV2 {
      */
     clearEventCache(eventId) {
         for (const key of this.occurrenceCache.keys()) {
-            if (key.startsWith(eventId + '_')) {
+            if (key.startsWith(`${eventId  }_`)) {
                 this.occurrenceCache.delete(key);
             }
         }

package/core/ics/ICSParser.js

@@ -39,7 +39,7 @@ export class ICSParser {
         let inEvent = false;
         let inAlarm = false;
 
-        for (let line of lines) {
+        for (const line of lines) {
             // Skip empty lines
             if (!line.trim()) continue;
 
@@ -248,7 +248,7 @@ export class ICSParser {
                 event.category = value.split(',')[0]; // Take first category
                 break;
 
-            case 'STATUS':
+            case 'STATUS': {
                 const statusMap = {
                     'TENTATIVE': 'tentative',
                     'CONFIRMED': 'confirmed',
@@ -256,6 +256,7 @@ export class ICSParser {
                 };
                 event.status = statusMap[value] || 'confirmed';
                 break;
+            }
 
             case 'TRANSP':
                 event.showAs = value === 'TRANSPARENT' ? 'free' : 'busy';
@@ -265,7 +266,7 @@ export class ICSParser {
                 event.organizer = value.replace('mailto:', '');
                 break;
 
-            case 'ATTENDEE':
+            case 'ATTENDEE': {
                 if (!event.attendees) event.attendees = [];
                 const email = value.replace('mailto:', '');
                 event.attendees.push({
@@ -273,6 +274,7 @@ export class ICSParser {
                     name: email.split('@')[0] // Use email prefix as name
                 });
                 break;
+            }
 
             case 'RRULE':
                 event.recurrence = value;
@@ -308,10 +310,10 @@ export class ICSParser {
         if (dateString.endsWith('Z')) {
             // UTC time
             return new Date(Date.UTC(year, month, day, hour, minute, second));
-        } else {
+        } 
             // Local time
             return new Date(year, month, day, hour, minute, second);
-        }
+        
     }
 
     /**
@@ -365,7 +367,7 @@ export class ICSParser {
             // Continuation lines (with space prefix)
             while (remaining.length > 0) {
                 const chunk = remaining.substr(0, this.maxLineLength - 1);
-                folded.push(' ' + chunk);
+                folded.push(` ${  chunk}`);
                 remaining = remaining.substr(chunk.length);
             }
 

package/core/search/EventSearch.js

@@ -288,7 +288,7 @@ export class EventSearch {
         const events = this.eventStore.getAllEvents();
 
         for (const event of events) {
-            const value = event[field] || (includeEmpty ? '(No ' + field + ')' : null);
+            const value = event[field] || (includeEmpty ? `(No ${  field  })` : null);
             if (value === null) continue;
 
             if (!groups.has(value)) {

package/core/state/StateManager.js

@@ -505,8 +505,10 @@ export class StateManager {
       this.history = this.history.slice(0, this.historyIndex + 1);
     }
 
-    // Add new state
-    this.history.push({ ...state });
+    // Deep clone state to prevent shared references in history
+    // (shallow copy would share nested objects like filters, businessHours, metadata)
+    const clonedState = this._deepClone(state);
+    this.history.push(clonedState);
     this.historyIndex++;
 
     // Limit history size
@@ -516,6 +518,32 @@ export class StateManager {
     }
   }
 
+  /**
+   * Deep clone a value for history storage
+   * @private
+   */
+  _deepClone(value) {
+    if (value === null || typeof value !== 'object') {
+      return value;
+    }
+
+    if (value instanceof Date) {
+      return new Date(value);
+    }
+
+    if (Array.isArray(value)) {
+      return value.map(item => this._deepClone(item));
+    }
+
+    const cloned = {};
+    for (const key in value) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) {
+        cloned[key] = this._deepClone(value[key]);
+      }
+    }
+    return cloned;
+  }
+
   /**
    * Notify listeners of state changes
    * @private

package/core/timezone/TimezoneManager.js

@@ -343,13 +343,13 @@ export class TimezoneManager {
         if (!tzString) return 'UTC';
 
         // Check if it's already an IANA identifier
-        if (this.database.timezones.hasOwnProperty(tzString)) {
+        if (Object.prototype.hasOwnProperty.call(this.database.timezones, tzString)) {
             return tzString;
         }
 
         // Check abbreviations
         const upperTz = tzString.toUpperCase();
-        if (this.database.abbreviations && this.database.abbreviations.hasOwnProperty(upperTz)) {
+        if (this.database.abbreviations && Object.prototype.hasOwnProperty.call(this.database.abbreviations, upperTz)) {
             return this.database.abbreviations[upperTz];
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forcecalendar/core",
-  "version": "1.1.0",
+  "version": "2.1.0",
   "type": "module",
   "private": false,
   "description": "A modern, lightweight, framework-agnostic calendar engine optimized for Salesforce",
@@ -11,7 +11,12 @@
   "scripts": {
     "test": "node tests/run-all.js",
     "test:ics": "node tests/integration/test-ics.js",
-    "test:search": "node tests/integration/test-search.js"
+    "test:search": "node tests/integration/test-search.js",
+    "lint": "eslint core/ --ext .js",
+    "lint:fix": "eslint core/ --ext .js --fix",
+    "format": "prettier --write \"core/**/*.js\"",
+    "format:check": "prettier --check \"core/**/*.js\"",
+    "quality": "npm run lint && npm run format:check"
   },
   "exports": {
     ".": "./core/index.js",