@forcecalendar/core 2.1.0 → 2.1.2

package/core/events/RRuleParser.js

@@ -4,436 +4,465 @@
  */
 
 export class RRuleParser {
-    /**
-     * Parse an RRULE string into a structured rule object
-     * @param {string|Object} rrule - RRULE string or rule object
-     * @returns {Object} Parsed rule object
-     */
-    static parse(rrule) {
-        // If already an object, validate and return
-        if (typeof rrule === 'object') {
-            return this.validateRule(rrule);
-        }
-
-        const rule = {
-            freq: null,
-            interval: 1,
-            count: null,
-            until: null,
-            byDay: [],
-            byWeekNo: [],
-            byMonth: [],
-            byMonthDay: [],
-            byYearDay: [],
-            bySetPos: [],
-            byHour: [],
-            byMinute: [],
-            bySecond: [],
-            wkst: 'MO', // Week start day
-            exceptions: [],
-            tzid: null
-        };
-
-        // Parse RRULE string
-        const parts = rrule.toUpperCase().split(';');
-
-        for (const part of parts) {
-            const [key, value] = part.split('=');
-
-            switch (key) {
-                case 'FREQ':
-                    rule.freq = this.parseFrequency(value);
-                    break;
-
-                case 'INTERVAL':
-                    rule.interval = parseInt(value, 10);
-                    if (rule.interval < 1) rule.interval = 1;
-                    break;
-
-                case 'COUNT':
-                    rule.count = parseInt(value, 10);
-                    break;
-
-                case 'UNTIL':
-                    rule.until = this.parseDateTime(value);
-                    break;
-
-                case 'BYDAY':
-                    rule.byDay = this.parseByDay(value);
-                    break;
-
-                case 'BYWEEKNO':
-                    rule.byWeekNo = this.parseIntList(value);
-                    break;
-
-                case 'BYMONTH':
-                    rule.byMonth = this.parseIntList(value);
-                    break;
-
-                case 'BYMONTHDAY':
-                    rule.byMonthDay = this.parseIntList(value);
-                    break;
-
-                case 'BYYEARDAY':
-                    rule.byYearDay = this.parseIntList(value);
-                    break;
-
-                case 'BYSETPOS':
-                    rule.bySetPos = this.parseIntList(value);
-                    break;
-
-                case 'BYHOUR':
-                    rule.byHour = this.parseIntList(value);
-                    break;
-
-                case 'BYMINUTE':
-                    rule.byMinute = this.parseIntList(value);
-                    break;
-
-                case 'BYSECOND':
-                    rule.bySecond = this.parseIntList(value);
-                    break;
-
-                case 'WKST':
-                    rule.wkst = value;
-                    break;
-
-                case 'EXDATE':
-                    rule.exceptions = this.parseExceptionDates(value);
-                    break;
-
-                case 'TZID':
-                    rule.tzid = value;
-                    break;
-            }
-        }
-
-        return this.validateRule(rule);
+  /**
+   * Parse an RRULE string into a structured rule object
+   * @param {string|Object} rrule - RRULE string or rule object
+   * @returns {Object} Parsed rule object
+   */
+  static parse(rrule) {
+    // If already an object, validate and return
+    if (typeof rrule === 'object') {
+      return this.validateRule(rrule);
     }
 
-    /**
-     * Parse frequency value
-     * @private
-     */
-    static parseFrequency(freq) {
-        const validFrequencies = ['SECONDLY', 'MINUTELY', 'HOURLY', 'DAILY', 'WEEKLY', 'MONTHLY', 'YEARLY'];
-        return validFrequencies.includes(freq) ? freq : 'DAILY';
+    const rule = {
+      freq: null,
+      interval: 1,
+      count: null,
+      until: null,
+      byDay: [],
+      byWeekNo: [],
+      byMonth: [],
+      byMonthDay: [],
+      byYearDay: [],
+      bySetPos: [],
+      byHour: [],
+      byMinute: [],
+      bySecond: [],
+      wkst: 'MO', // Week start day
+      exceptions: [],
+      tzid: null
+    };
+
+    // Parse RRULE string
+    const parts = rrule.toUpperCase().split(';');
+
+    for (const part of parts) {
+      const [key, value] = part.split('=');
+
+      switch (key) {
+        case 'FREQ':
+          rule.freq = this.parseFrequency(value);
+          break;
+
+        case 'INTERVAL':
+          rule.interval = parseInt(value, 10);
+          if (rule.interval < 1) rule.interval = 1;
+          break;
+
+        case 'COUNT':
+          rule.count = parseInt(value, 10);
+          break;
+
+        case 'UNTIL':
+          rule.until = this.parseDateTime(value);
+          break;
+
+        case 'BYDAY':
+          rule.byDay = this.parseByDay(value);
+          break;
+
+        case 'BYWEEKNO':
+          rule.byWeekNo = this.parseIntList(value);
+          break;
+
+        case 'BYMONTH':
+          rule.byMonth = this.parseIntList(value);
+          break;
+
+        case 'BYMONTHDAY':
+          rule.byMonthDay = this.parseIntList(value);
+          break;
+
+        case 'BYYEARDAY':
+          rule.byYearDay = this.parseIntList(value);
+          break;
+
+        case 'BYSETPOS':
+          rule.bySetPos = this.parseIntList(value);
+          break;
+
+        case 'BYHOUR':
+          rule.byHour = this.parseIntList(value);
+          break;
+
+        case 'BYMINUTE':
+          rule.byMinute = this.parseIntList(value);
+          break;
+
+        case 'BYSECOND':
+          rule.bySecond = this.parseIntList(value);
+          break;
+
+        case 'WKST':
+          rule.wkst = value;
+          break;
+
+        case 'EXDATE':
+          rule.exceptions = this.parseExceptionDates(value);
+          break;
+
+        case 'TZID':
+          rule.tzid = value;
+          break;
+      }
     }
 
-    /**
-     * Parse BYDAY value
-     * Returns array of strings like ['MO', '2TU', '-1FR'] for compatibility with RecurrenceEngine
-     * @private
-     */
-    static parseByDay(value) {
-        const days = value.split(',');
-        const weekDays = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
-        const result = [];
-
-        for (const day of days) {
-            const trimmed = day.trim().toUpperCase();
-            const match = trimmed.match(/^([+-]?\d*)([A-Z]{2})$/);
-            if (match) {
-                const [_, nth, weekday] = match;
-                if (weekDays.includes(weekday)) {
-                    // Return string format for RecurrenceEngine compatibility
-                    // e.g., 'MO', '2MO', '-1FR'
-                    result.push(nth ? `${nth}${weekday}` : weekday);
-                }
-            }
+    return this.validateRule(rule);
+  }
+
+  /**
+   * Parse frequency value
+   * @private
+   */
+  static parseFrequency(freq) {
+    const validFrequencies = [
+      'SECONDLY',
+      'MINUTELY',
+      'HOURLY',
+      'DAILY',
+      'WEEKLY',
+      'MONTHLY',
+      'YEARLY'
+    ];
+    return validFrequencies.includes(freq) ? freq : 'DAILY';
+  }
+
+  /**
+   * Parse BYDAY value
+   * Returns array of strings like ['MO', '2TU', '-1FR'] for compatibility with RecurrenceEngine
+   * @private
+   */
+  static parseByDay(value) {
+    const days = value.split(',');
+    const weekDays = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
+    const result = [];
+
+    for (const day of days) {
+      const trimmed = day.trim().toUpperCase();
+      const match = trimmed.match(/^([+-]?\d*)([A-Z]{2})$/);
+      if (match) {
+        const [_, nth, weekday] = match;
+        if (weekDays.includes(weekday)) {
+          // Return string format for RecurrenceEngine compatibility
+          // e.g., 'MO', '2MO', '-1FR'
+          result.push(nth ? `${nth}${weekday}` : weekday);
         }
-
-        return result;
+      }
     }
 
-    /**
-     * Parse comma-separated integer list
-     * @private
-     */
-    static parseIntList(value) {
-        return value.split(',').map(v => parseInt(v.trim(), 10)).filter(v => !isNaN(v));
+    return result;
+  }
+
+  /**
+   * Parse comma-separated integer list
+   * @private
+   */
+  static parseIntList(value) {
+    return value
+      .split(',')
+      .map(v => parseInt(v.trim(), 10))
+      .filter(v => !isNaN(v));
+  }
+
+  /**
+   * Parse date/datetime value
+   * @private
+   */
+  static parseDateTime(value) {
+    // Handle different date formats
+    // YYYYMMDD
+    if (value.length === 8) {
+      const year = parseInt(value.substr(0, 4), 10);
+      const month = parseInt(value.substr(4, 2), 10) - 1;
+      const day = parseInt(value.substr(6, 2), 10);
+      return new Date(year, month, day);
     }
 
-    /**
-     * Parse date/datetime value
-     * @private
-     */
-    static parseDateTime(value) {
-        // Handle different date formats
-        // YYYYMMDD
-        if (value.length === 8) {
-            const year = parseInt(value.substr(0, 4), 10);
-            const month = parseInt(value.substr(4, 2), 10) - 1;
-            const day = parseInt(value.substr(6, 2), 10);
-            return new Date(year, month, day);
-        }
-
-        // YYYYMMDDTHHMMSS
-        if (value.length === 15 && value[8] === 'T') {
-            const year = parseInt(value.substr(0, 4), 10);
-            const month = parseInt(value.substr(4, 2), 10) - 1;
-            const day = parseInt(value.substr(6, 2), 10);
-            const hour = parseInt(value.substr(9, 2), 10);
-            const minute = parseInt(value.substr(11, 2), 10);
-            const second = parseInt(value.substr(13, 2), 10);
-            return new Date(year, month, day, hour, minute, second);
-        }
-
-        // YYYYMMDDTHHMMSSZ (UTC)
-        if (value.length === 16 && value[8] === 'T' && value[15] === 'Z') {
-            const year = parseInt(value.substr(0, 4), 10);
-            const month = parseInt(value.substr(4, 2), 10) - 1;
-            const day = parseInt(value.substr(6, 2), 10);
-            const hour = parseInt(value.substr(9, 2), 10);
-            const minute = parseInt(value.substr(11, 2), 10);
-            const second = parseInt(value.substr(13, 2), 10);
-            return new Date(Date.UTC(year, month, day, hour, minute, second));
-        }
-
-        // Try standard date parse as fallback
-        return new Date(value);
+    // YYYYMMDDTHHMMSS
+    if (value.length === 15 && value[8] === 'T') {
+      const year = parseInt(value.substr(0, 4), 10);
+      const month = parseInt(value.substr(4, 2), 10) - 1;
+      const day = parseInt(value.substr(6, 2), 10);
+      const hour = parseInt(value.substr(9, 2), 10);
+      const minute = parseInt(value.substr(11, 2), 10);
+      const second = parseInt(value.substr(13, 2), 10);
+      return new Date(year, month, day, hour, minute, second);
     }
 
-    /**
-     * Parse exception dates
-     * @private
-     */
-    static parseExceptionDates(value) {
-        const dates = value.split(',');
-        return dates.map(date => this.parseDateTime(date.trim()));
+    // YYYYMMDDTHHMMSSZ (UTC)
+    if (value.length === 16 && value[8] === 'T' && value[15] === 'Z') {
+      const year = parseInt(value.substr(0, 4), 10);
+      const month = parseInt(value.substr(4, 2), 10) - 1;
+      const day = parseInt(value.substr(6, 2), 10);
+      const hour = parseInt(value.substr(9, 2), 10);
+      const minute = parseInt(value.substr(11, 2), 10);
+      const second = parseInt(value.substr(13, 2), 10);
+      return new Date(Date.UTC(year, month, day, hour, minute, second));
     }
 
-    /**
-     * Validate and normalize rule
-     * @private
-     */
-    static validateRule(rule) {
-        // Ensure frequency is set
-        if (!rule.freq) {
-            rule.freq = 'DAILY';
-        }
-
-        // Cannot have both COUNT and UNTIL
-        if (rule.count && rule.until) {
-            throw new Error('RRULE cannot have both COUNT and UNTIL');
-        }
-
-        // Validate interval
-        if (rule.interval < 1) {
-            rule.interval = 1;
-        }
-
-        // Validate by* arrays
-        const validateArray = (arr, min, max) => {
-            return arr.filter(v => v >= min && v <= max);
-        };
-
-        rule.byMonth = validateArray(rule.byMonth || [], 1, 12);
-        rule.byMonthDay = validateArray(rule.byMonthDay || [], -31, 31).filter(v => v !== 0);
-        rule.byYearDay = validateArray(rule.byYearDay || [], -366, 366).filter(v => v !== 0);
-        rule.byWeekNo = validateArray(rule.byWeekNo || [], -53, 53).filter(v => v !== 0);
-        rule.byHour = validateArray(rule.byHour || [], 0, 23);
-        rule.byMinute = validateArray(rule.byMinute || [], 0, 59);
-        rule.bySecond = validateArray(rule.bySecond || [], 0, 59);
-
-        return rule;
+    // Try standard date parse as fallback
+    return new Date(value);
+  }
+
+  /**
+   * Parse exception dates
+   * @private
+   */
+  static parseExceptionDates(value) {
+    const dates = value.split(',');
+    return dates.map(date => this.parseDateTime(date.trim()));
+  }
+
+  /**
+   * Validate and normalize rule
+   * @private
+   */
+  static validateRule(rule) {
+    // Ensure frequency is set
+    if (!rule.freq) {
+      rule.freq = 'DAILY';
     }
 
-    /**
-     * Build RRULE string from rule object
-     * @param {Object} rule - Rule object
-     * @returns {string} RRULE string
-     */
-    static buildRRule(rule) {
-        const parts = [];
-
-        // Required frequency
-        parts.push(`FREQ=${rule.freq}`);
+    // Cannot have both COUNT and UNTIL
+    if (rule.count && rule.until) {
+      throw new Error('RRULE cannot have both COUNT and UNTIL');
+    }
 
-        // Optional interval
-        if (rule.interval && rule.interval > 1) {
-            parts.push(`INTERVAL=${rule.interval}`);
-        }
+    // Validate interval
+    if (rule.interval < 1) {
+      rule.interval = 1;
+    }
 
-        // Count or until
-        if (rule.count) {
-            parts.push(`COUNT=${rule.count}`);
-        } else if (rule.until) {
-            parts.push(`UNTIL=${this.formatDateTime(rule.until)}`);
-        }
+    // Validate by* arrays
+    const validateArray = (arr, min, max) => {
+      return arr.filter(v => v >= min && v <= max);
+    };
+
+    rule.byMonth = validateArray(rule.byMonth || [], 1, 12);
+    rule.byMonthDay = validateArray(rule.byMonthDay || [], -31, 31).filter(v => v !== 0);
+    rule.byYearDay = validateArray(rule.byYearDay || [], -366, 366).filter(v => v !== 0);
+    rule.byWeekNo = validateArray(rule.byWeekNo || [], -53, 53).filter(v => v !== 0);
+    rule.byHour = validateArray(rule.byHour || [], 0, 23);
+    rule.byMinute = validateArray(rule.byMinute || [], 0, 59);
+    rule.bySecond = validateArray(rule.bySecond || [], 0, 59);
+
+    return rule;
+  }
+
+  /**
+   * Build RRULE string from rule object
+   * @param {Object} rule - Rule object
+   * @returns {string} RRULE string
+   */
+  static buildRRule(rule) {
+    const parts = [];
+
+    // Required frequency
+    parts.push(`FREQ=${rule.freq}`);
+
+    // Optional interval
+    if (rule.interval && rule.interval > 1) {
+      parts.push(`INTERVAL=${rule.interval}`);
+    }
 
-        // 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}`);
-        }
+    // Count or until
+    if (rule.count) {
+      parts.push(`COUNT=${rule.count}`);
+    } else if (rule.until) {
+      parts.push(`UNTIL=${this.formatDateTime(rule.until)}`);
+    }
 
-        if (rule.byMonth && rule.byMonth.length > 0) {
-            parts.push(`BYMONTH=${rule.byMonth.join(',')}`);
-        }
+    // 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}`);
+    }
 
-        if (rule.byMonthDay && rule.byMonthDay.length > 0) {
-            parts.push(`BYMONTHDAY=${rule.byMonthDay.join(',')}`);
-        }
+    if (rule.byMonth && rule.byMonth.length > 0) {
+      parts.push(`BYMONTH=${rule.byMonth.join(',')}`);
+    }
 
-        if (rule.byYearDay && rule.byYearDay.length > 0) {
-            parts.push(`BYYEARDAY=${rule.byYearDay.join(',')}`);
-        }
+    if (rule.byMonthDay && rule.byMonthDay.length > 0) {
+      parts.push(`BYMONTHDAY=${rule.byMonthDay.join(',')}`);
+    }
 
-        if (rule.byWeekNo && rule.byWeekNo.length > 0) {
-            parts.push(`BYWEEKNO=${rule.byWeekNo.join(',')}`);
-        }
+    if (rule.byYearDay && rule.byYearDay.length > 0) {
+      parts.push(`BYYEARDAY=${rule.byYearDay.join(',')}`);
+    }
 
-        if (rule.bySetPos && rule.bySetPos.length > 0) {
-            parts.push(`BYSETPOS=${rule.bySetPos.join(',')}`);
-        }
+    if (rule.byWeekNo && rule.byWeekNo.length > 0) {
+      parts.push(`BYWEEKNO=${rule.byWeekNo.join(',')}`);
+    }
 
-        if (rule.byHour && rule.byHour.length > 0) {
-            parts.push(`BYHOUR=${rule.byHour.join(',')}`);
-        }
+    if (rule.bySetPos && rule.bySetPos.length > 0) {
+      parts.push(`BYSETPOS=${rule.bySetPos.join(',')}`);
+    }
 
-        if (rule.byMinute && rule.byMinute.length > 0) {
-            parts.push(`BYMINUTE=${rule.byMinute.join(',')}`);
-        }
+    if (rule.byHour && rule.byHour.length > 0) {
+      parts.push(`BYHOUR=${rule.byHour.join(',')}`);
+    }
 
-        if (rule.bySecond && rule.bySecond.length > 0) {
-            parts.push(`BYSECOND=${rule.bySecond.join(',')}`);
-        }
+    if (rule.byMinute && rule.byMinute.length > 0) {
+      parts.push(`BYMINUTE=${rule.byMinute.join(',')}`);
+    }
 
-        // Week start
-        if (rule.wkst && rule.wkst !== 'MO') {
-            parts.push(`WKST=${rule.wkst}`);
-        }
+    if (rule.bySecond && rule.bySecond.length > 0) {
+      parts.push(`BYSECOND=${rule.bySecond.join(',')}`);
+    }
 
-        return parts.join(';');
+    // Week start
+    if (rule.wkst && rule.wkst !== 'MO') {
+      parts.push(`WKST=${rule.wkst}`);
     }
 
-    /**
-     * Format date/datetime for RRULE
-     * @private
-     */
-    static formatDateTime(date) {
-        const year = date.getUTCFullYear();
-        const month = String(date.getUTCMonth() + 1).padStart(2, '0');
-        const day = String(date.getUTCDate()).padStart(2, '0');
-        const hour = String(date.getUTCHours()).padStart(2, '0');
-        const minute = String(date.getUTCMinutes()).padStart(2, '0');
-        const second = String(date.getUTCSeconds()).padStart(2, '0');
-
-        return `${year}${month}${day}T${hour}${minute}${second}Z`;
+    return parts.join(';');
+  }
+
+  /**
+   * Format date/datetime for RRULE
+   * @private
+   */
+  static formatDateTime(date) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    const hour = String(date.getUTCHours()).padStart(2, '0');
+    const minute = String(date.getUTCMinutes()).padStart(2, '0');
+    const second = String(date.getUTCSeconds()).padStart(2, '0');
+
+    return `${year}${month}${day}T${hour}${minute}${second}Z`;
+  }
+
+  /**
+   * Get human-readable description of rule
+   * @param {Object} rule - Parsed rule object
+   * @returns {string} Human-readable description
+   */
+  static getDescription(rule) {
+    const freqMap = {
+      SECONDLY: 'second',
+      MINUTELY: 'minute',
+      HOURLY: 'hour',
+      DAILY: 'day',
+      WEEKLY: 'week',
+      MONTHLY: 'month',
+      YEARLY: 'year'
+    };
+
+    const weekdayMap = {
+      SU: 'Sunday',
+      MO: 'Monday',
+      TU: 'Tuesday',
+      WE: 'Wednesday',
+      TH: 'Thursday',
+      FR: 'Friday',
+      SA: 'Saturday'
+    };
+
+    const nthMap = {
+      1: 'first',
+      2: 'second',
+      3: 'third',
+      4: 'fourth',
+      5: 'fifth',
+      '-1': 'last',
+      '-2': 'second to last'
+    };
+
+    let description = 'Every';
+
+    // Interval
+    if (rule.interval > 1) {
+      description += ` ${rule.interval}`;
     }
 
-    /**
-     * Get human-readable description of rule
-     * @param {Object} rule - Parsed rule object
-     * @returns {string} Human-readable description
-     */
-    static getDescription(rule) {
-        const freqMap = {
-            'SECONDLY': 'second',
-            'MINUTELY': 'minute',
-            'HOURLY': 'hour',
-            'DAILY': 'day',
-            'WEEKLY': 'week',
-            'MONTHLY': 'month',
-            'YEARLY': 'year'
-        };
-
-        const weekdayMap = {
-            'SU': 'Sunday',
-            'MO': 'Monday',
-            'TU': 'Tuesday',
-            'WE': 'Wednesday',
-            'TH': 'Thursday',
-            'FR': 'Friday',
-            'SA': 'Saturday'
-        };
-
-        const nthMap = {
-            1: 'first',
-            2: 'second',
-            3: 'third',
-            4: 'fourth',
-            5: 'fifth',
-            '-1': 'last',
-            '-2': 'second to last'
-        };
-
-        let description = 'Every';
-
-        // Interval
-        if (rule.interval > 1) {
-            description += ` ${rule.interval}`;
-        }
+    // Frequency
+    description += ` ${freqMap[rule.freq]}`;
+    if (rule.interval > 1) {
+      description += 's';
+    }
 
-        // Frequency
-        description += ` ${freqMap[rule.freq]}`;
-        if (rule.interval > 1) {
-            description += 's';
+    // 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 };
         }
-
-        // 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[parseDay(d).weekday]).join(', ');
-                description += ` on ${days}`;
-            } else if (rule.freq === 'MONTHLY' || rule.freq === 'YEARLY') {
-                const dayDescs = rule.byDay.map(d => {
-                    const parsed = parseDay(d);
-                    if (parsed.nth) {
-                        return `the ${nthMap[parsed.nth] || parsed.nth} ${weekdayMap[parsed.weekday]}`;
-                    }
-                    return weekdayMap[parsed.weekday];
-                }).join(', ');
-                description += ` on ${dayDescs}`;
+        return d;
+      };
+
+      if (rule.freq === 'WEEKLY') {
+        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 => {
+            const parsed = parseDay(d);
+            if (parsed.nth) {
+              return `the ${nthMap[parsed.nth] || parsed.nth} ${weekdayMap[parsed.weekday]}`;
             }
-        }
-
-        // By month day
-        if (rule.byMonthDay && rule.byMonthDay.length > 0) {
-            const days = rule.byMonthDay.map(d => {
-                if (d < 0) {
-                    return `${Math.abs(d)} day(s) from the end`;
-                }
-                return `day ${d}`;
-            }).join(', ');
-            description += ` on ${days}`;
-        }
+            return weekdayMap[parsed.weekday];
+          })
+          .join(', ');
+        description += ` on ${dayDescs}`;
+      }
+    }
 
-        // By month
-        if (rule.byMonth && rule.byMonth.length > 0) {
-            const monthNames = ['January', 'February', 'March', 'April', 'May', 'June',
-                              'July', 'August', 'September', 'October', 'November', 'December'];
-            const months = rule.byMonth.map(m => monthNames[m - 1]).join(', ');
-            description += ` in ${months}`;
-        }
+    // By month day
+    if (rule.byMonthDay && rule.byMonthDay.length > 0) {
+      const days = rule.byMonthDay
+        .map(d => {
+          if (d < 0) {
+            return `${Math.abs(d)} day(s) from the end`;
+          }
+          return `day ${d}`;
+        })
+        .join(', ');
+      description += ` on ${days}`;
+    }
 
-        // Count or until
-        if (rule.count) {
-            description += `, ${rule.count} time${rule.count > 1 ? 's' : ''}`;
-        } else if (rule.until) {
-            description += `, until ${rule.until.toLocaleDateString()}`;
-        }
+    // By month
+    if (rule.byMonth && rule.byMonth.length > 0) {
+      const monthNames = [
+        'January',
+        'February',
+        'March',
+        'April',
+        'May',
+        'June',
+        'July',
+        'August',
+        'September',
+        'October',
+        'November',
+        'December'
+      ];
+      const months = rule.byMonth.map(m => monthNames[m - 1]).join(', ');
+      description += ` in ${months}`;
+    }
 
-        return description;
+    // Count or until
+    if (rule.count) {
+      description += `, ${rule.count} time${rule.count > 1 ? 's' : ''}`;
+    } else if (rule.until) {
+      description += `, until ${rule.until.toLocaleDateString()}`;
     }
-}
+
+    return description;
+  }
+}