recurring events in static source

src/event-sources/array-event-source.ts

@@ -3,6 +3,8 @@ import { EventInput } from '../structs/event'
 
 registerEventSourceDef({
 
+  singleFetch: true, // can we please NOT store the raw events internally then???
+
   parseMeta(raw: any): EventInput[] | null {
     if (Array.isArray(raw)) { // short form
       return raw

src/reducers/eventSources.ts

@@ -1,4 +1,4 @@
-import { EventSource, EventSourceHash, getEventSourceDef } from '../structs/event-source'
+import { EventSource, EventSourceHash, getEventSourceDef, EventSourceDef } from '../structs/event-source'
 import Calendar from '../Calendar'
 import { arrayToHash, assignTo, filterHash } from '../util/object'
 import { DateRange } from '../datelib/date-range'
@@ -20,7 +20,7 @@ export default function(eventSourceHash: EventSourceHash, action: Action, datePr
 
     case 'FETCH_EVENT_SOURCES':
       if (dateProfile) {
-        return fetchSourcesById(eventSourceHash, action.sourceIds || null, dateProfile, calendar)
+        return fetchSourcesByIds(eventSourceHash, action.sourceIds || null, dateProfile, calendar)
       } else {
         return eventSourceHash // can't fetch if don't know the framing range
       }
@@ -63,6 +63,7 @@ function fetchDirtySources(sourceHash: EventSourceHash, dateProfile: DateProfile
   let activeRange = dateProfile.activeRange
   let dirtySourceIds = []
 
+
   for (let sourceId in sourceHash) {
     let eventSource = sourceHash[sourceId]
 
@@ -77,13 +78,13 @@ function fetchDirtySources(sourceHash: EventSourceHash, dateProfile: DateProfile
   }
 
   if (dirtySourceIds.length) {
-    return fetchSourcesById(sourceHash, dirtySourceIds, dateProfile, calendar)
+    sourceHash = fetchSourcesByIds(sourceHash, dirtySourceIds, dateProfile, calendar)
   }
 
   return sourceHash
 }
 
-function fetchSourcesById(
+function fetchSourcesByIds(
   prevSources: EventSourceHash,
   sourceIds: string[] | null,
   dateProfile: DateProfile,
@@ -97,14 +98,7 @@ function fetchSourcesById(
     let source = prevSources[sourceId]
 
     if (!sourceIdHash || sourceIdHash[sourceId]) {
-      let fetchId = String(uid++)
-
-      fetchSource(source, activeRange, fetchId, calendar)
-
-      nextSources[sourceId] = assignTo({}, source, {
-        isFetching: true,
-        latestFetchId: fetchId
-      })
+      nextSources[sourceId] = fetchSource(source, activeRange, calendar)
     } else {
       nextSources[sourceId] = source
     }
@@ -113,8 +107,20 @@ function fetchSourcesById(
   return nextSources
 }
 
-function fetchSource(eventSource: EventSource, range: DateRange, fetchId: string, calendar: Calendar) {
-  getEventSourceDef(eventSource.sourceDefId).fetch(
+function fetchSource(eventSource: EventSource, range: DateRange, calendar: Calendar) {
+  let sourceDef = getEventSourceDef(eventSource.sourceDefId)
+
+  if (sourceDef.singleFetch && eventSource.fetchRange) {
+    return eventSource
+  } else {
+    return fetchSourceAsync(eventSource, sourceDef, range, calendar)
+  }
+}
+
+function fetchSourceAsync(eventSource: EventSource, sourceDef: EventSourceDef, range: DateRange, calendar: Calendar) {
+  let fetchId = String(uid++)
+
+  sourceDef.fetch(
     {
       eventSource,
       calendar,
@@ -152,6 +158,13 @@ function fetchSource(eventSource: EventSource, range: DateRange, fetchId: string
       })
     }
   )
+
+  // TODO: if singleFetch, remove the meta at this point?
+
+  return assignTo({}, eventSource, {
+    isFetching: true,
+    latestFetchId: fetchId
+  })
 }
 
 function receiveResponse(sourceHash: EventSourceHash, sourceId: string, fetchId: string, fetchRange: DateRange) {

src/reducers/eventStore.ts

@@ -2,11 +2,13 @@ import Calendar from '../Calendar'
 import { filterHash } from '../util/object'
 import { EventMutation, applyMutationToEventStore } from '../structs/event-mutation'
 import { EventDef, EventInstance, EventInput, EventInstanceHash } from '../structs/event'
-import { EventStore, parseEventStore, mergeEventStores, getRelatedEvents, createEmptyEventStore } from '../structs/event-store'
+import { EventStore, parseEventStore, mergeEventStores, getRelatedEvents, createEmptyEventStore, expandEventDefInstances } from '../structs/event-store'
 import { Action } from './types'
-import { EventSourceHash, EventSource } from '../structs/event-source'
+import { EventSourceHash, EventSource, getEventSourceDef } from '../structs/event-source'
 import { DateRange } from '../datelib/date-range'
 
+// how to let user modify recurring def AFTER?
+
 export default function(eventStore: EventStore, action: Action, sourceHash: EventSourceHash, calendar: Calendar): EventStore {
   switch(action.type) {
 
@@ -45,6 +47,9 @@ export default function(eventStore: EventStore, action: Action, sourceHash: Even
     case 'REMOVE_ALL_EVENTS':
       return createEmptyEventStore()
 
+    case 'SET_DATE_PROFILE':
+      return expandStaticEventDefs(eventStore, sourceHash, action.dateProfile.activeRange, calendar)
+
     default:
       return eventStore
   }
@@ -130,3 +135,22 @@ function applyMutationToRelated(eventStore: EventStore, instanceId: string, muta
   related = applyMutationToEventStore(related, mutation, calendar)
   return mergeEventStores(eventStore, related)
 }
+
+function expandStaticEventDefs(eventStore: EventStore, eventSources: EventSourceHash, framingRange: DateRange, calendar: Calendar): EventStore {
+  let staticSources = filterHash(eventSources, function(eventSource: EventSource) { // sources that won't change
+    return eventSource.fetchRange && getEventSourceDef(eventSource.sourceDefId).singleFetch // only needs one fetch, and already got it
+  }) as EventSourceHash
+
+  let defs = eventStore.defs
+  let instances = filterHash(eventStore.instances, function(eventInstance) {
+    let def = defs[eventInstance.defId]
+
+    return !def.recurringDef || !staticSources[def.sourceId]
+  })
+
+  for (let defId in defs) {
+    expandEventDefInstances(defs[defId], framingRange, calendar, instances)
+  }
+
+  return { defs, instances }
+}