lost of renaming

src/Calendar.ts

@@ -317,7 +317,6 @@ export default class Calendar {
     }
 
     this.dispatch({ type: 'ADD_EVENT_SOURCES', sources })
-
     this.setViewType(this.opt('defaultView'), this.getInitialDate())
   }
 
@@ -331,11 +330,11 @@ export default class Calendar {
         defs: {},
         instances: {}
       },
-      selection: null,
-      dragState: null,
-      eventResizeState: null,
-      businessHoursDef: false,
-      selectedEventInstanceId: null
+      businessHoursDef: false, // gets populated when we delegate rendering to View
+      dateSelection: null,
+      eventSelection: '',
+      eventDrag: null,
+      eventResize: null
     }
   }
 
@@ -554,11 +553,11 @@ export default class Calendar {
     renderedView.render({
       dateProfile: state.dateProfile,
       eventStore: state.eventStore,
-      selection: state.selection,
-      dragState: state.dragState,
-      eventResizeState: state.eventResizeState,
       businessHoursDef: renderedView.opt('businessHours'),
-      selectedEventInstanceId: state.selectedEventInstanceId
+      dateSelection: state.dateSelection,
+      eventSelection: state.eventSelection,
+      eventDrag: state.eventDrag,
+      eventResize: state.eventResize
     }, forceFlags)
 
     if (this.updateViewSize()) { // success?
@@ -960,7 +959,7 @@ export default class Calendar {
     let selection = parseDateSpan(selectionInput, this.dateEnv)
     if (selection) { // throw parse error otherwise?
       this.dispatch({
-        type: 'SELECT',
+        type: 'SELECT_DATES',
         selection: selection
       })
       browserContext.reportDateSelection(this, selection)

src/agenda/AgendaView.ts

@@ -175,36 +175,36 @@ export default class AgendaView extends View {
     let allDaySeletion = null
     let timedSelection = null
     let eventStoreGroups = this.splitEventStore(renderState.eventStore)
-    let dragStateGroups = this.splitInteractionState(renderState.dragState)
-    let eventResizeStateGroups = this.splitInteractionState(renderState.eventResizeState)
+    let dragGroups = this.splitInteractionState(renderState.eventDrag)
+    let resizeGroups = this.splitInteractionState(renderState.eventResize)
 
-    if (renderState.selection) {
-      if (renderState.selection.isAllDay) {
-        allDaySeletion = renderState.selection
+    if (renderState.dateSelection) {
+      if (renderState.dateSelection.isAllDay) {
+        allDaySeletion = renderState.dateSelection
       } else {
-        timedSelection = renderState.selection
+        timedSelection = renderState.dateSelection
       }
     }
 
     this.timeGrid.render({
       dateProfile: renderState.dateProfile,
       eventStore: eventStoreGroups.timed,
-      selection: timedSelection,
-      dragState: dragStateGroups.timed,
-      eventResizeState: eventResizeStateGroups.timed,
-      businessHoursDef: renderState.businessHoursDef,
-      selectedEventInstanceId: renderState.selectedEventInstanceId
+      dateSelection: timedSelection,
+      eventSelection: renderState.eventSelection,
+      eventDrag: dragGroups.timed,
+      eventResize: resizeGroups.timed,
+      businessHoursDef: renderState.businessHoursDef
     }, forceFlags)
 
     if (this.dayGrid) {
       this.dayGrid.render({
         dateProfile: renderState.dateProfile,
         eventStore: eventStoreGroups.allDay,
-        selection: allDaySeletion,
-        dragState: dragStateGroups.allDay,
-        eventResizeState: eventResizeStateGroups.allDay,
-        businessHoursDef: renderState.businessHoursDef,
-        selectedEventInstanceId: renderState.selectedEventInstanceId
+        dateSelection: allDaySeletion,
+        eventSelection: renderState.eventSelection,
+        eventDrag: dragGroups.allDay,
+        eventResize: resizeGroups.allDay,
+        businessHoursDef: renderState.businessHoursDef
       }, forceFlags)
     }
   }

src/agenda/TimeGrid.ts

@@ -639,7 +639,7 @@ export default class TimeGrid extends DateComponent {
 
 
   // Renders a visual indication of a selection. Overrides the default, which was to simply render a highlight.
-  renderSelection(selection: DateSpan) {
+  renderDateSelection(selection: DateSpan) {
     let segs = this.selectionToSegs(selection)
 
     if (this.opt('selectHelper')) { // this setting signals that a mock helper event should be rendered
@@ -651,7 +651,7 @@ export default class TimeGrid extends DateComponent {
 
 
   // Unrenders any visual indication of a selection
-  unrenderSelection() {
+  unrenderDateSelection() {
     this.helperRenderer.unrender()
     this.unrenderHighlight()
   }

src/common/browser-context.ts

@@ -89,7 +89,7 @@ export class BrowserContext {
     if (dateSelectedCalendar) {
 
       dateSelectedCalendar.dispatch({
-        type: 'UNSELECT'
+        type: 'UNSELECT_DATES'
       })
 
       dateSelectedCalendar.publiclyTrigger('unselect', [
@@ -124,7 +124,7 @@ export class BrowserContext {
   unselectEvent() {
     if (this.eventSelectedComponent) {
       this.eventSelectedComponent.getCalendar().dispatch({
-        type: 'CLEAR_SELECTED_EVENT'
+        type: 'UNSELECT_EVENT'
       })
       this.eventSelectedComponent = null
     }

src/component/DateComponent.ts

@@ -22,12 +22,12 @@ import { DateRange, rangeContainsMarker } from '../datelib/date-range'
 
 export interface DateComponentRenderState {
   dateProfile: DateProfile | null
-  eventStore: EventStore
-  selection: DateSpan | null
-  dragState: EventInteractionState | null
-  eventResizeState: EventInteractionState | null
   businessHoursDef: BusinessHoursDef // BusinessHoursDef's `false` is the empty state
-  selectedEventInstanceId: string
+  eventStore: EventStore
+  dateSelection: DateSpan | null
+  eventSelection: string
+  eventDrag: EventInteractionState | null
+  eventResize: EventInteractionState | null
 }
 
 // NOTE: for fg-events, eventRange.range is NOT sliced,
@@ -80,12 +80,11 @@ export default abstract class DateComponent extends Component {
 
   dateProfile: DateProfile = null
   businessHoursDef: BusinessHoursDef = false
-  selection: DateSpan = null
   eventStore: EventStore = null
-  dragState: EventInteractionState = null
-  eventResizeState: EventInteractionState = null
-  interactingEventDefId: string = null
-  selectedEventInstanceId: string = null
+  dateSelection: DateSpan = null
+  eventSelection: string = ''
+  eventDrag: EventInteractionState = null
+  eventResize: EventInteractionState = null
 
 
   constructor(_view, _options?) {
@@ -154,11 +153,11 @@ export default abstract class DateComponent extends Component {
     }
 
     // don't worry about updating the resize of the helper
-    if (force || flags.selection || flags.drag || flags.eventResize) {
+    if (force || flags.dateSelection || flags.eventDrag || flags.eventResize) {
       this.computeHighlightSize()
     }
 
-    if (force || flags.drag || flags.eventResize) {
+    if (force || flags.eventDrag || flags.eventResize) {
       this.computeHelperSize()
     }
 
@@ -170,11 +169,11 @@ export default abstract class DateComponent extends Component {
       this.assignBusinessHoursSize()
     }
 
-    if (force || flags.selection || flags.drag || flags.eventResize) {
+    if (force || flags.dateSelection || flags.eventDrag || flags.eventResize) {
       this.assignHighlightSize()
     }
 
-    if (force || flags.drag || flags.eventResize) {
+    if (force || flags.eventDrag || flags.eventResize) {
       this.assignHelperSize()
     }
 
@@ -287,12 +286,12 @@ export default abstract class DateComponent extends Component {
     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
+      businessHours: renderState.businessHoursDef !== this.businessHoursDef,
+      dateSelection: renderState.dateSelection !== this.dateSelection,
+      eventSelection: renderState.eventSelection !== this.eventSelection,
+      eventDrag: renderState.eventDrag !== this.eventDrag,
+      eventResize: renderState.eventResize !== this.eventResize
     }
 
     assignTo(dirtyFlags, forceFlags)
@@ -349,10 +348,10 @@ export default abstract class DateComponent extends Component {
       dirtySizeFlags.businessHours = true
     }
 
-    if (flags.selection && renderState.selection) {
-      this.renderSelection(renderState.selection)
-      renderedFlags.selection = true
-      dirtySizeFlags.selection = true
+    if (flags.dateSelection && renderState.dateSelection) {
+      this.renderDateSelection(renderState.dateSelection)
+      renderedFlags.dateSelection = true
+      dirtySizeFlags.dateSelection = true
     }
 
     if (flags.events && renderState.eventStore) {
@@ -361,20 +360,20 @@ export default abstract class DateComponent extends Component {
       dirtySizeFlags.events = true
     }
 
-    if (flags.selectedEvent) {
-      this.selectEventsByInstanceId(renderState.selectedEventInstanceId)
-      renderedFlags.selectedEvent = true
-      dirtySizeFlags.selectedEvent = true
+    if (flags.eventSelection) {
+      this.selectEventsByInstanceId(renderState.eventSelection)
+      renderedFlags.eventSelection = true
+      dirtySizeFlags.eventSelection = true
     }
 
-    if (flags.drag && renderState.dragState) {
-      this.renderDragState(renderState.dragState)
-      renderedFlags.drag = true
-      dirtySizeFlags.drag = true
+    if (flags.eventDrag && renderState.eventDrag) {
+      this.renderEventDragState(renderState.eventDrag)
+      renderedFlags.eventDrag = true
+      dirtySizeFlags.eventDrag = true
     }
 
-    if (flags.eventResize && renderState.eventResizeState) {
-      this.renderEventResizeState(renderState.eventResizeState)
+    if (flags.eventResize && renderState.eventResize) {
+      this.renderEventResizeState(renderState.eventResize)
       renderedFlags.eventResize = true
       dirtySizeFlags.eventResize = true
     }
@@ -389,14 +388,14 @@ export default abstract class DateComponent extends Component {
       renderedFlags.eventResize = false
     }
 
-    if ((!flags || flags.drag) && renderedFlags.drag) {
-      this.unrenderDragState()
-      renderedFlags.drag = false
+    if ((!flags || flags.eventDrag) && renderedFlags.eventDrag) {
+      this.unrenderEventDragState()
+      renderedFlags.eventDrag = false
     }
 
-    if ((!flags || flags.selectedEvent) && renderedFlags.selectedEvent) {
+    if ((!flags || flags.eventSelection) && renderedFlags.eventSelection) {
       this.unselectAllEvents()
-      renderedFlags.selectedEvent = false
+      renderedFlags.eventSelection = false
     }
 
     if ((!flags || flags.events) && renderedFlags.events) {
@@ -404,9 +403,9 @@ export default abstract class DateComponent extends Component {
       renderedFlags.events = false
     }
 
-    if ((!flags || flags.selection) && renderedFlags.selection) {
-      this.unrenderSelection()
-      renderedFlags.selection = false
+    if ((!flags || flags.dateSelection) && renderedFlags.dateSelection) {
+      this.unrenderDateSelection()
+      renderedFlags.dateSelection = false
     }
 
     if ((!flags || flags.businessHours) && renderedFlags.businessHours) {
@@ -580,21 +579,21 @@ export default abstract class DateComponent extends Component {
   // ---------------------------------------------------------------------------------------------------------------
 
 
-  renderDragState(dragState: EventInteractionState) {
-    this.hideSegsByHash(dragState.affectedEvents.instances)
-    this.renderDrag(dragState.mutatedEvents, dragState.isEvent, dragState.origSeg)
+  renderEventDragState(state: EventInteractionState) {
+    this.hideSegsByHash(state.affectedEvents.instances)
+    this.renderEventDrag(state.mutatedEvents, state.isEvent, state.origSeg)
   }
 
 
-  unrenderDragState() {
-    this.showSegsByHash(this.dragState.affectedEvents.instances)
-    this.unrenderDrag()
+  unrenderEventDragState() {
+    this.showSegsByHash(this.eventDrag.affectedEvents.instances)
+    this.unrenderEventDrag()
   }
 
 
   // Renders a visual indication of a event or external-element drag over the given drop zone.
   // If an external-element, seg will be `null`.
-  renderDrag(eventStore: EventStore, isEvent: boolean, origSeg: Seg | null) {
+  renderEventDrag(eventStore: EventStore, isEvent: boolean, origSeg: Seg | null) {
     let segs = this.eventStoreToSegs(eventStore)
 
     // if the user is dragging something that is considered an event with real event data,
@@ -615,7 +614,7 @@ export default abstract class DateComponent extends Component {
 
 
   // Unrenders a visual indication of an event or external-element being dragged.
-  unrenderDrag() {
+  unrenderEventDrag() {
     this.unrenderHighlight()
 
     if (this.helperRenderer) {
@@ -628,14 +627,14 @@ export default abstract class DateComponent extends Component {
   // ---------------------------------------------------------------------------------------------------------------
 
 
-  renderEventResizeState(eventResizeState: EventInteractionState) {
-    this.hideSegsByHash(eventResizeState.affectedEvents.instances)
-    this.renderEventResize(eventResizeState.mutatedEvents, eventResizeState.origSeg)
+  renderEventResizeState(state: EventInteractionState) {
+    this.hideSegsByHash(state.affectedEvents.instances)
+    this.renderEventResize(state.mutatedEvents, state.origSeg)
   }
 
 
   unrenderEventResizeState() {
-    this.showSegsByHash(this.eventResizeState.affectedEvents.instances)
+    this.showSegsByHash(this.eventResize.affectedEvents.instances)
     this.unrenderEventResize()
   }
 
@@ -735,13 +734,13 @@ export default abstract class DateComponent extends Component {
 
 
   // Renders a visual indication of the selection
-  renderSelection(selection: DateSpan) {
+  renderDateSelection(selection: DateSpan) {
     this.renderHighlightSegs(this.selectionToSegs(selection))
   }
 
 
   // Unrenders a visual indication of selection
-  unrenderSelection() {
+  unrenderDateSelection() {
     this.unrenderHighlight()
   }
 
@@ -997,8 +996,7 @@ export default abstract class DateComponent extends Component {
 
 
   isValidSegDownEl(el: HTMLElement) {
-    return !this.dragState &&
-      !this.eventResizeState &&
+    return !this.eventDrag && !this.eventResize &&
       !elementClosest(el, '.fc-helper')
   }
 

src/interactions-external/ExternalElementDragging.ts

@@ -124,21 +124,21 @@ export default class ExternalElementDragging {
     this.droppableEvent = null
   }
 
-  displayDrag(nextCalendar: Calendar | null, dragState: EventInteractionState) {
+  displayDrag(nextCalendar: Calendar | null, state: EventInteractionState) {
     let prevCalendar = this.receivingCalendar
 
     if (prevCalendar && prevCalendar !== nextCalendar) {
-      prevCalendar.dispatch({ type: 'CLEAR_DRAG' })
+      prevCalendar.dispatch({ type: 'UNSET_EVENT_DRAG' })
     }
 
     if (nextCalendar) {
-      nextCalendar.dispatch({ type: 'SET_DRAG', dragState: dragState })
+      nextCalendar.dispatch({ type: 'SET_EVENT_DRAG', state })
     }
   }
 
   clearDrag() {
     if (this.receivingCalendar) {
-      this.receivingCalendar.dispatch({ type: 'CLEAR_DRAG' })
+      this.receivingCalendar.dispatch({ type: 'UNSET_EVENT_DRAG' })
     }
   }
 

src/interactions/DateSelecting.ts

@@ -62,9 +62,9 @@ export default class DateSelecting {
     }
 
     if (dragSelection) {
-      calendar.dispatch({ type: 'SELECT', selection: dragSelection })
+      calendar.dispatch({ type: 'SELECT_DATES', selection: dragSelection })
     } else if (!isFinal) { // only unselect if moved away while dragging
-      calendar.dispatch({ type: 'UNSELECT' })
+      calendar.dispatch({ type: 'UNSELECT_DATES' })
     }
 
     if (!isFinal) {
@@ -84,7 +84,7 @@ export default class DateSelecting {
 
     // only unselect if this component has a selection.
     // otherwise, we might be clearing another component's new selection in the same calendar.
-    } else if (!wasTouchScroll && component.selection) {
+    } else if (!wasTouchScroll && component.dateSelection) {
       let unselectAuto = component.opt('unselectAuto')
       let unselectCancel = component.opt('unselectCancel')
 

src/interactions/EventDragging.ts

@@ -59,7 +59,7 @@ export default class EventDragging {
     dragging.minDistance = ev.isTouch ? 0 : 5
     dragging.delay =
       // only do a touch delay if touch and this event hasn't been selected yet
-      (ev.isTouch && eventInstanceId !== component.selectedEventInstanceId) ?
+      (ev.isTouch && eventInstanceId !== component.eventSelection) ?
         getComponentTouchDelay(component) :
         null
 
@@ -78,7 +78,7 @@ export default class EventDragging {
     if (ev.isTouch) {
 
       // need to select a different event?
-      if (this.eventInstanceId !== this.component.selectedEventInstanceId) {
+      if (this.eventInstanceId !== this.component.eventSelection) {
         let initialCalendar = this.component.getCalendar()
 
         initialCalendar.dispatch({
@@ -195,7 +195,7 @@ export default class EventDragging {
   }
 
   // render a drag state on the next receivingCalendar
-  displayDrag(nextCalendar: Calendar | null, dragState: EventInteractionState) {
+  displayDrag(nextCalendar: Calendar | null, state: EventInteractionState) {
     let initialCalendar = this.component.getCalendar()
     let prevCalendar = this.receivingCalendar
 
@@ -206,23 +206,23 @@ export default class EventDragging {
       // if so, don't clear all the way. we still need to to hide the affectedEvents
       if (prevCalendar === initialCalendar) {
         prevCalendar.dispatch({
-          type: 'SET_DRAG',
-          dragState: {
-            affectedEvents: dragState.affectedEvents,
+          type: 'SET_EVENT_DRAG',
+          state: {
+            affectedEvents: state.affectedEvents,
             mutatedEvents: createEmptyEventStore(),
             isEvent: true,
-            origSeg: dragState.origSeg
+            origSeg: state.origSeg
           }
         })
 
       // completely clear the old calendar if it wasn't the initial
       } else {
-        prevCalendar.dispatch({ type: 'CLEAR_DRAG' })
+        prevCalendar.dispatch({ type: 'UNSET_EVENT_DRAG' })
       }
     }
 
     if (nextCalendar) {
-      nextCalendar.dispatch({ type: 'SET_DRAG', dragState })
+      nextCalendar.dispatch({ type: 'SET_EVENT_DRAG', state })
     }
   }
 
@@ -231,12 +231,12 @@ export default class EventDragging {
     let { receivingCalendar } = this
 
     if (receivingCalendar) {
-      receivingCalendar.dispatch({ type: 'CLEAR_DRAG' })
+      receivingCalendar.dispatch({ type: 'UNSET_EVENT_DRAG' })
     }
 
     // the initial calendar might have an dummy drag state from displayDrag
     if (initialCalendar !== receivingCalendar) {
-      initialCalendar.dispatch({ type: 'CLEAR_DRAG' })
+      initialCalendar.dispatch({ type: 'UNSET_EVENT_DRAG' })
     }
   }
 

src/interactions/EventResizing.ts

@@ -47,7 +47,7 @@ export default class EventDragging {
     // if touch, need to be working with a selected event
     this.dragging.setIgnoreMove(
       !this.component.isValidSegDownEl(ev.origEvent.target as HTMLElement) ||
-      (ev.isTouch && this.component.selectedEventInstanceId !== eventInstance.instanceId)
+      (ev.isTouch && this.component.eventSelection !== eventInstance.instanceId)
     )
   }
 
@@ -83,7 +83,7 @@ export default class EventDragging {
 
       calendar.dispatch({
         type: 'SET_EVENT_RESIZE',
-        eventResizeState: {
+        state: {
           affectedEvents: relatedEvents,
           mutatedEvents: mutatedRelated,
           isEvent: true,
@@ -91,7 +91,7 @@ export default class EventDragging {
         }
       })
     } else {
-      calendar.dispatch({ type: 'CLEAR_EVENT_RESIZE' })
+      calendar.dispatch({ type: 'UNSET_EVENT_RESIZE' })
     }
 
     if (!isFinal) {

src/reducers/main.ts

@@ -17,11 +17,11 @@ export default function(state: CalendarState, action: Action, calendar: Calendar
     dateProfile,
     eventSources,
     eventStore: reduceEventStore(state.eventStore, action, eventSources, calendar),
-    businessHoursDef: state.businessHoursDef, // TODO: rename?
-    selection: reduceDateSelection(state.selection, action), // TODO: rename
-    selectedEventInstanceId: reduceSelectedEvent(state.selectedEventInstanceId, action),
-    dragState: reduceDrag(state.dragState, action),
-    eventResizeState: reduceEventResize(state.eventResizeState, action),
+    businessHoursDef: state.businessHoursDef,
+    dateSelection: reduceDateSelection(state.dateSelection, action),
+    eventSelection: reduceSelectedEvent(state.eventSelection, action),
+    eventDrag: reduceEventDrag(state.eventDrag, action),
+    eventResize: reduceEventResize(state.eventResize, action),
     loadingLevel: reduceLoadingLevel(state.loadingLevel, action, eventSources)
   }
 }
@@ -37,9 +37,9 @@ function reduceDateProfile(currentDateProfile: DateProfile | null, action: Actio
 
 function reduceDateSelection(currentSelection: DateSpan | null, action: Action) {
   switch (action.type) {
-    case 'SELECT': // TODO: rename
+    case 'SELECT_DATES':
       return action.selection
-    case 'UNSELECT': // TODO: rename
+    case 'UNSELECT_DATES':
       return null
     default:
       return currentSelection
@@ -50,18 +50,18 @@ function reduceSelectedEvent(currentInstanceId: string, action: Action): string
   switch (action.type) {
     case 'SELECT_EVENT':
       return action.eventInstanceId
-    case 'CLEAR_SELECTED_EVENT':
+    case 'UNSELECT_EVENT':
       return ''
     default:
       return currentInstanceId
   }
 }
 
-function reduceDrag(currentDrag: EventInteractionState | null, action: Action) {
+function reduceEventDrag(currentDrag: EventInteractionState | null, action: Action) {
   switch (action.type) {
-    case 'SET_DRAG':
-      return action.dragState
-    case 'CLEAR_DRAG':
+    case 'SET_EVENT_DRAG':
+      return action.state
+    case 'UNSET_EVENT_DRAG':
       return null
     default:
       return currentDrag
@@ -71,8 +71,8 @@ function reduceDrag(currentDrag: EventInteractionState | null, action: Action) {
 function reduceEventResize(currentEventResize: EventInteractionState | null, action: Action) {
   switch (action.type) {
     case 'SET_EVENT_RESIZE':
-      return action.eventResizeState
-    case 'CLEAR_EVENT_RESIZE':
+      return action.state
+    case 'UNSET_EVENT_RESIZE':
       return null
     default:
       return currentEventResize

src/reducers/types.ts

@@ -21,17 +21,17 @@ export type Action =
 
   { type: 'SET_DATE_PROFILE', dateProfile: DateProfile  } |
 
-  { type: 'SELECT', selection: DateSpan } |
-  { type: 'UNSELECT' } |
+  { type: 'SELECT_DATES', selection: DateSpan } |
+  { type: 'UNSELECT_DATES' } |
 
   { type: 'SELECT_EVENT', eventInstanceId: string } |
-  { type: 'CLEAR_SELECTED_EVENT' } |
+  { type: 'UNSELECT_EVENT' } |
 
-  { type: 'SET_DRAG', dragState: EventInteractionState } |
-  { type: 'CLEAR_DRAG' } |
+  { type: 'SET_EVENT_DRAG', state: EventInteractionState } |
+  { type: 'UNSET_EVENT_DRAG' } |
 
-  { type: 'SET_EVENT_RESIZE', eventResizeState: EventInteractionState } |
-  { type: 'CLEAR_EVENT_RESIZE' } |
+  { type: 'SET_EVENT_RESIZE', state: EventInteractionState } |
+  { type: 'UNSET_EVENT_RESIZE' } |
 
   { type: 'ADD_EVENT_SOURCES', sources: EventSource[] } |
   { type: 'REMOVE_EVENT_SOURCES', sourceIds?: string[] } | // if no sourceIds, remove all