store recurring info in eventdef

src/structs/event-store.ts

@@ -1,5 +1,5 @@
 import { EventInput, EventDefHash, EventInstanceHash, parseEventDef, parseEventDateSpan, createEventInstance } from './event'
-import { expandRecurring } from './recurring-event'
+import { parseEventDefRecurring, expandEventDef } from './recurring-event'
 import Calendar from '../Calendar'
 import { assignTo } from '../util/object'
 import { DateRange } from '../datelib/date-range'
@@ -25,14 +25,21 @@ export function parseEventStore(
 
   for (let rawEvent of rawEvents) {
     let leftovers = {}
-    let recurringDateSpans = expandRecurring(rawEvent, fetchRange, calendar, leftovers)
+    let parsedRecurring = parseEventDefRecurring(rawEvent, leftovers)
 
     // a recurring event?
-    if (recurringDateSpans) {
-      let def = parseEventDef(leftovers, sourceId, recurringDateSpans.isAllDay, recurringDateSpans.hasEnd)
+    if (parsedRecurring) {
+      let def = parseEventDef(leftovers, sourceId, parsedRecurring.isAllDay, parsedRecurring.hasEnd)
+      def.recurringDef = {
+        typeId: parsedRecurring.typeId,
+        typeData: parsedRecurring.typeData
+      }
+
       dest.defs[def.defId] = def
 
-      for (let range of recurringDateSpans.ranges) {
+      let ranges = expandEventDef(def, fetchRange, calendar)
+
+      for (let range of ranges) {
         let instance = createEventInstance(def.defId, range)
         dest.instances[instance.instanceId] = instance
       }

src/structs/event.ts

@@ -63,6 +63,7 @@ export interface EventDef extends EventDefAttrs {
   publicId: string
   hasEnd: boolean
   isAllDay: boolean
+  recurringDef: { typeId: number, typeData: {} } | null
   extendedProps: object
   isTemporary?: boolean // if true, will disappear upon navigation
 }
@@ -123,6 +124,7 @@ export function parseEventDef(raw: EventNonDateInput, sourceId: string, isAllDay
   props.sourceId = sourceId
   props.isAllDay = isAllDay
   props.hasEnd = hasEnd
+  props.recurringDef = null
 
   if ('id' in leftovers) {
     props.publicId = String(leftovers.id)

src/structs/recurring-event-simple.ts

@@ -2,9 +2,9 @@ import { startOfDay, addDays } from '../datelib/marker'
 import { Duration, createDuration } from '../datelib/duration'
 import { arrayToHash } from '../util/object'
 import { refineProps } from '../util/misc'
-import { registerRecurringExpander, RecurringEventDateSpans } from './recurring-event'
+import { registerRecurringType, ParsedRecurring } from './recurring-event'
 import Calendar from '../Calendar'
-import { EventInput } from './event'
+import { EventInput, EventDef } from './event'
 import { DateRange } from '../datelib/date-range'
 
 /*
@@ -17,31 +17,47 @@ const SIMPLE_RECURRING_PROPS = {
   endTime: createDuration
 }
 
-registerRecurringExpander(
-  function(rawEvent: EventInput, framingRange: DateRange, calendar: Calendar, leftoverProps: object): RecurringEventDateSpans | null {
+interface SimpleRecurringData {
+  daysOfWeek: number[] | null
+  startTime: Duration | null
+  endTime: Duration | null
+}
+
+interface SimpleParsedRecurring extends ParsedRecurring {
+  typeData: SimpleRecurringData
+}
+
+registerRecurringType({
+
+  parse(rawEvent: EventInput, leftoverProps: any): SimpleParsedRecurring | null {
     if (
       rawEvent.daysOfWeek ||
       rawEvent.startTime != null ||
       rawEvent.endTime != null
     ) {
-      let props = refineProps(rawEvent, SIMPLE_RECURRING_PROPS, {}, leftoverProps)
+      let props = refineProps(rawEvent, SIMPLE_RECURRING_PROPS, {}, leftoverProps) as SimpleRecurringData
 
       return {
         isAllDay: !props.startTime && !props.endTime,
         hasEnd: Boolean(props.endTime),
-        ranges: expandRanges(
-          props.daysOfWeek,
-          props.startTime,
-          props.endTime,
-          framingRange,
-          calendar
-        )
+        typeData: props
       }
     }
 
     return null
+  },
+
+  expand(typeData: SimpleRecurringData, eventDef: EventDef, framingRange: DateRange, calendar: Calendar): DateRange[] {
+    return expandRanges(
+      typeData.daysOfWeek,
+      typeData.startTime,
+      typeData.endTime,
+      framingRange,
+      calendar
+    )
   }
-)
+
+})
 
 function expandRanges(
   daysOfWeek: number[] | null,

src/structs/recurring-event.ts

@@ -1,44 +1,55 @@
 import Calendar from '../Calendar'
-import { EventInput } from './event'
+import { EventInput, EventDef } from './event'
 import { DateRange } from '../datelib/date-range'
 
 /*
 The plugin system for defining how a recurring event is expanded into individual instances.
 */
 
-export interface RecurringEventDateSpans {
+export interface ParsedRecurring {
   isAllDay: boolean
   hasEnd: boolean
-  ranges: DateRange[]
+  typeData: any
 }
 
-export type RecurringExpander = (
-  rawEvent: EventInput,
-  range: DateRange,
-  calendar: Calendar,
-  leftovers: object
-) => RecurringEventDateSpans | null
+export interface IddParsedRecurring extends ParsedRecurring {
+  typeId: number
+}
+
+export interface RecurringType {
+  parse: (rawEvent: EventInput, leftoverProps: any) => ParsedRecurring | null
+  expand: (typeData: any, eventDef: EventDef, framingRange: DateRange, calendar: Calendar) => DateRange[]
+}
 
 
-let recurringExpanders: RecurringExpander[] = []
+let recurringTypes: RecurringType[] = []
 
-export function registerRecurringExpander(expander: RecurringExpander) {
-  recurringExpanders.push(expander)
+export function registerRecurringType(recurringType: RecurringType) {
+  recurringTypes.push(recurringType)
 }
 
-export function expandRecurring(
-  rawEvent: EventInput,
-  range: DateRange,
-  calendar: Calendar,
-  leftovers?: object
-): RecurringEventDateSpans | null {
-  for (let expander of recurringExpanders) {
-    let dateInfo = expander(rawEvent, range, calendar, leftovers || {})
-
-    if (dateInfo) {
-      return dateInfo
+
+export function parseEventDefRecurring(eventInput: EventInput, leftovers: any): IddParsedRecurring | null {
+  for (let i = 0; i < recurringTypes.length; i++) {
+    let parsed = recurringTypes[i].parse(eventInput, leftovers) as IddParsedRecurring
+
+    if (parsed) {
+      parsed.typeId = i
+      return parsed
     }
   }
 
   return null
 }
+
+
+export function expandEventDef(eventDef: EventDef, framingRange: DateRange, calendar: Calendar) {
+  let typeDef = recurringTypes[eventDef.recurringDef.typeId]
+
+  return typeDef.expand(
+    eventDef.recurringDef.typeData,
+    eventDef,
+    framingRange,
+    calendar
+  )
+}