clean up render method, more granular updateSize, remove BusinessHourRenderer

src/Calendar.ts

@@ -124,7 +124,7 @@ export default class Calendar {
     } else if (this.elementVisible()) {
       // mainly for the public API
       this.calcSize()
-      this.updateViewSize()
+      this.updateViewSize(true) // force=true
     }
   }
 
@@ -441,7 +441,7 @@ export default class Calendar {
 
     if (optionCnt === 1) {
       if (optionName === 'height' || optionName === 'contentHeight' || optionName === 'aspectRatio') {
-        this.updateViewSize(true) // isResize=true
+        this.updateViewSize(true) // force=true
         return
       } else if (optionName === 'defaultDate') {
         return // can't change date this way. use gotoDate instead
@@ -726,13 +726,13 @@ export default class Calendar {
   }
 
 
-  updateViewSize(isResize: boolean = false) {
+  updateViewSize(force: boolean = false) {
     let { renderedView } = this
     let scroll
 
     if (!this.ignoreUpdateViewSize && renderedView) {
 
-      if (isResize) {
+      if (force) {
         this.calcSize()
         scroll = renderedView.queryScroll()
       }
@@ -741,12 +741,13 @@ export default class Calendar {
 
       renderedView.updateSize(
         this.getSuggestedViewHeight(),
-        this.isHeightAuto()
+        this.isHeightAuto(),
+        force
       )
 
       this.ignoreUpdateViewSize--
 
-      if (isResize) {
+      if (force) {
         renderedView.applyScroll(scroll)
       }
 
@@ -796,9 +797,9 @@ export default class Calendar {
       // cast to any because .target, which is Element, can't be compared to window for some reason.
       (ev as any).target === window &&
       this.renderedView &&
-      this.renderedView.isDatesRendered
+      this.renderedView.renderedFlags.dates
     ) {
-      if (this.updateViewSize(true)) { // isResize=true, returns true on success
+      if (this.updateViewSize(true)) { // force=true, returns true on success
         this.publiclyTrigger('windowResize', [ this.renderedView ])
       }
     }

src/View.ts

@@ -268,7 +268,7 @@ export default abstract class View extends DateComponent {
   // since the initial getNow call.
   updateNowIndicator() {
     if (
-      this.isDatesRendered &&
+      this.renderedFlags.dates &&
       this.initialNowDate // activated before?
     ) {
       this.unrenderNowIndicator() // won't unrender if unnecessary
@@ -304,8 +304,8 @@ export default abstract class View extends DateComponent {
   ------------------------------------------------------------------------------------------------------------------*/
 
 
-  updateSize(totalHeight, isAuto) {
-    super.updateSize(totalHeight, isAuto)
+  updateSize(totalHeight, isAuto, force) {
+    super.updateSize(totalHeight, isAuto, force)
     this.updateNowIndicator()
   }
 
@@ -335,7 +335,7 @@ export default abstract class View extends DateComponent {
   queryScroll() {
     let scroll = {}
 
-    if (this.isDatesRendered) {
+    if (this.renderedFlags.dates) {
       assignTo(scroll, this.queryDateScroll())
     }
 
@@ -344,11 +344,11 @@ export default abstract class View extends DateComponent {
 
 
   applyScroll(scroll) {
-    if (scroll.isDateInit && this.isDatesRendered) {
+    if (scroll.isDateInit && this.renderedFlags.dates) {
       assignTo(scroll, this.computeInitialDateScroll())
     }
 
-    if (this.isDatesRendered) {
+    if (this.renderedFlags.dates) {
       this.applyDateScroll(scroll)
     }
   }

src/agenda/AgendaView.ts

@@ -224,7 +224,7 @@ export default class AgendaView extends View {
 
 
   // Adjusts the vertical dimensions of the view to the specified values
-  updateSize(totalHeight, isAuto) {
+  updateBaseSize(totalHeight, isAuto) {
     let eventLimit
     let scrollerHeight
     let scrollbarWidths
@@ -293,8 +293,6 @@ export default class AgendaView extends View {
         this.timeGrid.bottomRuleEl.style.display = ''
       }
     }
-
-    super.updateSize(totalHeight, isAuto) // children and now-indicator
   }
 
 

src/agenda/TimeGrid.ts

@@ -1,6 +1,5 @@
 import { htmlEscape } from '../util/html'
 import { htmlToElement, findElements, createElement, removeElement, applyStyle } from '../util/dom-manip'
-import BusinessHourRenderer from '../component/renderers/BusinessHourRenderer'
 import { default as DayTableMixin, DayTableInterface } from '../component/DayTableMixin'
 import CoordCache from '../common/CoordCache'
 import UnzonedRange from '../models/UnzonedRange'
@@ -471,18 +470,6 @@ export default class TimeGrid extends DateComponent {
   ------------------------------------------------------------------------------------------------------------------*/
 
 
-  updateSize(totalHeight, isAuto) {
-    super.updateSize(totalHeight, isAuto)
-    this.buildCoordCaches()
-
-    this.eventRenderer.computeFgSizes()
-    this.fillRenderer.computeSizes()
-
-    this.eventRenderer.assignFgSizes()
-    this.fillRenderer.assignSizes()
-  }
-
-
   getTotalSlatHeight() {
     return this.slatContainerEl.offsetHeight
   }
@@ -688,7 +675,6 @@ export default class TimeGrid extends DateComponent {
 }
 
 TimeGrid.prototype.eventRendererClass = TimeGridEventRenderer
-TimeGrid.prototype.businessHourRendererClass = BusinessHourRenderer
 TimeGrid.prototype.helperRendererClass = TimeGridHelperRenderer
 TimeGrid.prototype.fillRendererClass = TimeGridFillRenderer
 

src/agenda/TimeGridEventRenderer.ts

@@ -46,7 +46,7 @@ export default class TimeGridEventRenderer extends EventRenderer {
   }
 
 
-  computeFgSizes() {
+  computeFgSize() {
     let { timeGrid } = this
 
     for (let col = 0; col < timeGrid.colCnt; col++) {
@@ -58,7 +58,7 @@ export default class TimeGridEventRenderer extends EventRenderer {
   }
 
 
-  assignFgSizes() {
+  assignFgSize() {
     let { timeGrid } = this
 
     for (let col = 0; col < timeGrid.colCnt; col++) {

src/agenda/TimeGridFillRenderer.ts

@@ -24,12 +24,12 @@ export default class TimeGridFillRenderer extends FillRenderer {
     })
   }
 
-  computeSizes() {
-    this.component.computeSegVerticals(this.getSegs())
+  computeSize(type) {
+    this.component.computeSegVerticals(this.renderedSegsByType[type])
   }
 
-  assignSizes() {
-    this.component.assignSegVerticals(this.getSegs())
+  assignSize(type) {
+    this.component.assignSegVerticals(this.renderedSegsByType[type])
   }
 
 }

src/basic/BasicView.ts

@@ -152,7 +152,7 @@ export default class BasicView extends View {
 
 
   // Refreshes the horizontal dimensions of the view
-  updateSize(totalHeight, isAuto) {
+  updateBaseSize(totalHeight, isAuto) {
     let { dayGrid } = this
     let eventLimit = this.opt('eventLimit')
     let headRowEl =
@@ -222,8 +222,6 @@ export default class BasicView extends View {
       // guarantees the same scrollbar widths
       this.scroller.lockOverflow(scrollbarWidths)
     }
-
-    super.updateSize(totalHeight, isAuto) // children and now-indicator
   }
 
 

src/basic/DayGrid.ts

@@ -13,7 +13,6 @@ import View from '../View'
 import CoordCache from '../common/CoordCache'
 import Popover from '../common/Popover'
 import UnzonedRange from '../models/UnzonedRange'
-import BusinessHourRenderer from '../component/renderers/BusinessHourRenderer'
 import { default as DayTableMixin, DayTableInterface } from '../component/DayTableMixin'
 import DayGridEventRenderer from './DayGridEventRenderer'
 import DayGridHelperRenderer from './DayGridHelperRenderer'
@@ -288,16 +287,6 @@ export default class DayGrid extends DateComponent {
   }
 
 
-  /* Sizing
-  ------------------------------------------------------------------------------------------------------------------*/
-
-
-  updateSize(totalHeight, isAuto) {
-    super.updateSize(totalHeight, isAuto)
-    this.buildCoordCaches()
-  }
-
-
   /* Hit System
   ------------------------------------------------------------------------------------------------------------------*/
 
@@ -780,7 +769,6 @@ export default class DayGrid extends DateComponent {
 }
 
 DayGrid.prototype.eventRendererClass = DayGridEventRenderer
-DayGrid.prototype.businessHourRendererClass = BusinessHourRenderer
 DayGrid.prototype.helperRendererClass = DayGridHelperRenderer
 DayGrid.prototype.fillRendererClass = DayGridFillRenderer
 

src/component/DateComponent.ts

@@ -54,7 +54,6 @@ export default abstract class DateComponent extends Component {
 
   eventRendererClass: any
   helperRendererClass: any
-  businessHourRendererClass: any
   fillRendererClass: any
 
   uid: any
@@ -65,18 +64,13 @@ export default abstract class DateComponent extends Component {
 
   eventRenderer: any
   helperRenderer: any
-  businessHourRenderer: any
   fillRenderer: any
 
   hasAllDayBusinessHours: boolean = false // TODO: unify with largeUnit and isTimeScale?
 
-  isSkeletonRendered: boolean = false
-  isDatesRendered: boolean = false
-  isBusinessHoursRendered: boolean = false
-  isSelectionRendered: boolean = false
-  isEventsRendered: boolean = false
-  isDragRendered: boolean = false
-  isEventResizeRendered: boolean = false
+  renderedFlags: any = {}
+  dirtySizeFlags: any = {}
+
   dateProfile: DateProfile
   businessHoursDef: BusinessHourDef
   selection: Selection
@@ -113,10 +107,6 @@ export default abstract class DateComponent extends Component {
     if (this.helperRendererClass && this.eventRenderer) {
       this.helperRenderer = new this.helperRendererClass(this, this.eventRenderer)
     }
-
-    if (this.businessHourRendererClass && this.fillRenderer) {
-      this.businessHourRenderer = new this.businessHourRendererClass(this, this.fillRenderer)
-    }
   }
 
 
@@ -148,8 +138,46 @@ export default abstract class DateComponent extends Component {
   }
 
 
-  updateSize(totalHeight, isAuto) {
-    this.callChildren('updateSize', arguments)
+  updateSize(totalHeight, isAuto, force) {
+    let flags = this.dirtySizeFlags
+
+    if (force || flags.skeleton || flags.dates) {
+      this.updateBaseSize(totalHeight, isAuto)
+    }
+
+    this.buildCoordCaches() // do this every time?
+
+    if (force || flags.businessHours) {
+      this.computeBusinessHoursSize()
+    }
+
+    // don't worry about updating the resize of the helper
+    if (force || flags.selection || flags.drag || flags.eventResize) {
+      this.computeHighlightSize()
+    }
+
+    if (force || flags.events) {
+      this.computeEventsSize()
+    }
+
+    if (force || flags.businessHours) {
+      this.assignBusinessHoursSize()
+    }
+
+    if (force || flags.selection || flags.drag || flags.eventResize) {
+      this.assignHighlightSize()
+    }
+
+    if (force || flags.events) {
+      this.assignEventsSize()
+    }
+
+    this.dirtySizeFlags = {}
+    this.callChildren('updateSize', arguments) // always do this at end?
+  }
+
+
+  updateBaseSize(totalHeight, isAuto) {
   }
 
 
@@ -245,134 +273,157 @@ export default abstract class DateComponent extends Component {
 
 
   render(renderState: DateComponentRenderState, forceFlags: RenderForceFlags) {
+    let { renderedFlags } = this
+    let dirtyFlags = {
+      skeleton: false,
+      dates: renderState.dateProfile !== this.dateProfile,
+      businessHours: renderState.businessHoursDef !== this.businessHoursDef,
+      selection: renderState.selection !== this.selection,
+      events: renderState.eventStore !== this.eventStore,
+      selectedEvent: renderState.selectedEventInstanceId !== this.selectedEventInstanceId,
+      drag: renderState.dragState !== this.dragState,
+      eventResize: renderState.eventResizeState !== this.eventResizeState
+    }
+
+    assignTo(dirtyFlags, forceFlags)
+
+    if (forceFlags === true) {
+      // everthing must be marked as dirty when doing a forced resize
+      for (let name in dirtyFlags) {
+        dirtyFlags[name] = true
+      }
+    } else {
 
-    let isSkeletonDirty = forceFlags === true
-    let isDatesDirty = forceFlags === true ||
-      isSkeletonDirty ||
-      renderState.dateProfile !== this.dateProfile
-    let isBusinessHoursDirty = forceFlags === true ||
-      isDatesDirty ||
-      renderState.businessHoursDef !== this.businessHoursDef
-    let isSelectionDirty = forceFlags === true ||
-      isDatesDirty ||
-      renderState.selection !== this.selection
-    let isEventsDirty = forceFlags === true || forceFlags.events ||
-      isDatesDirty ||
-      renderState.eventStore !== this.eventStore
-    let isDragDirty = forceFlags === true ||
-      isDatesDirty ||
-      renderState.dragState !== this.dragState
-    let isEventResizeDirty = forceFlags === true ||
-      isDatesDirty ||
-      renderState.eventResizeState !== this.eventResizeState
-
-    // unrendering
-    if (isEventResizeDirty && this.isEventResizeRendered) {
-      this.unrenderEventResizeState()
-      this.isEventResizeRendered = false
-    }
-    if (isDragDirty && this.isDragRendered) {
-      this.unrenderDragState()
-      this.isDragRendered = false
-    }
-    if (isEventsDirty && this.isEventsRendered) {
-      this.unrenderEvents()
-      this.isEventsRendered = false
-    }
-    if (isSelectionDirty && this.isSelectionRendered) {
-      this.unrenderSelection()
-      this.isSelectionRendered = false
-    }
-    if (isBusinessHoursDirty && this.isBusinessHoursRendered) {
-      this.unrenderBusinessHours()
-      this.isBusinessHoursRendered = false
-    }
-    if (isDatesDirty && this.isDatesRendered) {
-      this.unrenderDates()
-      this.isDatesRendered = false
-    }
-    if (isSkeletonDirty && this.isSkeletonRendered) {
-      this.unrenderSkeleton()
-      this.isSkeletonRendered = false
+      // mark things that are still not rendered as dirty
+      for (let name in dirtyFlags) {
+        if (!renderedFlags[name]) {
+          dirtyFlags[name] = true
+        }
+      }
+
+      // when the dates are dirty, mark nearly everything else as dirty too
+      if (dirtyFlags.dates) {
+        for (let name in dirtyFlags) {
+          if (name !== 'skeleton') {
+            forceFlags = true
+          }
+        }
+      }
     }
 
-    assignTo(this, renderState)
+    this.unrender(dirtyFlags) // only unrender dirty things
+    assignTo(this, renderState) // assign incoming state to local state
+    this.renderByFlag(renderState, dirtyFlags) // only render dirty things
+    this.renderChildren(renderState, forceFlags)
+  }
+
+
+  renderByFlag(renderState: DateComponentRenderState, flags) {
+    let { renderedFlags, dirtySizeFlags } = this
 
-    // rendering
-    if ((isSkeletonDirty || !this.isSkeletonRendered) || !this.isSkeletonRendered) {
+    if (flags.skeleton) {
       this.renderSkeleton()
-      this.isSkeletonRendered = true
+      renderedFlags.skeleton = true
+      dirtySizeFlags.skeleton = true
     }
-    if ((isDatesDirty || !this.isDatesRendered) && renderState.dateProfile) {
+
+    if (flags.dates && renderState.dateProfile) {
       this.renderDates() // pass in dateProfile too?
-      this.isDatesRendered = true
+      renderedFlags.dates = true
+      dirtySizeFlags.dates = true
     }
-    if ((isBusinessHoursDirty || !this.isBusinessHoursRendered) && renderState.businessHoursDef && this.isDatesRendered) {
+
+    if (flags.businessHours && renderState.businessHoursDef) {
       this.renderBusinessHours(renderState.businessHoursDef)
-      this.isBusinessHoursRendered = true
+      renderedFlags.businessHours = true
+      dirtySizeFlags.businessHours = true
     }
-    if ((isSelectionDirty || !this.isSelectionRendered) && renderState.selection && this.isDatesRendered) {
+
+    if (flags.selection && renderState.selection) {
       this.renderSelection(renderState.selection)
-      this.isSelectionRendered = true
+      renderedFlags.selection = true
+      dirtySizeFlags.selection = true
     }
-    if ((isEventsDirty || !this.isEventsRendered) && renderState.eventStore && this.isDatesRendered) {
+
+    if (flags.events && renderState.eventStore) {
       this.renderEvents(renderState.eventStore)
-      this.isEventsRendered = true
+      renderedFlags.events = true
+      dirtySizeFlags.events = true
     }
-    if ((isDragDirty || !this.isDragRendered) && renderState.dragState && this.isDatesRendered) {
-      let { dragState } = renderState
-      this.renderDragState(dragState)
-      this.isDragRendered = true
-    }
-    if ((isEventResizeDirty || !this.isEventResizeRendered) && renderState.eventResizeState && this.isDatesRendered) {
-      let { eventResizeState } = renderState
-      this.renderEventResizeState(eventResizeState)
-      this.isEventResizeRendered = true
-    }
-
-    this.updateSelectedEventInstance(renderState.selectedEventInstanceId)
 
-    this.renderChildren(renderState, forceFlags)
-  }
+    if (flags.selectedEvent) {
+      this.selectEventsByInstanceId(renderState.selectedEventInstanceId)
+      renderedFlags.selectedEvent = true
+      dirtySizeFlags.selectedEvent = true
+    }
 
+    if (flags.drag && renderState.dragState) {
+      this.renderDragState(renderState.dragState)
+      renderedFlags.drag = true
+      dirtySizeFlags.drag = true
+    }
 
-  renderChildren(renderState: DateComponentRenderState, forceFlags: RenderForceFlags) {
-    this.callChildren('render', arguments)
+    if (flags.eventResize && renderState.eventResizeState) {
+      this.renderEventResizeState(renderState.eventResizeState)
+      renderedFlags.eventResize = true
+      dirtySizeFlags.eventResize = true
+    }
   }
 
 
-  removeElement() {
-    this.updateSelectedEventInstance()
+  unrender(flags?: any) {
+    let { renderedFlags } = this
 
-    if (this.isEventResizeRendered) {
-      this.unrenderEventResizeState()
-      this.isEventResizeRendered = false
+    if ((!flags || flags.eventResize) && renderedFlags.eventResize) {
+      this.unrenderEventResize()
+      renderedFlags.eventResize = false
     }
-    if (this.isDragRendered) {
+
+    if ((!flags || flags.drag) && renderedFlags.drag) {
       this.unrenderDragState()
-      this.isDragRendered = false
+      renderedFlags.drag = false
+    }
+
+    if ((!flags || flags.selectedEvent) && renderedFlags.selectedEvent) {
+      this.unselectAllEvents()
+      renderedFlags.selectedEvent = false
     }
-    if (this.isEventsRendered) {
+
+    if ((!flags || flags.events) && renderedFlags.events) {
       this.unrenderEvents()
-      this.isEventsRendered = false
+      renderedFlags.events = false
     }
-    if (this.isSelectionRendered) {
+
+    if ((!flags || flags.selection) && renderedFlags.selection) {
       this.unrenderSelection()
-      this.isSelectionRendered = false
+      renderedFlags.selection = false
     }
-    if (this.isBusinessHoursRendered) {
+
+    if ((!flags || flags.businessHours) && renderedFlags.businessHours) {
       this.unrenderBusinessHours()
-      this.isBusinessHoursRendered = false
+      renderedFlags.businessHours = false
     }
-    if (this.isDatesRendered) {
+
+    if ((!flags || flags.dates) && renderedFlags.dates) {
       this.unrenderDates()
-      this.isDatesRendered = false
+      renderedFlags.dates = false
     }
-    if (this.isSkeletonRendered) {
+
+    if ((!flags || flags.skeleton) && renderedFlags.skeleton) {
       this.unrenderSkeleton()
-      this.isSkeletonRendered = false
+      renderedFlags.skeleton = false
     }
+  }
+
+
+  renderChildren(renderState: DateComponentRenderState, forceFlags: RenderForceFlags) {
+    this.callChildren('render', arguments)
+  }
+
 
+  removeElement() {
+    this.unrender()
+    this.dirtySizeFlags = {}
     super.removeElement()
   }
 
@@ -435,8 +486,9 @@ export default abstract class DateComponent extends Component {
 
 
   renderBusinessHours(businessHoursDef: BusinessHourDef) {
-    if (this.businessHourRenderer) {
-      this.businessHourRenderer.renderSegs(
+    if (this.fillRenderer) {
+      this.fillRenderer.renderSegs(
+        'businessHours',
         this.eventStoreToSegs(
           buildBusinessHourEventStore(
             businessHoursDef,
@@ -444,7 +496,12 @@ export default abstract class DateComponent extends Component {
             this.dateProfile.activeUnzonedRange,
             this.getCalendar()
           )
-        )
+        ),
+        {
+          getClasses(seg) {
+            return [ 'fc-bgevent' ].concat(seg.eventRange.eventDef.className)
+          }
+        }
       )
     }
   }
@@ -452,8 +509,22 @@ export default abstract class DateComponent extends Component {
 
   // Unrenders previously-rendered business-hours
   unrenderBusinessHours() {
-    if (this.businessHourRenderer) {
-      this.businessHourRenderer.unrender()
+    if (this.fillRenderer) {
+      this.fillRenderer.unrender('businessHours')
+    }
+  }
+
+
+  computeBusinessHoursSize() {
+    if (this.fillRenderer) {
+      this.fillRenderer.computeSize('businessHours')
+    }
+  }
+
+
+  assignBusinessHoursSize() {
+    if (this.fillRenderer) {
+      this.fillRenderer.assignSize('businessHours')
     }
   }
 
@@ -481,6 +552,20 @@ export default abstract class DateComponent extends Component {
   }
 
 
+  computeEventsSize() {
+    if (this.eventRenderer) {
+      this.eventRenderer.computeFgSize()
+    }
+  }
+
+
+  assignEventsSize() {
+    if (this.eventRenderer) {
+      this.eventRenderer.assignFgSize()
+    }
+  }
+
+
   // Drag-n-Drop Rendering (for both events and external elements)
   // ---------------------------------------------------------------------------------------------------------------
 
@@ -502,7 +587,6 @@ export default abstract class DateComponent extends Component {
   // Must return elements used for any mock events.
   renderDrag(eventStore: EventStore, origSeg?, isTouch = false) {
     // subclasses can implement
-    // TODO: how to determine if just one child rendered the drag so we don't have to render the helper?
   }
 
 
@@ -599,19 +683,6 @@ export default abstract class DateComponent extends Component {
   // TODO: show/hide according to groupId?
 
 
-  updateSelectedEventInstance(instanceId?) {
-    if (this.selectedEventInstanceId && this.selectedEventInstanceId !== instanceId) {
-      this.unselectAllEvents()
-      this.selectEventsByInstanceId = null
-    }
-
-    if (instanceId && !this.selectedEventInstanceId) {
-      this.selectEventsByInstanceId(instanceId)
-      this.selectedEventInstanceId = instanceId
-    }
-  }
-
-
   selectEventsByInstanceId(instanceId) {
     this.getAllEventSegs().forEach(function(seg) {
       if (
@@ -694,6 +765,20 @@ export default abstract class DateComponent extends Component {
   }
 
 
+  computeHighlightSize() {
+    if (this.fillRenderer) {
+      this.fillRenderer.computeSize('highlight')
+    }
+  }
+
+
+  assignHighlightSize() {
+    if (this.fillRenderer) {
+      this.fillRenderer.assignSize('highlight')
+    }
+  }
+
+
   /* Converting selection/eventRanges -> segs
   ------------------------------------------------------------------------------------------------------------------*/
 

src/component/renderers/BusinessHourRenderer.ts

@@ -1,31 +0,0 @@
-
-export default class BusinessHourRenderer {
-
-  component: any
-  fillRenderer: any
-
-
-  constructor(component, fillRenderer) {
-    this.component = component
-    this.fillRenderer = fillRenderer
-  }
-
-
-  renderSegs(segs) {
-    if (this.fillRenderer) {
-      this.fillRenderer.renderSegs('businessHours', segs, {
-        getClasses(seg) {
-          return [ 'fc-bgevent' ].concat(seg.eventRange.eventDef.className)
-        }
-      })
-    }
-  }
-
-
-  unrender() {
-    if (this.fillRenderer) {
-      this.fillRenderer.unrender('businessHours')
-    }
-  }
-
-}

src/component/renderers/EventRenderer.ts

@@ -474,4 +474,12 @@ export default class EventRenderer {
     return false // TODO
   }
 
+
+  computeFgSize() {
+  }
+
+
+  assignFgSize() {
+  }
+
 }

src/component/renderers/FillRenderer.ts

@@ -102,15 +102,10 @@ export default class FillRenderer { // use for highlight, background events, bus
   }
 
 
-  getSegs() {
-    let { renderedSegsByType } = this
-    let segs = []
-
-    for (let type in renderedSegsByType) {
-      segs.push(...renderedSegsByType[type])
-    }
+  computeSize(type: string) {
+  }
 
-    return segs
+  assignSize(type: string) {
   }
 
 }

src/exports.ts

@@ -83,7 +83,6 @@ export { default as Calendar } from './Calendar'
 export { default as View } from './View'
 export { defineView, getViewConfig } from './ViewRegistry'
 export { default as DayTableMixin } from './component/DayTableMixin'
-export { default as BusinessHourRenderer } from './component/renderers/BusinessHourRenderer'
 export { default as EventRenderer } from './component/renderers/EventRenderer'
 export { default as FillRenderer } from './component/renderers/FillRenderer'
 export { default as HelperRenderer } from './component/renderers/HelperRenderer'

src/list/ListView.ts

@@ -55,9 +55,7 @@ export default class ListView extends View {
   }
 
 
-  updateSize(totalHeight, isAuto) {
-    super.updateSize(totalHeight, isAuto)
-
+  updateBaseSize(totalHeight, isAuto) {
     this.scroller.clear() // sets height to 'auto' and clears overflow
 
     if (!isAuto) {