rename all unzonedranges

src/Calendar.ts

@@ -845,7 +845,7 @@ export default class Calendar {
     let props = {
       title: view.title,
       activeButton: view.type,
-      isTodayEnabled: todayInfo.isValid && !rangeContainsMarker(dateProfile.currentUnzonedRange, now),
+      isTodayEnabled: todayInfo.isValid && !rangeContainsMarker(dateProfile.currentRange, now),
       isPrevEnabled: prevInfo.isValid,
       isNextEnabled: nextInfo.isValid
     }

src/DateProfileGenerator.ts

@@ -5,12 +5,12 @@ import { DateRange, OpenDateRange, constrainMarkerToRange, intersectRanges, rang
 
 
 export interface DateProfile {
-  validUnzonedRange: DateRange
-  currentUnzonedRange: DateRange
+  validRange: DateRange
+  currentRange: DateRange
   currentRangeUnit: string
   isRangeAllDay: boolean
-  activeUnzonedRange: DateRange
-  renderUnzonedRange: DateRange
+  activeRange: DateRange
+  renderRange: DateRange
   minTime: Duration
   maxTime: Duration
   isValid: boolean
@@ -34,8 +34,8 @@ export default class DateProfileGenerator {
   }
 
 
-  trimHiddenDays(unzonedRange) {
-    return this._view.trimHiddenDays(unzonedRange)
+  trimHiddenDays(range) {
+    return this._view.trimHiddenDays(range)
   }
 
 
@@ -73,57 +73,57 @@ export default class DateProfileGenerator {
   // Optional direction param indicates whether the date is being incremented/decremented
   // from its previous value. decremented = -1, incremented = 1 (default).
   build(date: DateMarker, direction?, forceToValid = false): DateProfile {
-    let validUnzonedRange: DateRange
+    let validRange: DateRange
     let minTime = null
     let maxTime = null
     let currentInfo
     let isRangeAllDay
-    let renderUnzonedRange: DateRange
-    let activeUnzonedRange: DateRange
+    let renderRange: DateRange
+    let activeRange: DateRange
     let isValid
 
-    validUnzonedRange = this.buildValidRange()
-    validUnzonedRange = this.trimHiddenDays(validUnzonedRange)
+    validRange = this.buildValidRange()
+    validRange = this.trimHiddenDays(validRange)
 
     if (forceToValid) {
-      date = constrainMarkerToRange(date, validUnzonedRange)
+      date = constrainMarkerToRange(date, validRange)
     }
 
     currentInfo = this.buildCurrentRangeInfo(date, direction)
     isRangeAllDay = /^(year|month|week|day)$/.test(currentInfo.unit)
-    renderUnzonedRange = this.buildRenderRange(
-      this.trimHiddenDays(currentInfo.unzonedRange),
+    renderRange = this.buildRenderRange(
+      this.trimHiddenDays(currentInfo.range),
       currentInfo.unit,
       isRangeAllDay
     )
-    renderUnzonedRange = this.trimHiddenDays(renderUnzonedRange)
-    activeUnzonedRange = renderUnzonedRange
+    renderRange = this.trimHiddenDays(renderRange)
+    activeRange = renderRange
 
     if (!this.opt('showNonCurrentDates')) {
-      activeUnzonedRange = intersectRanges(activeUnzonedRange, currentInfo.unzonedRange)
+      activeRange = intersectRanges(activeRange, currentInfo.range)
     }
 
     minTime = createDuration(this.opt('minTime'))
     maxTime = createDuration(this.opt('maxTime'))
-    activeUnzonedRange = this.adjustActiveRange(activeUnzonedRange, minTime, maxTime)
-    activeUnzonedRange = intersectRanges(activeUnzonedRange, validUnzonedRange) // might return null
+    activeRange = this.adjustActiveRange(activeRange, minTime, maxTime)
+    activeRange = intersectRanges(activeRange, validRange) // might return null
 
-    if (activeUnzonedRange) {
-      date = constrainMarkerToRange(date, activeUnzonedRange)
+    if (activeRange) {
+      date = constrainMarkerToRange(date, activeRange)
     }
 
     // it's invalid if the originally requested date is not contained,
     // or if the range is completely outside of the valid range.
-    isValid = rangesIntersect(currentInfo.unzonedRange, validUnzonedRange)
+    isValid = rangesIntersect(currentInfo.range, validRange)
 
     return {
       // constraint for where prev/next operations can go and where events can be dragged/resized to.
       // an object with optional start and end properties.
-      validUnzonedRange: validUnzonedRange,
+      validRange: validRange,
 
       // range the view is formally responsible for.
       // for example, a month view might have 1st-31st, excluding padded dates
-      currentUnzonedRange: currentInfo.unzonedRange,
+      currentRange: currentInfo.range,
 
       // name of largest unit being displayed, like "month" or "week"
       currentRangeUnit: currentInfo.unit,
@@ -132,11 +132,11 @@ export default class DateProfileGenerator {
 
       // dates that display events and accept drag-n-drop
       // will be `null` if no dates accept events
-      activeUnzonedRange: activeUnzonedRange,
+      activeRange: activeRange,
 
       // date range with a rendered skeleton
       // includes not-active days that need some sort of DOM
-      renderUnzonedRange: renderUnzonedRange,
+      renderRange: renderRange,
 
       // Duration object that denotes the first visible time of any given day
       minTime: minTime,
@@ -173,25 +173,25 @@ export default class DateProfileGenerator {
     let viewSpec = this._view.viewSpec
     let duration = null
     let unit = null
-    let unzonedRange = null
+    let range = null
     let dayCount
 
     if (viewSpec.duration) {
       duration = viewSpec.duration
       unit = viewSpec.durationUnit
-      unzonedRange = this.buildRangeFromDuration(date, direction, duration, unit)
+      range = this.buildRangeFromDuration(date, direction, duration, unit)
     } else if ((dayCount = this.opt('dayCount'))) {
       unit = 'day'
-      unzonedRange = this.buildRangeFromDayCount(date, direction, dayCount)
-    } else if ((unzonedRange = this.buildCustomVisibleRange(date))) {
-      unit = dateEnv.greatestWholeUnit(unzonedRange.start, unzonedRange.end).unit
+      range = this.buildRangeFromDayCount(date, direction, dayCount)
+    } else if ((range = this.buildCustomVisibleRange(date))) {
+      unit = dateEnv.greatestWholeUnit(range.start, range.end).unit
     } else {
       duration = this.getFallbackDuration()
       unit = greatestDurationDenominator(duration).unit
-      unzonedRange = this.buildRangeFromDuration(date, direction, duration, unit)
+      range = this.buildRangeFromDuration(date, direction, duration, unit)
     }
 
-    return { duration: duration, unit: unit, unzonedRange: unzonedRange }
+    return { duration: duration, unit: unit, range }
   }
 
 
@@ -200,7 +200,7 @@ export default class DateProfileGenerator {
   }
 
 
-  // Returns a new activeUnzonedRange to have time values (un-ambiguate)
+  // Returns a new activeRange to have time values (un-ambiguate)
   // minTime or maxTime causes the range to expand.
   adjustActiveRange(range: DateRange, minTime: Duration, maxTime: Duration) {
     const dateEnv = this._view.calendar.dateEnv
@@ -313,24 +313,24 @@ export default class DateProfileGenerator {
 
 
   // Builds a normalized range object for the "visible" range,
-  // which is a way to define the currentUnzonedRange and activeUnzonedRange at the same time.
+  // which is a way to define the currentRange and activeRange at the same time.
   buildCustomVisibleRange(date: DateMarker) {
     const dateEnv = this._view.calendar.dateEnv
-    let visibleUnzonedRange = this._view.getRangeOption('visibleRange', dateEnv.toDate(date))
+    let visibleRange = this._view.getRangeOption('visibleRange', dateEnv.toDate(date))
 
-    if (visibleUnzonedRange && (visibleUnzonedRange.start == null || visibleUnzonedRange.end == null)) {
+    if (visibleRange && (visibleRange.start == null || visibleRange.end == null)) {
       return null
     }
 
-    return visibleUnzonedRange
+    return visibleRange
   }
 
 
   // Computes the range that will represent the element/cells for *rendering*,
   // but which may have voided days/times.
   // not responsible for trimming hidden days.
-  buildRenderRange(currentUnzonedRange: DateRange, currentRangeUnit, isRangeAllDay) {
-    return currentUnzonedRange
+  buildRenderRange(currentRange: DateRange, currentRangeUnit, isRangeAllDay) {
+    return currentRange
   }
 
 

src/View.ts

@@ -47,15 +47,15 @@ export default abstract class View extends DateComponent {
   dateProfileGeneratorClass: any // initialized after class
   dateProfileGenerator: DateProfileGenerator
 
-  // whether minTime/maxTime will affect the activeUnzonedRange. Views must opt-in.
+  // whether minTime/maxTime will affect the activeRange. Views must opt-in.
   // initialized after class
   usesMinMaxTime: boolean
 
   // DEPRECATED
-  start: Date // use activeUnzonedRange
-  end: Date // use activeUnzonedRange
-  intervalStart: Date // use currentUnzonedRange
-  intervalEnd: Date // use currentUnzonedRange
+  start: Date // use activeRange
+  end: Date // use activeRange
+  intervalStart: Date // use currentRange
+  intervalEnd: Date // use currentRange
 
 
   constructor(calendar, viewSpec) {
@@ -94,13 +94,13 @@ export default abstract class View extends DateComponent {
   // Computes what the title at the top of the calendar should be for this view
   computeTitle(dateProfile) {
     let dateEnv = this.getDateEnv()
-    let unzonedRange
+    let range: DateRange
 
     // for views that span a large unit of time, show the proper interval, ignoring stray days before and after
     if (/^(year|month)$/.test(dateProfile.currentRangeUnit)) {
-      unzonedRange = dateProfile.currentUnzonedRange
+      range = dateProfile.currentRange
     } else { // for day units or smaller, use the actual day range
-      unzonedRange = dateProfile.activeUnzonedRange
+      range = dateProfile.activeRange
     }
 
     // TODO: precompute
@@ -114,8 +114,8 @@ export default abstract class View extends DateComponent {
     }
 
     return dateEnv.formatRange(
-      unzonedRange.start,
-      unzonedRange.end,
+      range.start,
+      range.end,
       createFormatter(rawTitleFormat),
       { isEndExclusive: dateProfile.isRangeAllDay }
     )
@@ -133,8 +133,8 @@ export default abstract class View extends DateComponent {
       return { year: 'numeric', month: 'long' } // like "September 2014"
     } else {
       let days = diffWholeDays(
-        dateProfile.currentUnzonedRange.start,
-        dateProfile.currentUnzonedRange.end
+        dateProfile.currentRange.start,
+        dateProfile.currentRange.end
       )
       if (days !== null && days > 1) {
         // multi-day range. shorter, like "Sep 9 - 10 2014"
@@ -156,7 +156,7 @@ export default abstract class View extends DateComponent {
 
     if ( // reuse current reference if possible, for rendering optimization
       this.dateProfile &&
-      rangesEqual(this.dateProfile.activeUnzonedRange, dateProfile.activeUnzonedRange)
+      rangesEqual(this.dateProfile.activeRange, dateProfile.activeRange)
     ) {
       return this.dateProfile
     }
@@ -170,10 +170,10 @@ export default abstract class View extends DateComponent {
 
     this.title = this.computeTitle(dateProfile)
     // DEPRECATED, but we need to keep it updated...
-    this.start = dateEnv.toDate(dateProfile.activeUnzonedRange.start)
-    this.end = dateEnv.toDate(dateProfile.activeUnzonedRange.end)
-    this.intervalStart = dateEnv.toDate(dateProfile.currentUnzonedRange.start)
-    this.intervalEnd = dateEnv.toDate(dateProfile.currentUnzonedRange.end)
+    this.start = dateEnv.toDate(dateProfile.activeRange.start)
+    this.end = dateEnv.toDate(dateProfile.activeRange.end)
+    this.intervalStart = dateEnv.toDate(dateProfile.currentRange.start)
+    this.intervalEnd = dateEnv.toDate(dateProfile.currentRange.end)
   }
 
 
@@ -428,9 +428,9 @@ export default abstract class View extends DateComponent {
 
   // Remove days from the beginning and end of the range that are computed as hidden.
   // If the whole range is trimmed off, returns null
-  trimHiddenDays(inputUnzonedRange): DateRange | null {
-    let start = inputUnzonedRange.start
-    let end = inputUnzonedRange.end
+  trimHiddenDays(range: DateRange): DateRange | null {
+    let start = range.start
+    let end = range.end
 
     if (start) {
       start = this.skipHiddenDays(start)
@@ -459,7 +459,7 @@ export default abstract class View extends DateComponent {
 
 
   // Incrementing the current day until it is no longer a hidden day, returning a copy.
-  // DOES NOT CONSIDER validUnzonedRange!
+  // DOES NOT CONSIDER validRange!
   // If the initial value of `date` is not a hidden day, don't do anything.
   // Pass `isExclusive` as `true` if you are dealing with an end date.
   // `inc` defaults to `1` (increment one day forward each time)

src/agenda/AgendaView.ts

@@ -349,7 +349,7 @@ agendaTimeGridMethods = {
     let view = this.view
     let calendar = view.calendar
     let dateEnv = calendar.dateEnv
-    let weekStart = this.dateProfile.renderUnzonedRange.start
+    let weekStart = this.dateProfile.renderRange.start
     let weekText
 
     if (this.opt('weekNumbers')) {

src/agenda/TimeGrid.ts

@@ -104,21 +104,21 @@ export default class TimeGrid extends DateComponent {
   ------------------------------------------------------------------------------------------------------------------*/
 
 
-  sliceRangeByTimes(unzonedRange) {
+  sliceRangeByTimes(range) {
     let segs = []
     let segRange
     let dayIndex
 
     for (dayIndex = 0; dayIndex < this.daysPerRow; dayIndex++) {
 
-      segRange = intersectRanges(unzonedRange, this.dayRanges[dayIndex])
+      segRange = intersectRanges(range, this.dayRanges[dayIndex])
 
       if (segRange) {
         segs.push({
           start: segRange.start,
           end: segRange.end,
-          isStart: segRange.start.valueOf() === unzonedRange.start.valueOf(),
-          isEnd: segRange.end.valueOf() === unzonedRange.end.valueOf(),
+          isStart: segRange.start.valueOf() === range.start.valueOf(),
+          isEnd: segRange.end.valueOf() === range.end.valueOf(),
           dayIndex: dayIndex
         })
       }
@@ -250,7 +250,7 @@ export default class TimeGrid extends DateComponent {
     let isRTL = this.isRTL
     let dateProfile = this.dateProfile
     let html = ''
-    let dayStart = startOfDay(dateProfile.renderUnzonedRange.start)
+    let dayStart = startOfDay(dateProfile.renderRange.start)
     let slotTime = dateProfile.minTime
     let slotIterator = createDuration(0)
     let slotDate // will be on the view's first day, but we only care about its time

src/basic/BasicViewDateProfileGenerator.ts

@@ -6,11 +6,11 @@ import { DateRange } from '../datelib/date-range'
 export default class BasicViewDateProfileGenerator extends DateProfileGenerator {
 
   // Computes the date range that will be rendered.
-  buildRenderRange(currentUnzonedRange, currentRangeUnit, isRangeAllDay): DateRange {
+  buildRenderRange(currentRange, currentRangeUnit, isRangeAllDay): DateRange {
     let dateEnv = this._view.calendar.dateEnv
-    let renderUnzonedRange = super.buildRenderRange(currentUnzonedRange, currentRangeUnit, isRangeAllDay)
-    let start = renderUnzonedRange.start
-    let end = renderUnzonedRange.end
+    let renderRange = super.buildRenderRange(currentRange, currentRangeUnit, isRangeAllDay)
+    let start = renderRange.start
+    let end = renderRange.end
     let endOfWeek
 
     // year and month views should be aligned with weeks. this is already done for week

src/basic/DayGrid.ts

@@ -243,7 +243,7 @@ export default class DayGrid extends DateComponent {
     let view = this.view
     let dateEnv = this.getDateEnv()
     let html = ''
-    let isDateValid = rangeContainsMarker(this.dateProfile.activeUnzonedRange, date) // TODO: called too frequently. cache somehow.
+    let isDateValid = rangeContainsMarker(this.dateProfile.activeRange, date) // TODO: called too frequently. cache somehow.
     let isDayNumberVisible = this.getIsDayNumbersVisible() && isDateValid
     let classes
     let weekCalcFirstDow

src/basic/MonthView.ts

@@ -24,7 +24,7 @@ export default class MonthView extends BasicView {
   isDateInOtherMonth(date: DateMarker, dateProfile) {
     let dateEnv = this.getDateEnv()
 
-    return dateEnv.getMonth(date) !== dateEnv.getMonth(dateProfile.currentUnzonedRange.start)
+    return dateEnv.getMonth(date) !== dateEnv.getMonth(dateProfile.currentRange.start)
   }
 
 }

src/basic/MonthViewDateProfileGenerator.ts

@@ -5,10 +5,10 @@ import { addWeeks, diffWeeks } from '../datelib/marker'
 export default class MonthViewDateProfileGenerator extends BasicViewDateProfileGenerator {
 
   // Computes the date range that will be rendered.
-  buildRenderRange(currentUnzonedRange, currentRangeUnit, isRangeAllDay) {
-    let renderUnzonedRange = super.buildRenderRange(currentUnzonedRange, currentRangeUnit, isRangeAllDay)
-    let start = renderUnzonedRange.start
-    let end = renderUnzonedRange.end
+  buildRenderRange(currentRange, currentRangeUnit, isRangeAllDay) {
+    let renderRange = super.buildRenderRange(currentRange, currentRangeUnit, isRangeAllDay)
+    let start = renderRange.start
+    let end = renderRange.end
     let rowCnt
 
     // ensure 6 weeks

src/component/DateComponent.ts

@@ -503,7 +503,7 @@ export default abstract class DateComponent extends Component {
           buildBusinessHours(
             businessHoursDef,
             this.hasAllDayBusinessHours,
-            this.dateProfile.activeUnzonedRange,
+            this.dateProfile.activeRange,
             this.getCalendar()
           )
         ),
@@ -807,8 +807,8 @@ export default abstract class DateComponent extends Component {
 
 
   eventStoreToSegs(eventStore: EventStore): Seg[] {
-    let activeUnzonedRange = this.dateProfile.activeUnzonedRange
-    let eventRenderRanges = sliceEventStore(eventStore, activeUnzonedRange)
+    let activeRange = this.dateProfile.activeRange
+    let eventRenderRanges = sliceEventStore(eventStore, activeRange)
     let allSegs: Seg[] = []
 
     for (let eventRenderRange of eventRenderRanges) {
@@ -931,7 +931,7 @@ export default abstract class DateComponent extends Component {
     let todayStart: DateMarker
     let todayEnd: DateMarker
 
-    if (!rangeContainsMarker(this.dateProfile.activeUnzonedRange, date)) {
+    if (!rangeContainsMarker(this.dateProfile.activeRange, date)) {
       classes.push('fc-disabled-day') // TODO: jQuery UI theme?
     } else {
       classes.push('fc-' + DAY_IDS[date.getUTCDay()])
@@ -965,7 +965,7 @@ export default abstract class DateComponent extends Component {
   // Will return `0` if there's not a clean whole interval.
   currentRangeAs(unit) { // PLURAL :(
     let dateEnv = this.getDateEnv()
-    let range = this.dateProfile.currentUnzonedRange
+    let range = this.dateProfile.currentRange
     let res = null
 
     if (unit === 'years') {

src/component/DayTableMixin.ts

@@ -17,8 +17,8 @@ export interface DayTableInterface {
   bookendCells(trEl: HTMLElement)
   getCellDate(row, col)
   getCellRange(row, col): DateRange
-  sliceRangeByDay(unzonedRange)
-  sliceRangeByRow(unzonedRange)
+  sliceRangeByDay(range)
+  sliceRangeByRow(range)
   renderIntroHtml()
 }
 
@@ -42,8 +42,8 @@ export default class DayTableMixin extends Mixin implements DayTableInterface {
     let t = (this as any)
     let view = t.view
     let dateProfile = t.dateProfile
-    let date: DateMarker = dateProfile.renderUnzonedRange.start
-    let end: DateMarker = dateProfile.renderUnzonedRange.end
+    let date: DateMarker = dateProfile.renderRange.start
+    let end: DateMarker = dateProfile.renderRange.end
     let dayIndex = -1
     let dayIndices = []
     let dayDates: DateMarker[] = []
@@ -175,9 +175,9 @@ export default class DayTableMixin extends Mixin implements DayTableInterface {
 
 
   // Slices up a date range into a segment for every week-row it intersects with
-  sliceRangeByRow(unzonedRange) {
+  sliceRangeByRow(range) {
     let daysPerRow = this.daysPerRow
-    let normalRange = (this as any).view.computeDayRange(unzonedRange) // make whole-day range, considering nextDayThreshold
+    let normalRange = (this as any).view.computeDayRange(range) // make whole-day range, considering nextDayThreshold
     let rangeFirst = this.getDateDayIndex(normalRange.start) // inclusive first index
     let rangeLast = this.getDateDayIndex(addDays(normalRange.end, -1)) // inclusive last index
     let segs = []
@@ -220,9 +220,9 @@ export default class DayTableMixin extends Mixin implements DayTableInterface {
 
   // Slices up a date range into a segment for every day-cell it intersects with.
   // TODO: make more DRY with sliceRangeByRow somehow.
-  sliceRangeByDay(unzonedRange) {
+  sliceRangeByDay(range) {
     let daysPerRow = this.daysPerRow
-    let normalRange = (this as any).view.computeDayRange(unzonedRange) // make whole-day range, considering nextDayThreshold
+    let normalRange = (this as any).view.computeDayRange(range) // make whole-day range, considering nextDayThreshold
     let rangeFirst = this.getDateDayIndex(normalRange.start) // inclusive first index
     let rangeLast = this.getDateDayIndex(addDays(normalRange.end, -1)) // inclusive last index
     let segs = []
@@ -321,7 +321,7 @@ export default class DayTableMixin extends Mixin implements DayTableInterface {
     let view = t.view
     let dateEnv = t.getDateEnv()
     let dateProfile = t.dateProfile
-    let isDateValid =  rangeContainsMarker(dateProfile.activeUnzonedRange, date) // TODO: called too frequently. cache somehow.
+    let isDateValid =  rangeContainsMarker(dateProfile.activeRange, date) // TODO: called too frequently. cache somehow.
     let classNames = [
       'fc-day-header',
       view.calendar.theme.getClass('widgetHeader')
@@ -412,7 +412,7 @@ export default class DayTableMixin extends Mixin implements DayTableInterface {
     let view = t.view
     let dateEnv = t.getDateEnv()
     let dateProfile = t.dateProfile
-    let isDateValid = rangeContainsMarker(dateProfile.activeUnzonedRange, date) // TODO: called too frequently. cache somehow.
+    let isDateValid = rangeContainsMarker(dateProfile.activeRange, date) // TODO: called too frequently. cache somehow.
     let classes = t.getDayClasses(date)
 
     classes.unshift('fc-day', view.calendar.theme.getClass('widgetContent'))

src/list/ListView.ts

@@ -72,8 +72,8 @@ export default class ListView extends View {
 
   renderDates() {
     let dateProfile = this.dateProfile
-    let dayStart = startOfDay(dateProfile.renderUnzonedRange.start)
-    let viewEnd = dateProfile.renderUnzonedRange.end
+    let dayStart = startOfDay(dateProfile.renderRange.start)
+    let viewEnd = dateProfile.renderRange.end
     let dayDates: DateMarker[] = []
     let dayRanges: DateRange[] = []
 

src/reducers/event-sources.ts

@@ -20,7 +20,7 @@ export function reduceEventSourceHash(sourceHash: EventSourceHash, action: any,
           calendar.dispatch({
             type: 'FETCH_EVENT_SOURCE',
             sourceId: eventSource.sourceId,
-            range: calendar.state.dateProfile.activeUnzonedRange
+            range: calendar.state.dateProfile.activeRange
           })
         }
         return assignTo({}, sourceHash, {
@@ -35,7 +35,7 @@ export function reduceEventSourceHash(sourceHash: EventSourceHash, action: any,
         calendar.dispatch({
           type: 'FETCH_EVENT_SOURCE',
           sourceId,
-          range: calendar.state.dateProfile.activeUnzonedRange
+          range: calendar.state.dateProfile.activeRange
         })
       }
       return sourceHash
@@ -110,7 +110,7 @@ export function reduceEventSourceHash(sourceHash: EventSourceHash, action: any,
       }
 
     case 'SET_DATE_PROFILE':
-      let activeRange = action.dateProfile.activeUnzonedRange
+      let activeRange = action.dateProfile.activeRange
 
       for (let sourceId in sourceHash) {
         eventSource = sourceHash[sourceId]

src/util/misc.ts

@@ -454,18 +454,18 @@ export function refineProps(rawProps: GenericHash, processors: GenericHash, defa
 
 // given a timed range, computes an all-day range that has the same exact duration,
 // but whose start time is aligned with the start of the day.
-export function computeAlignedDayRange(range: DateRange): DateRange {
-  let dayCnt = Math.floor(diffDays(range.start, range.end)) || 1
-  let start = startOfDay(range.start)
+export function computeAlignedDayRange(timedRange: DateRange): DateRange {
+  let dayCnt = Math.floor(diffDays(timedRange.start, timedRange.end)) || 1
+  let start = startOfDay(timedRange.start)
   let end = addDays(start, dayCnt)
   return { start, end }
 }
 
 
 // given a timed range, computes an all-day range based on how for the end date bleeds into the next day
-export function computeVisibleDayRange(unzonedRange: DateRange, nextDayThreshold: Duration): DateRange {
-  let startDay: DateMarker = startOfDay(unzonedRange.start) // the beginning of the day the range starts
-  let end: DateMarker = unzonedRange.end
+export function computeVisibleDayRange(timedRange: DateRange, nextDayThreshold: Duration): DateRange {
+  let startDay: DateMarker = startOfDay(timedRange.start) // the beginning of the day the range starts
+  let end: DateMarker = timedRange.end
   let endDay: DateMarker = startOfDay(end)
   let endTimeMS: number = end.valueOf() - endDay.valueOf() // # of milliseconds into `endDay`