tweaks

src/common/GlobalContext.ts

@@ -1,5 +1,5 @@
 import DateComponent from '../component/DateComponent'
-import PointerDragListener from '../dnd/PointerDragListener'
+import PointerDragging from '../dnd/PointerDragging'
 import DateClicking from '../interactions/DateClicking'
 import DateSelecting from '../interactions/DateSelecting'
 import EventClicking from '../interactions/EventClicking'
@@ -12,7 +12,7 @@ import Calendar from '../Calendar'
 
 export class GlobalContext { // TODO: rename file to something better
 
-  pointerUpListener: PointerDragListener
+  pointer: PointerDragging
   componentCnt: number = 0
   componentHash = {}
   listenerHash = {}
@@ -40,14 +40,14 @@ export class GlobalContext { // TODO: rename file to something better
   }
 
   bind() {
-    let pointerUpListener = this.pointerUpListener = new PointerDragListener(document as any)
-    pointerUpListener.shouldIgnoreMove = true
-    pointerUpListener.emitter.on('pointerup', this.onPointerUp)
+    let pointer = this.pointer = new PointerDragging(document as any)
+    pointer.shouldIgnoreMove = true
+    pointer.emitter.on('pointerup', this.onPointerUp)
   }
 
   unbind() {
-    this.pointerUpListener.destroy()
-    this.pointerUpListener = null
+    this.pointer.destroy()
+    this.pointer = null
   }
 
   bindComponent(component: DateComponent) {
@@ -76,7 +76,7 @@ export class GlobalContext { // TODO: rename file to something better
 
   onPointerUp = (ev) => {
     let { listenerHash } = this
-    let { wasTouchScroll, downEl } = this.pointerUpListener
+    let { wasTouchScroll, downEl } = this.pointer
 
     for (let id in listenerHash) {
       listenerHash[id].dateSelecting.onDocumentPointerUp(ev, wasTouchScroll, downEl)

src/dnd/DragMirror.ts

@@ -1,12 +1,12 @@
-import { IntentfulDragListener } from '../dnd/IntentfulDragListener'
-import { PointerDragEvent } from '../dnd/PointerDragListener'
+import ElementDragging from '../dnd/ElementDragging'
+import { PointerDragEvent } from '../dnd/PointerDragging'
 import { removeElement, applyStyle } from '../util/dom-manip'
 import { computeRect } from '../util/dom-geom'
 import { whenTransitionDone } from '../util/dom-event'
 
 export default class DragMirror {
 
-  dragListener: IntentfulDragListener
+  dragging: ElementDragging
   isEnabled: boolean = false
   pointerDownX: number
   pointerDownY: number
@@ -20,19 +20,19 @@ export default class DragMirror {
   isReverting: boolean = false
   revertDoneCallback: any
 
-  constructor(dragListener: IntentfulDragListener) {
-    this.dragListener = dragListener
-    dragListener.on('pointerdown', this.onPointerDown)
-    dragListener.on('dragstart', this.onDragStart)
-    dragListener.on('dragmove', this.onDragMove)
-    dragListener.on('pointerup', this.onPointerUp)
+  constructor(dragging: ElementDragging) {
+    this.dragging = dragging
+    dragging.emitter.on('pointerdown', this.onPointerDown)
+    dragging.emitter.on('dragstart', this.onDragStart)
+    dragging.emitter.on('dragmove', this.onDragMove)
+    dragging.emitter.on('pointerup', this.onPointerUp)
   }
 
   enable() {
     if (!this.isEnabled) {
       this.isEnabled = true
 
-      if (this.dragListener.isDragging) {
+      if (this.dragging.isDragging) {
 
         if (this.mirrorEl) {
           this.mirrorEl.style.display = ''

src/dnd/HitDragListener.ts

@@ -1,6 +1,6 @@
 import EmitterMixin from '../common/EmitterMixin'
-import { PointerDragEvent } from './PointerDragListener'
-import { IntentfulDragListener } from './IntentfulDragListener'
+import { PointerDragEvent } from './PointerDragging'
+import ElementDragging from './ElementDragging'
 import DateComponent, { DateComponentHash } from '../component/DateComponent'
 import { Selection } from '../reducers/selection'
 import { computeRect } from '../util/dom-geom'
@@ -22,7 +22,7 @@ fires (none will be fired if no initial hit):
 export default class HitDragListener {
 
   droppableHash: DateComponentHash
-  dragListener: IntentfulDragListener
+  dragging: ElementDragging
   emitter: EmitterMixin
   initialHit: Hit
   movingHit: Hit
@@ -34,7 +34,7 @@ export default class HitDragListener {
   // options
   subjectCenter: boolean = false
 
-  constructor(dragListener: IntentfulDragListener, droppable: DateComponent | DateComponentHash) {
+  constructor(dragging: ElementDragging, droppable: DateComponent | DateComponentHash) {
 
     if (droppable instanceof DateComponent) {
       this.droppableHash = { [droppable.uid]: droppable }
@@ -42,18 +42,18 @@ export default class HitDragListener {
       this.droppableHash = droppable
     }
 
-    dragListener.on('pointerdown', this.onPointerDown)
-    dragListener.on('dragstart', this.onDragStart)
-    dragListener.on('dragmove', this.onDragMove)
-    dragListener.on('pointerup', this.onPointerUp)
-    dragListener.on('dragend', this.onDragEnd)
+    dragging.emitter.on('pointerdown', this.onPointerDown)
+    dragging.emitter.on('dragstart', this.onDragStart)
+    dragging.emitter.on('dragmove', this.onDragMove)
+    dragging.emitter.on('pointerup', this.onPointerUp)
+    dragging.emitter.on('dragend', this.onDragEnd)
 
-    this.dragListener = dragListener
+    this.dragging = dragging
     this.emitter = new EmitterMixin()
   }
 
   destroy() {
-    this.dragListener.destroy() // should not be responsible for destroying!
+    this.dragging.destroy() // should not be responsible for destroying!
   }
 
   on(name, handler) {
@@ -68,15 +68,15 @@ export default class HitDragListener {
     this.prepareComponents()
     this.processFirstCoord(ev)
 
-    let { dragListener } = this
+    let { dragging } = this
 
     if (this.initialHit || !this.dieIfNoInitial) {
       this.isIgnoringMove = false
-      dragListener.setIgnoreMove(false)
+      dragging.setIgnoreMove(false)
       this.emitter.trigger('pointerdown', ev)
     } else {
       this.isIgnoringMove = true
-      dragListener.setIgnoreMove(true)
+      dragging.setIgnoreMove(true)
     }
   }
 

src/dnd/IntentfulDragListener.ts

@@ -1,208 +0,0 @@
-import { default as EmitterMixin } from '../common/EmitterMixin'
-import { default as PointerDragListener, PointerDragEvent } from './PointerDragListener'
-import { preventSelection, allowSelection, preventContextMenu, allowContextMenu } from '../util/misc'
-import DragMirror from './DragMirror'
-
-/* needs events:
-- pointerdown
-- dragstart
-- dragmove
-- pointerup
-- dragend
-*/
-export interface IntentfulDragListener {
-  isDragging: boolean
-  on(evName: string, callback: (ev: PointerDragEvent) => void)
-  setMirrorNeedsRevert(bool: boolean)
-  enableMirror()
-  disableMirror()
-  setIgnoreMove(bool: boolean)
-  destroy()
-}
-
-/*
-fires:
-- pointerdown
-- dragstart
-- dragmove
-- pointermove
-- pointerup (always happens before dragend!)
-- dragend (happens after any revert animation)
-*/
-export class IntentfulDragListenerImpl implements IntentfulDragListener {
-
-  pointerListener: PointerDragListener
-  emitter: EmitterMixin
-  dragMirror: DragMirror // TODO: move out of here?
-
-  // options
-  delay: number
-  minDistance: number = 0
-  touchScrollAllowed: boolean = true
-
-  isWatchingPointer: boolean = false
-  isDragging: boolean = false // is it INTENTFULLY dragging? lasts until after revert animation // TODO: exclude revert anim?
-  isDelayEnded: boolean = false
-  isDistanceSurpassed: boolean = false
-
-  delayTimeoutId: number
-  origX: number
-  origY: number
-
-  constructor(containerEl: HTMLElement) {
-    this.emitter = new EmitterMixin()
-    this.dragMirror = new DragMirror(this)
-
-    let pointerListener = this.pointerListener = new PointerDragListener(containerEl)
-    pointerListener.emitter.on('pointerdown', this.onPointerDown)
-    pointerListener.emitter.on('pointermove', this.onPointerMove)
-    pointerListener.emitter.on('pointerup', this.onPointerUp)
-  }
-
-  destroy() {
-    this.pointerListener.destroy()
-  }
-
-  on(name, handler) {
-    this.emitter.on(name, handler)
-  }
-
-  onPointerDown = (ev: PointerDragEvent) => {
-    if (!this.isDragging) { // mainly so new drag doesn't happen while revert animation is going
-      this.isWatchingPointer = true
-      this.isDelayEnded = false
-      this.isDistanceSurpassed = false
-
-      preventSelection(document.body)
-      preventContextMenu(document.body)
-
-      this.origX = ev.pageX
-      this.origY = ev.pageY
-
-      this.emitter.trigger('pointerdown', ev)
-
-      // if moving is being ignored, don't fire any initial drag events
-      if (!this.pointerListener.shouldIgnoreMove) {
-        // actions that could fire dragstart...
-
-        this.startDelay(ev)
-
-        if (!this.minDistance) {
-          this.handleDistanceSurpassed(ev)
-        }
-      }
-    }
-  }
-
-  onPointerMove = (ev: PointerDragEvent) => {
-    if (this.isWatchingPointer) { // if false, still waiting for previous drag's revert
-      this.emitter.trigger('pointermove', ev)
-
-      if (!this.isDistanceSurpassed) {
-        let dx = ev.pageX - this.origX
-        let dy = ev.pageY - this.origY
-        let minDistance = this.minDistance
-        let distanceSq // current distance from the origin, squared
-
-        distanceSq = dx * dx + dy * dy
-        if (distanceSq >= minDistance * minDistance) { // use pythagorean theorem
-          this.handleDistanceSurpassed(ev)
-        }
-      }
-
-      if (this.isDragging) {
-        this.emitter.trigger('dragmove', ev)
-      }
-    }
-  }
-
-  onPointerUp = (ev: PointerDragEvent) => {
-    if (this.isWatchingPointer) { // if false, still waiting for previous drag's revert
-      this.isWatchingPointer = false
-
-      this.emitter.trigger('pointerup', ev) // can potentially set needsRevert
-
-      if (this.isDragging) {
-        this.tryStopDrag(ev)
-      }
-
-      allowSelection(document.body)
-      allowContextMenu(document.body)
-
-      if (this.delayTimeoutId) {
-        clearTimeout(this.delayTimeoutId)
-        this.delayTimeoutId = null
-      }
-    }
-  }
-
-  startDelay(ev: PointerDragEvent) {
-    if (typeof this.delay === 'number') {
-      this.delayTimeoutId = setTimeout(() => {
-        this.delayTimeoutId = null
-        this.handleDelayEnd(ev)
-      }, this.delay)
-    } else {
-      this.handleDelayEnd(ev)
-    }
-  }
-
-  handleDelayEnd(ev: PointerDragEvent) {
-    this.isDelayEnded = true
-    this.tryStartDrag(ev)
-  }
-
-  handleDistanceSurpassed(ev: PointerDragEvent) {
-    this.isDistanceSurpassed = true
-    this.tryStartDrag(ev)
-  }
-
-  tryStartDrag(ev: PointerDragEvent) {
-    if (this.isDelayEnded && this.isDistanceSurpassed) {
-      if (!this.pointerListener.wasTouchScroll || this.touchScrollAllowed) {
-        this.isDragging = true
-        this.emitter.trigger('dragstart', ev)
-
-        if (this.touchScrollAllowed === false) {
-          this.pointerListener.cancelTouchScroll()
-        }
-      }
-    }
-  }
-
-  tryStopDrag(ev) {
-    let stopDrag = this.stopDrag.bind(this, ev) // bound with args
-
-    if (this.dragMirror.isReverting) {
-      this.dragMirror.revertDoneCallback = stopDrag // will clear itself
-    } else {
-      // HACK - we want to make sure dragend fires after all pointerup events.
-      // Without doing this hack, pointer-up event propogation might reach an ancestor
-      // node after dragend
-      setTimeout(stopDrag, 0)
-    }
-  }
-
-  stopDrag(ev) {
-    this.isDragging = false // go first because DragMirror::enable relies on it :(
-    this.emitter.trigger('dragend', ev)
-  }
-
-
-  enableMirror() {
-    this.dragMirror.enable()
-  }
-
-  disableMirror() {
-    this.dragMirror.disable()
-  }
-
-  setMirrorNeedsRevert(bool: boolean) {
-    this.dragMirror.needsRevert = bool
-  }
-
-  setIgnoreMove(bool: boolean) {
-    this.pointerListener.shouldIgnoreMove = bool
-  }
-
-}

src/dnd/PointerDragListener.ts → src/dnd/PointerDragging.ts

@@ -18,7 +18,7 @@ emitted events:
 - pointermove
 - pointerup
 */
-export default class PointerDragListener {
+export default class PointerDragging {
 
   containerEl: HTMLElement
   subjectEl: HTMLElement

src/exports.ts

@@ -109,8 +109,8 @@ export { parse as parseMarker } from './datelib/parsing'
 export { registerSourceType } from './reducers/event-sources'
 export { refineProps } from './reducers/utils'
 
-export { default as PointerDragListener, PointerDragEvent } from './dnd/PointerDragListener'
-export { IntentfulDragListener } from './dnd/IntentfulDragListener'
+export { default as PointerDragging, PointerDragEvent } from './dnd/PointerDragging'
+export { default as ElementDragging } from './dnd/ElementDragging'
 
 export { default as ExternalDraggableEvent } from './interactions/ExternalDraggableEvent'
 export { default as ExternalDragging } from './interactions/ExternalDragging'

src/interactions/DateClicking.ts

@@ -1,37 +1,37 @@
 import DateComponent from '../component/DateComponent'
-import { IntentfulDragListenerImpl } from '../dnd/IntentfulDragListener'
+import FeaturefulElementDragging from '../dnd/FeaturefulElementDragging'
 import HitDragListener, { isHitsEqual } from '../dnd/HitDragListener'
-import { PointerDragEvent } from '../dnd/PointerDragListener'
+import { PointerDragEvent } from '../dnd/PointerDragging'
 
 export default class DateClicking {
 
   component: DateComponent
-  dragListener: IntentfulDragListenerImpl
+  dragging: FeaturefulElementDragging
   hitListener: HitDragListener
 
   constructor(component: DateComponent) {
     this.component = component
-    this.dragListener = new IntentfulDragListenerImpl(component.el)
-    this.hitListener = new HitDragListener(this.dragListener, component)
+    this.dragging = new FeaturefulElementDragging(component.el)
+    this.hitListener = new HitDragListener(this.dragging, component)
     this.hitListener.on('pointerdown', this.onPointerDown)
     this.hitListener.on('dragend', this.onDragEnd)
   }
 
   onPointerDown = (ev: PointerDragEvent) => {
     let { component } = this
-    let { pointerListener } = this.dragListener
+    let { pointer } = this.dragging
 
     // do this in pointerdown (not dragend) because DOM might be mutated by the time dragend is fired
-    pointerListener.shouldIgnoreMove = !component.isValidDateInteraction(pointerListener.downEl)
+    pointer.shouldIgnoreMove = !component.isValidDateInteraction(pointer.downEl)
   }
 
   onDragEnd = (ev: PointerDragEvent) => {
     let { component } = this
-    let { pointerListener } = this.dragListener
+    let { pointer } = this.dragging
 
     if (
-      !pointerListener.shouldIgnoreMove && // not ignored in onPointerDown
-      !pointerListener.wasTouchScroll
+      !pointer.shouldIgnoreMove && // not ignored in onPointerDown
+      !pointer.wasTouchScroll
     ) {
       let { initialHit, finalHit } = this.hitListener
 

src/interactions/DateSelecting.ts

@@ -4,15 +4,15 @@ import DateComponent from '../component/DateComponent'
 import HitDragListener, { Hit } from '../dnd/HitDragListener'
 import { Selection } from '../reducers/selection'
 import UnzonedRange from '../models/UnzonedRange'
-import { PointerDragEvent } from '../dnd/PointerDragListener'
-import { IntentfulDragListenerImpl } from '../dnd/IntentfulDragListener'
+import { PointerDragEvent } from '../dnd/PointerDragging'
+import FeaturefulElementDragging from '../dnd/FeaturefulElementDragging'
 import { GlobalContext } from '../common/GlobalContext'
 
 export default class DateSelecting {
 
   component: DateComponent
   globalContext: GlobalContext
-  dragListener: IntentfulDragListenerImpl
+  dragging: FeaturefulElementDragging
   hitListener: HitDragListener
   dragSelection: Selection
 
@@ -20,10 +20,10 @@ export default class DateSelecting {
     this.component = component
     this.globalContext = globalContext
 
-    this.dragListener = new IntentfulDragListenerImpl(component.el)
-    this.dragListener.touchScrollAllowed = false
+    this.dragging = new FeaturefulElementDragging(component.el)
+    this.dragging.touchScrollAllowed = false
 
-    let hitListener = this.hitListener = new HitDragListener(this.dragListener, component)
+    let hitListener = this.hitListener = new HitDragListener(this.dragging, component)
     hitListener.on('pointerdown', this.onPointerDown)
     hitListener.on('dragstart', this.onDragStart)
     hitListener.on('hitover', this.onHitOver)
@@ -35,14 +35,14 @@ export default class DateSelecting {
   }
 
   onPointerDown = (ev: PointerDragEvent) => {
-    let { component, dragListener } = this
+    let { component, dragging } = this
     let isValid = component.opt('selectable') &&
       component.isValidDateInteraction(ev.origEvent.target as HTMLElement)
 
     // don't bother to watch expensive moves if component won't do selection
-    dragListener.pointerListener.shouldIgnoreMove = !isValid
+    dragging.pointer.shouldIgnoreMove = !isValid
 
-    dragListener.delay = (isValid && ev.isTouch) ?
+    dragging.delay = (isValid && ev.isTouch) ?
       getComponentDelay(component) :
       null
   }

src/interactions/EventDragging.ts

@@ -1,17 +1,17 @@
 import { default as DateComponent, Seg } from '../component/DateComponent'
-import { PointerDragEvent } from '../dnd/PointerDragListener'
+import { PointerDragEvent } from '../dnd/PointerDragging'
 import HitDragListener, { isHitsEqual, Hit } from '../dnd/HitDragListener'
 import { EventMutation, diffDates, getRelatedEvents, applyMutationToAll } from '../reducers/event-mutation'
 import { GlobalContext } from '../common/GlobalContext'
 import { startOfDay } from '../datelib/marker'
 import { elementClosest } from '../util/dom-manip'
-import { IntentfulDragListenerImpl } from '../dnd/IntentfulDragListener'
+import FeaturefulElementDragging from '../dnd/FeaturefulElementDragging'
 
 export default class EventDragging {
 
   component: DateComponent
   globalContext: GlobalContext // need this as a member?
-  dragListener: IntentfulDragListenerImpl
+  dragging: FeaturefulElementDragging
   hitListener: HitDragListener
   draggingSeg: Seg
   mutation: EventMutation
@@ -20,11 +20,11 @@ export default class EventDragging {
     this.component = component
     this.globalContext = globalContext
 
-    this.dragListener = new IntentfulDragListenerImpl(component.el)
-    this.dragListener.pointerListener.selector = '.fc-draggable'
-    this.dragListener.touchScrollAllowed = false
+    this.dragging = new FeaturefulElementDragging(component.el)
+    this.dragging.pointer.selector = '.fc-draggable'
+    this.dragging.touchScrollAllowed = false
 
-    let hitListener = this.hitListener = new HitDragListener(this.dragListener, globalContext.componentHash)
+    let hitListener = this.hitListener = new HitDragListener(this.dragging, globalContext.componentHash)
     hitListener.subjectCenter = true
     hitListener.on('pointerdown', this.onPointerDown)
     hitListener.on('dragstart', this.onDragStart)
@@ -38,16 +38,16 @@ export default class EventDragging {
   }
 
   onPointerDown = (ev: PointerDragEvent) => {
-    let { dragListener } = this
+    let { dragging } = this
 
-    dragListener.delay = this.computeDragDelay(ev)
+    dragging.delay = this.computeDragDelay(ev)
 
     // to prevent from cloning the sourceEl before it is selected
-    dragListener.dragMirror.disable()
+    dragging.dragMirror.disable()
 
     let origTarget = ev.origEvent.target as HTMLElement
 
-    dragListener.pointerListener.shouldIgnoreMove =
+    dragging.pointer.shouldIgnoreMove =
       !this.component.isValidSegInteraction(origTarget) ||
       elementClosest(origTarget, '.fc-resizer')
   }
@@ -112,7 +112,7 @@ export default class EventDragging {
       }
     })
 
-    let { dragMirror } = this.dragListener
+    let { dragMirror } = this.dragging
 
     // TODO wish we could somehow wait for dispatch to guarantee render
     if (!document.querySelector('.fc-helper')) {
@@ -142,7 +142,7 @@ export default class EventDragging {
       }
     })
 
-    let { dragMirror } = this.dragListener
+    let { dragMirror } = this.dragging
 
     dragMirror.enable()
     dragMirror.needsRevert = true

src/interactions/EventResizing.ts

@@ -3,13 +3,13 @@ import HitDragListener, { isHitsEqual, Hit } from '../dnd/HitDragListener'
 import { EventMutation, diffDates, getRelatedEvents, applyMutationToAll } from '../reducers/event-mutation'
 import { elementClosest } from '../util/dom-manip'
 import UnzonedRange from '../models/UnzonedRange'
-import { IntentfulDragListenerImpl } from '../dnd/IntentfulDragListener'
-import { PointerDragEvent } from '../dnd/PointerDragListener'
+import FeaturefulElementDragging from '../dnd/FeaturefulElementDragging'
+import { PointerDragEvent } from '../dnd/PointerDragging'
 
 export default class EventDragging {
 
   component: DateComponent
-  dragListener: IntentfulDragListenerImpl
+  dragging: FeaturefulElementDragging
   hitListener: HitDragListener
   draggingSeg: Seg
   mutation: EventMutation
@@ -17,11 +17,11 @@ export default class EventDragging {
   constructor(component: DateComponent) {
     this.component = component
 
-    this.dragListener = new IntentfulDragListenerImpl(component.el)
-    this.dragListener.pointerListener.selector = '.fc-resizer'
-    this.dragListener.touchScrollAllowed = false
+    this.dragging = new FeaturefulElementDragging(component.el)
+    this.dragging.pointer.selector = '.fc-resizer'
+    this.dragging.touchScrollAllowed = false
 
-    let hitListener = this.hitListener = new HitDragListener(this.dragListener, component)
+    let hitListener = this.hitListener = new HitDragListener(this.dragging, component)
     hitListener.on('pointerdown', this.onPointerDown)
     hitListener.on('dragstart', this.onDragStart)
     hitListener.on('hitover', this.onHitOver)
@@ -38,7 +38,7 @@ export default class EventDragging {
     let eventInstanceId = seg.eventRange.eventInstance.instanceId
 
     // if touch, need to be working with a selected event
-    this.dragListener.pointerListener.shouldIgnoreMove =
+    this.dragging.pointer.shouldIgnoreMove =
       !this.component.isValidSegInteraction(ev.origEvent.target) ||
       (ev.isTouch && this.component.selectedEventInstanceId !== eventInstanceId)
   }

src/interactions/ExternalDraggableEvent.ts

@@ -1,4 +1,4 @@
-import { IntentfulDragListenerImpl } from '../dnd/IntentfulDragListener'
+import FeaturefulElementDragging from '../dnd/FeaturefulElementDragging'
 import ExternalDragging from './ExternalDragging'
 
 export interface ExternalDraggableEventSettings {
@@ -11,7 +11,7 @@ export default class ExternalDraggableEvent {
   externalDragging: ExternalDragging
 
   constructor(settings: ExternalDraggableEventSettings) {
-    let dragListener = new IntentfulDragListenerImpl(settings.el)
+    let dragListener = new FeaturefulElementDragging(settings.el)
     this.externalDragging = new ExternalDragging(dragListener, settings.event)
   }
 

src/interactions/ExternalDragging.ts

@@ -1,7 +1,7 @@
-import { IntentfulDragListener } from '../dnd/IntentfulDragListener'
+import ElementDragging from '../dnd/ElementDragging'
 import HitDragListener, { Hit } from '../dnd/HitDragListener'
 import globalContext from '../common/GlobalContext'
-import { PointerDragEvent } from '../dnd/PointerDragListener'
+import { PointerDragEvent } from '../dnd/PointerDragging'
 import { EventStore, parseDef, createInstance } from '../reducers/event-store'
 import UnzonedRange from '../models/UnzonedRange'
 import * as externalHooks from '../exports'
@@ -15,15 +15,15 @@ export default class ExternalDragging {
   explicitEventCreationData: any
   eventCreationData: any
 
-  constructor(dragListener: IntentfulDragListener, rawEventCreationData?) {
-    let hitListener = this.hitListener = new HitDragListener(dragListener, globalContext.componentHash)
+  constructor(dragging: ElementDragging, rawEventCreationData?) {
+    let hitListener = this.hitListener = new HitDragListener(dragging, globalContext.componentHash)
     hitListener.dieIfNoInitial = false
     hitListener.on('dragstart', this.onDragStart)
     hitListener.on('hitover', this.onHitOver)
     hitListener.on('hitout', this.onHitOut)
     hitListener.on('dragend', this.onDragEnd)
 
-    dragListener.enableMirror()
+    dragging.enableMirror()
 
     this.explicitEventCreationData = rawEventCreationData ? processExplicitData(rawEventCreationData) : null
   }
@@ -62,15 +62,15 @@ export default class ExternalDragging {
       }
     })
 
-    let { dragListener } = this.hitListener
+    let { dragging } = this.hitListener
 
-    dragListener.setMirrorNeedsRevert(false)
+    dragging.setMirrorNeedsRevert(false)
 
     // TODO wish we could somehow wait for dispatch to guarantee render
     if (!document.querySelector('.fc-helper')) {
-      dragListener.enableMirror()
+      dragging.enableMirror()
     } else {
-      dragListener.disableMirror()
+      dragging.disableMirror()
     }
   }
 
@@ -87,14 +87,14 @@ export default class ExternalDragging {
 
     this.addableEventStore = null
 
-    let { dragListener } = this.hitListener
+    let { dragging } = this.hitListener
 
-    dragListener.enableMirror()
-    dragListener.setMirrorNeedsRevert(true)
+    dragging.enableMirror()
+    dragging.setMirrorNeedsRevert(true)
   }
 
   onDragEnd = (pev: PointerDragEvent) => {
-    this.hitListener.dragListener.enableMirror() // always restore!
+    this.hitListener.dragging.enableMirror() // always restore!
 
     if (this.addableEventStore) {
       let finalHit = this.hitListener.finalHit