reselect -> memoize

src/Calendar.ts

@@ -14,7 +14,7 @@ import { createFormatter } from './datelib/formatting'
 import { Duration, createDuration } from './datelib/duration'
 import reduce from './reducers/main'
 import { parseDateSpan, DateSpanInput, DateSpan, buildDateSpanApi, DateSpanApi, buildDatePointApi, DatePointApi } from './structs/date-span'
-import reselector, { memoizeOutput } from './util/reselector'
+import { memoize, memoizeOutput } from './util/memoize'
 import { mapHash, assignTo, isPropsEqual } from './util/object'
 import { DateRangeInput } from './datelib/date-range'
 import DateProfileGenerator from './DateProfileGenerator'
@@ -63,11 +63,11 @@ export default class Calendar {
   triggerWith: EmitterInterface['triggerWith']
   hasHandlers: EmitterInterface['hasHandlers']
 
-  private buildDateEnv = reselector(buildDateEnv)
-  private buildTheme = reselector(buildTheme)
-  private buildEventUiSingleBase = reselector(processScopedUiProps)
+  private buildDateEnv = memoize(buildDateEnv)
+  private buildTheme = memoize(buildTheme)
+  private buildEventUiSingleBase = memoize(processScopedUiProps)
   private buildEventUiBySource = memoizeOutput(buildEventUiBySource, isPropsEqual)
-  private buildEventUiBases = reselector(buildEventUiBases)
+  private buildEventUiBases = memoize(buildEventUiBases)
 
   // strictly for constraint system
   eventUiBases: EventUiHash
@@ -99,7 +99,7 @@ export default class Calendar {
   isRendering: boolean = false // currently in the executeRender function?
   renderingPauseDepth: number = 0
   renderableEventStore: EventStore
-  buildDelayedRerender = reselector(buildDelayedRerender)
+  buildDelayedRerender = memoize(buildDelayedRerender)
   delayedRerender: any
   afterSizingTriggers: any = {}
   isViewUpdated: boolean = false
@@ -1180,7 +1180,7 @@ export default class Calendar {
 EmitterMixin.mixInto(Calendar)
 
 
-// for reselectors
+// for memoizers
 // -----------------------------------------------------------------------------------------------------------------
 
 

src/CalendarComponent.ts

@@ -9,7 +9,7 @@ import { assignTo } from './util/object';
 import { EventStore } from './structs/event-store'
 import { EventUiHash } from './component/event-ui'
 import { BusinessHoursInput, parseBusinessHours } from './structs/business-hours'
-import reselector from './util/reselector'
+import { memoize } from './util/memoize'
 import { computeHeightAndMargins } from './util/dom-geom'
 import { createFormatter } from './datelib/formatting'
 import { diffWholeDays } from './datelib/marker'
@@ -39,7 +39,7 @@ export default class CalendarComponent extends Component<CalendarComponentProps>
   viewHeight: number
 
   private _renderToolbars = memoizeRendering(this.renderToolbars)
-  private buildViewPropTransformers = reselector(buildViewPropTransformers)
+  private buildViewPropTransformers = memoize(buildViewPropTransformers)
 
 
   constructor(context: ComponentContext, el: HTMLElement) {
@@ -54,9 +54,9 @@ export default class CalendarComponent extends Component<CalendarComponentProps>
 
     this.toggleElClassNames(true)
 
-    this.computeTitle = reselector(computeTitle)
+    this.computeTitle = memoize(computeTitle)
 
-    this.parseBusinessHours = reselector((input) => {
+    this.parseBusinessHours = memoize((input) => {
       return parseBusinessHours(input, this.calendar)
     })
   }

src/agenda/AgendaView.ts

@@ -7,7 +7,7 @@ import DaySeries from '../common/DaySeries'
 import DayTable from '../common/DayTable'
 import SimpleTimeGrid from './SimpleTimeGrid'
 import SimpleDayGrid from '../basic/SimpleDayGrid'
-import reselector from '../util/reselector'
+import { memoize } from '../util/memoize'
 import { ViewProps } from '../View'
 import { EMPTY_PROPS } from '../component/event-splitting'
 
@@ -18,7 +18,7 @@ export default class AgendaView extends AbstractAgendaView {
   simpleDayGrid: SimpleDayGrid
   simpleTimeGrid: SimpleTimeGrid
 
-  private buildDayTable = reselector(buildDayTable)
+  private buildDayTable = memoize(buildDayTable)
 
   constructor(
     _context: ComponentContext,

src/agenda/SimpleTimeGrid.ts

@@ -5,7 +5,7 @@ import { EventStore } from '../structs/event-store'
 import { EventUiHash } from '../component/event-ui'
 import { EventInteractionState } from '../interactions/event-interaction-state'
 import { DateSpan } from '../structs/date-span'
-import reselector from '../util/reselector'
+import { memoize } from '../util/memoize'
 import { intersectRanges, DateRange } from '../datelib/date-range'
 import DayTable from '../common/DayTable'
 import { DateEnv } from '../datelib/env'
@@ -31,7 +31,7 @@ export default class SimpleTimeGrid extends DateComponent<SimpleTimeGridProps> {
   timeGrid: TimeGrid
   offsetTracker: OffsetTracker
 
-  private buildDayRanges = reselector(buildDayRanges)
+  private buildDayRanges = memoize(buildDayRanges)
   private dayRanges: DateRange[] // for now indicator
   private slicer = new TimeGridSlicer()
 

src/basic/BasicView.ts

@@ -5,7 +5,7 @@ import { ComponentContext } from '../component/Component'
 import { ViewSpec } from '../structs/view-spec'
 import DateProfileGenerator, { DateProfile } from '../DateProfileGenerator'
 import { ViewProps } from '../View'
-import reselector from '../util/reselector'
+import { memoize } from '../util/memoize'
 import DaySeries from '../common/DaySeries'
 import DayTable from '../common/DayTable'
 
@@ -15,7 +15,7 @@ export default class BasicView extends AbstractBasicView {
   simpleDayGrid: SimpleDayGrid
   dayTable: DayTable
 
-  private buildDayTable = reselector(buildDayTable)
+  private buildDayTable = memoize(buildDayTable)
 
   constructor(_context: ComponentContext, viewSpec: ViewSpec, dateProfileGenerator: DateProfileGenerator, parentEl: HTMLElement) {
     super(_context, viewSpec, dateProfileGenerator, parentEl)

src/common/slicing-utils.ts

@@ -8,7 +8,7 @@ import { DateSpan, fabricateEventRange } from '../structs/date-span'
 import { EventInteractionState } from '../interactions/event-interaction-state'
 import DateComponent from '../component/DateComponent'
 import { Duration } from '../datelib/duration'
-import reselector from '../util/reselector'
+import { memoize } from '../util/memoize'
 import { DateMarker, addMs } from '../datelib/marker'
 
 export interface SliceableProps {
@@ -33,11 +33,11 @@ export interface SlicedProps<SegType extends Seg> {
 
 export default abstract class Slicer<SegType extends Seg, ExtraArgs extends any[] = []> {
 
-  private sliceBusinessHours = reselector(this._sliceBusinessHours)
-  private sliceDateSelection = reselector(this._sliceDateSpan)
-  private sliceEventStore = reselector(this._sliceEventStore)
-  private sliceEventDrag = reselector(this._sliceInteraction)
-  private sliceEventResize = reselector(this._sliceInteraction)
+  private sliceBusinessHours = memoize(this._sliceBusinessHours)
+  private sliceDateSelection = memoize(this._sliceDateSpan)
+  private sliceEventStore = memoize(this._sliceEventStore)
+  private sliceEventDrag = memoize(this._sliceInteraction)
+  private sliceEventResize = memoize(this._sliceInteraction)
 
   abstract sliceRange(dateRange: DateRange, ...extraArgs: ExtraArgs): SegType[]
 

src/component/event-splitting.ts

@@ -2,7 +2,7 @@ import { EventStore, createEmptyEventStore } from '../structs/event-store'
 import { EventDef } from '../structs/event'
 import { EventInteractionState } from '../interactions/event-interaction-state'
 import { mapHash } from '../util/object'
-import reselector from '../util/reselector'
+import { memoize } from '../util/memoize'
 import { EventUiHash, EventUi, combineEventUis } from './event-ui'
 import { DateSpan } from '../structs/date-span'
 
@@ -28,12 +28,12 @@ export const EMPTY_PROPS: SplittableProps = {
 
 export default abstract class Splitter<PropsType extends SplittableProps = SplittableProps> {
 
-  private getKeysForEventDefs = reselector(this._getKeysForEventDefs)
-  private splitDateSelection = reselector(this._splitDateSpan)
-  private splitEventStore = reselector(this._splitEventStore)
-  private splitEventUiBases = reselector(this._splitEventUiBases)
-  private splitEventDrag = reselector(this._splitInteraction)
-  private splitEventResize = reselector(this._splitInteraction)
+  private getKeysForEventDefs = memoize(this._getKeysForEventDefs)
+  private splitDateSelection = memoize(this._splitDateSpan)
+  private splitEventStore = memoize(this._splitEventStore)
+  private splitEventUiBases = memoize(this._splitEventUiBases)
+  private splitEventDrag = memoize(this._splitInteraction)
+  private splitEventResize = memoize(this._splitInteraction)
   protected keyEventUiMergers: { [key: string]: typeof mergeKeyEventUi } = {}
 
   abstract getKeysForDateSpan(dateSpan: DateSpan): string[]
@@ -59,7 +59,7 @@ export default abstract class Splitter<PropsType extends SplittableProps = Split
     let populate = function(key: string) {
       if (!splitProps[key]) {
         let eventStore = eventStores[key] || EMPTY_PROPS.eventStore
-        keyEventUiMergers[key] = oldKeyEventUiMergers[key] || reselector(mergeKeyEventUi)
+        keyEventUiMergers[key] = oldKeyEventUiMergers[key] || memoize(mergeKeyEventUi)
 
         splitProps[key] = {
           dateSelection: dateSelections[key] || null,

src/datelib/formatting-native.ts

@@ -3,7 +3,7 @@ import { DateMarker, timeAsMs } from './marker'
 import { CalendarSystem } from './calendar-system'
 import { Locale } from './locale'
 import { DateFormatter, DateFormattingContext, ZonedMarker, formatTimeZoneOffset } from './formatting'
-import reselector from '../util/reselector'
+import { memoize } from '../util/memoize'
 
 const EXTENDED_SETTINGS_AND_SEVERITIES = {
   week: 3,
@@ -60,7 +60,7 @@ export class NativeFormatter implements DateFormatter {
     this.extendedSettings = extendedSettings
     this.severity = severity
 
-    this.buildFormattingFunc = reselector(buildFormattingFunc)
+    this.buildFormattingFunc = memoize(buildFormattingFunc)
   }
 
   format(date: ZonedMarker, context: DateFormattingContext) {

src/exports.ts

@@ -36,7 +36,7 @@ export {
   isArraysEqual
 } from './util/array'
 
-export { default as reselector, memoizeOutput } from './util/reselector'
+export { memoize, memoizeOutput } from './util/memoize'
 export { memoizeRendering, MemoizedRendering } from './component/memoized-rendering'
 
 export {

src/list/ListView.ts

@@ -14,7 +14,7 @@ import { ViewSpec } from '../structs/view-spec'
 import { EventUiHash } from '../component/event-ui'
 import { EventRenderRange, sliceEventStore } from '../component/event-rendering'
 import { EventStore } from '../structs/event-store'
-import reselector from '../util/reselector'
+import { memoize } from '../util/memoize'
 import { MemoizedRendering, memoizeRendering } from '../component/memoized-rendering'
 import { Seg } from '../component/DateComponent'
 
@@ -28,8 +28,8 @@ export default class ListView extends View {
 
   dayDates: DateMarker[] // TOOD: kill this. only have it because ListEventRenderer
 
-  private computeDateVars = reselector(computeDateVars)
-  private eventStoreToSegs = reselector(this._eventStoreToSegs)
+  private computeDateVars = memoize(computeDateVars)
+  private eventStoreToSegs = memoize(this._eventStoreToSegs)
   private renderContent: MemoizedRendering<[Seg[]]>
 
 

src/util/memoize.ts

@@ -0,0 +1,33 @@
+import { isArraysEqual } from './array'
+
+export function memoize<T>(workerFunc: T): T {
+  let args
+  let res
+
+  return function() {
+    if (!args || !isArraysEqual(args, arguments)) {
+      args = arguments
+      res = (workerFunc as any).apply(this, arguments)
+    }
+
+    return res
+  } as any
+}
+
+/*
+always executes the workerFunc, but if the result is equal to the previous result,
+return the previous result instead.
+*/
+export function memoizeOutput<T>(workerFunc: T, equalityFunc: (output0, output1) => boolean): T {
+  let cachedRes = null
+
+  return function() {
+    let newRes = (workerFunc as any).apply(this, arguments)
+
+    if (cachedRes === null || !(cachedRes === newRes || equalityFunc(cachedRes, newRes))) {
+      cachedRes = newRes
+    }
+
+    return cachedRes
+  } as any
+}

src/util/reselector.ts

@@ -1,33 +0,0 @@
-import { isArraysEqual } from './array'
-
-// TODO: eliminate use of equalityFuncs
-export default function<T>(workerFunc: T): T {
-  let args
-  let res
-
-  return function() {
-    if (!args || !isArraysEqual(args, arguments)) {
-      args = arguments
-      res = (workerFunc as any).apply(this, arguments)
-    }
-
-    return res
-  } as any
-}
-
-export function memoizeOutput<ArgsType extends any[], OutputType>(
-  workerFunc: (...args: ArgsType) => OutputType,
-  equalityFunc: (output0: OutputType, output1: OutputType) => boolean
-): typeof workerFunc {
-  let res = null // cachedRes
-
-  return function() {
-    let newRes = workerFunc.apply(this, arguments)
-
-    if (res === null || !(res === newRes || equalityFunc(res, newRes))) {
-      res = newRes
-    }
-
-    return res
-  }
-}