packages/shared/lib/calendar/recurrence/recurring.ts

   1 /* eslint-disable no-param-reassign */
   2 import { addDays, addMilliseconds, differenceInCalendarDays, max } from '../../date-fns-utc';
   3 import { convertUTCDateTimeToZone, convertZonedDateTimeToUTC, fromUTCDate, toUTCDate } from '../../date/timezone';
   4 import type {
   5     VcalDateOrDateTimeProperty,
   6     VcalDateOrDateTimeValue,
   7     VcalRruleProperty,
   8     VcalVeventComponent,
   9 } from '../../interfaces/calendar/VcalModel';
  10 import { createExdateMap } from '../exdate';
  11 import { getInternalDateTimeValue, internalValueToIcalValue } from '../vcal';
  12 import { getDtendProperty, propertyToUTCDate } from '../vcalConverter';
  13 import { getPropertyTzid } from '../vcalHelper';
  14 import { getIsAllDay } from '../veventHelper';
  15
  16 interface CacheInner {
  17     dtstart: VcalDateOrDateTimeValue;
  18     utcStart: Date;
  19     isAllDay: boolean;
  20     eventDuration: number;
  21     modifiedRrule: VcalRruleProperty;
  22     exdateMap: { [key: number]: boolean };
  23 }
  24
  25 export interface RecurringResult {
  26     localStart: Date;
  27     localEnd: Date;
  28     utcStart: Date;
  29     utcEnd: Date;
  30     occurrenceNumber: number;
  31 }
  32
  33 export interface OccurrenceIterationCache {
  34     start: CacheInner;
  35     iteration: {
  36         iterator: any;
  37         result: RecurringResult[];
  38         interval: number[];
  39     };
  40 }
  41
  42 type RequiredVcalVeventComponent = Pick<VcalVeventComponent, 'dtstart' | 'rrule' | 'exdate'>;
  43
  44 const YEAR_IN_MS = Date.UTC(1971, 0, 1);
  45
  46 const isInInterval = (a1: number, a2: number, b1: number, b2: number) => a1 <= b2 && a2 >= b1;
  47
  48 // Special case for when attempting to use occurrences when an rrule does not exist.
  49 // Fake an rrule so that the iteration goes through at least once
  50 const DEFAULT_RRULE = {
  51     value: {
  52         freq: 'DAILY',
  53         count: 1,
  54     },
  55 };
  56
  57 interface FillOccurrencesBetween {
  58     interval: number[];
  59     iterator: any;
  60     eventDuration: number;
  61     originalDtstart: VcalDateOrDateTimeProperty;
  62     originalDtend: VcalDateOrDateTimeProperty;
  63     isAllDay: boolean;
  64     exdateMap: { [key: number]: boolean };
  65 }
  66 const fillOccurrencesBetween = ({
  67     interval: [start, end],
  68     iterator,
  69     eventDuration,
  70     originalDtstart,
  71     originalDtend,
  72     isAllDay,
  73     exdateMap,
  74 }: FillOccurrencesBetween) => {
  75     const result = [];
  76     let next;
  77
  78     const startTzid = getPropertyTzid(originalDtstart);
  79     const endTzid = getPropertyTzid(originalDtend);
  80
  81     // eslint-disable-next-line no-cond-assign
  82     while ((next = iterator.next())) {
  83         const localStart = toUTCDate(getInternalDateTimeValue(next));
  84         if (exdateMap[+localStart]) {
  85             continue;
  86         }
  87
  88         let localEnd;
  89         let utcStart;
  90         let utcEnd;
  91
  92         if (isAllDay) {
  93             localEnd = addDays(localStart, eventDuration);
  94             utcStart = localStart;
  95             utcEnd = localEnd;
  96         } else if (!startTzid || !endTzid) {
  97             const endInStartTimezone = addMilliseconds(localStart, eventDuration);
  98             localEnd = endInStartTimezone;
  99             utcStart = localStart;
 100             utcEnd = endInStartTimezone;
 101         } else {
 102             const endInStartTimezone = addMilliseconds(localStart, eventDuration);
 103
 104             const endInUTC = convertZonedDateTimeToUTC(fromUTCDate(endInStartTimezone), startTzid);
 105             localEnd = toUTCDate(convertUTCDateTimeToZone(endInUTC, endTzid));
 106
 107             utcStart = toUTCDate(convertZonedDateTimeToUTC(fromUTCDate(localStart), startTzid));
 108             utcEnd = toUTCDate(endInUTC);
 109         }
 110
 111         if (+utcStart > end) {
 112             break;
 113         }
 114
 115         if (isInInterval(+utcStart, +utcEnd, start, end)) {
 116             result.push({
 117                 localStart,
 118                 localEnd,
 119                 utcStart,
 120                 utcEnd,
 121                 occurrenceNumber: iterator.occurrence_number as number,
 122             });
 123         }
 124     }
 125     return result;
 126 };
 127
 128 /**
 129  * Convert the until property of an rrule to be in the timezone of the start date
 130  */
 131 const getModifiedUntilRrule = (internalRrule: VcalRruleProperty, startTzid: string | undefined): VcalRruleProperty => {
 132     if (!internalRrule || !internalRrule.value || !internalRrule.value.until || !startTzid) {
 133         return internalRrule;
 134     }
 135     const utcUntil = toUTCDate(internalRrule.value.until);
 136     const localUntil = convertUTCDateTimeToZone(fromUTCDate(utcUntil), startTzid);
 137     return {
 138         ...internalRrule,
 139         value: {
 140             ...internalRrule.value,
 141             until: {
 142                 ...localUntil,
 143                 isUTC: true,
 144             },
 145         },
 146     };
 147 };
 148
 149 const getOccurrenceSetup = (component: RequiredVcalVeventComponent) => {
 150     const { dtstart: internalDtstart, rrule: internalRrule, exdate: internalExdate } = component;
 151     const internalDtEnd = getDtendProperty(component);
 152
 153     const isAllDay = getIsAllDay(component);
 154     const dtstartType = isAllDay ? 'date' : 'date-time';
 155
 156     // Pretend the (local) date is in UTC time to keep the absolute times.
 157     const dtstart = internalValueToIcalValue(dtstartType, {
 158         ...internalDtstart.value,
 159         isUTC: true,
 160     }) as VcalDateOrDateTimeValue;
 161     // Since the local date is pretended in UTC time, the until has to be converted into a fake local UTC time too
 162     const safeRrule = getModifiedUntilRrule(internalRrule || DEFAULT_RRULE, getPropertyTzid(internalDtstart));
 163
 164     const utcStart = propertyToUTCDate(internalDtstart);
 165     let eventDuration: number;
 166
 167     if (isAllDay) {
 168         const rawEnd = propertyToUTCDate(internalDtEnd);
 169         // Non-inclusive end...
 170         const modifiedEnd = addDays(rawEnd, -1);
 171         const utcEnd = max(utcStart, modifiedEnd);
 172
 173         eventDuration = differenceInCalendarDays(utcEnd, utcStart);
 174     } else {
 175         const utcStart = propertyToUTCDate(internalDtstart);
 176         const utcEnd = propertyToUTCDate(internalDtEnd);
 177
 178         eventDuration = Math.max(+utcEnd - +utcStart, 0);
 179     }
 180
 181     return {
 182         dtstart,
 183         utcStart,
 184         isAllDay,
 185         eventDuration,
 186         modifiedRrule: safeRrule,
 187         exdateMap: createExdateMap(internalExdate),
 188     };
 189 };
 190
 191 interface GetOccurrences {
 192     component: RequiredVcalVeventComponent;
 193     maxStart?: Date;
 194     maxCount?: number;
 195     cache?: Partial<OccurrenceIterationCache>;
 196 }
 197 export const getOccurrences = ({
 198     component,
 199     maxStart = new Date(9999, 0, 1),
 200     maxCount = 1,
 201     cache = {},
 202 }: GetOccurrences): Pick<RecurringResult, 'localStart' | 'localEnd' | 'occurrenceNumber'>[] => {
 203     // ICAL.js ignores COUNT=0, so we have to deal with it by hand
 204     if (maxCount <= 0 || component?.rrule?.value.count === 0) {
 205         return [];
 206     }
 207
 208     if (!cache.start) {
 209         cache.start = getOccurrenceSetup(component);
 210     }
 211
 212     const { eventDuration, isAllDay, dtstart, modifiedRrule, exdateMap } = cache.start;
 213
 214     let iterator;
 215     try {
 216         const rrule = internalValueToIcalValue('recur', modifiedRrule.value);
 217         iterator = rrule.iterator(dtstart);
 218     } catch (e: any) {
 219         console.error(e);
 220         // Pretend it was ok
 221         return [];
 222     }
 223     const result = [];
 224
 225     let next;
 226     // eslint-disable-next-line no-cond-assign
 227     while ((next = iterator.next())) {
 228         const localStart = toUTCDate(getInternalDateTimeValue(next));
 229         if (exdateMap[+localStart]) {
 230             continue;
 231         }
 232         if (result.length >= maxCount || localStart >= maxStart) {
 233             break;
 234         }
 235         const localEnd = isAllDay ? addDays(localStart, eventDuration) : addMilliseconds(localStart, eventDuration);
 236         result.push({
 237             localStart,
 238             localEnd,
 239             occurrenceNumber: iterator.occurrence_number,
 240         });
 241     }
 242     return result;
 243 };
 244
 245 export const getOccurrencesBetween = (
 246     component: Pick<VcalVeventComponent, 'dtstart' | 'rrule' | 'exdate'>,
 247     start: number,
 248     end: number,
 249     cache: Partial<OccurrenceIterationCache> = {}
 250 ): RecurringResult[] => {
 251     // ICAL.js ignores COUNT=0, so we have to deal with it by hand
 252     if (component?.rrule?.value.count === 0) {
 253         return [];
 254     }
 255
 256     if (!cache.start) {
 257         cache.start = getOccurrenceSetup(component);
 258     }
 259
 260     const originalDtstart = component.dtstart;
 261     const originalDtend = getDtendProperty(component);
 262
 263     const { eventDuration, isAllDay, utcStart, dtstart, modifiedRrule, exdateMap } = cache.start;
 264
 265     // If it starts after the current end, ignore it
 266     if (+utcStart > end) {
 267         return [];
 268     }
 269
 270     if (!cache.iteration || start < cache.iteration.interval[0] || end > cache.iteration.interval[1]) {
 271         try {
 272             const rrule = internalValueToIcalValue('recur', modifiedRrule.value);
 273             const iterator = rrule.iterator(dtstart);
 274
 275             const interval = [start - YEAR_IN_MS, end + YEAR_IN_MS];
 276             const result = fillOccurrencesBetween({
 277                 interval,
 278                 iterator,
 279                 eventDuration,
 280                 originalDtstart,
 281                 originalDtend,
 282                 isAllDay,
 283                 exdateMap,
 284             });
 285
 286             cache.iteration = {
 287                 iterator,
 288                 result,
 289                 interval,
 290             };
 291         } catch (e: any) {
 292             console.error(e);
 293             // Pretend it was ok
 294             return [];
 295         }
 296     }
 297
 298     return cache.iteration.result.filter(({ utcStart, utcEnd }) => isInInterval(+utcStart, +utcEnd, start, end));
 299 };