@forcecalendar/core 1.1.0 → 2.0.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) {

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)
+    let 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

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/package.json

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