fixes to constraint system

src/component/DateComponent.ts

@@ -143,6 +143,7 @@ export default class DateComponent<PropsType> extends Component<PropsType> {
   // -----------------------------------------------------------------------------------------------------------------
 
   isEventsValid(eventStore: EventStore) {
+    let { calendar } = this
     let dateProfile = (this.props as any).dateProfile // HACK
     let instances = eventStore.instances
 
@@ -154,7 +155,7 @@ export default class DateComponent<PropsType> extends Component<PropsType> {
       }
     }
 
-    return isEventsValid(eventStore, this.calendar)
+    return isEventsValid(eventStore, calendar.renderableEventUis, calendar)
   }
 
   isSelectionValid(selection: DateSpan): boolean {

src/interactions-external/ExternalElementDragging.ts

@@ -13,6 +13,7 @@ import EventApi from '../api/EventApi'
 import { elementMatches } from '../util/dom-manip'
 import { enableCursor, disableCursor } from '../util/misc'
 import { isEventsValid, isSelectionValid, eventToDateSpan } from '../validation'
+import { computeEventDefUis } from '../component/event-ui'
 
 export type DragMetaGenerator = DragMetaInput | ((el: HTMLElement) => DragMetaInput)
 
@@ -72,7 +73,11 @@ export default class ExternalElementDragging {
 
         // TODO: fix inefficiency of calling eventTupleToStore again, and eventToDateSpan
         if (this.dragMeta.create) {
-          isInvalid = !isEventsValid(eventTupleToStore(droppableEvent), receivingCalendar)
+          let droppableEventStore = eventTupleToStore(droppableEvent)
+          let droppableEventUis = computeEventDefUis(droppableEventStore.defs, {}, receivingCalendar)
+
+          isInvalid = !isEventsValid(droppableEventStore, droppableEventUis, receivingCalendar)
+
         } else { // treat non-event-creating drags as selection validation
           isInvalid = !isSelectionValid(eventToDateSpan(droppableEvent.def, droppableEvent.instance), receivingCalendar)
         }

src/validation.ts

@@ -20,9 +20,9 @@ interface ValidationEntity {
   allows: Allow[]
 }
 
-export function isEventsValid(eventStore: EventStore, calendar: Calendar): boolean {
+export function isEventsValid(eventStore: EventStore, eventUis: EventUiHash, calendar: Calendar): boolean {
   return isEntitiesValid(
-    eventStoreToEntities(eventStore, calendar.renderableEventUis),
+    eventStoreToEntities(eventStore, eventUis),
     calendar
   )
 }
@@ -61,11 +61,14 @@ function isEntitiesValid(entities: ValidationEntity[], calendar: Calendar): bool
 
   for (let subjectEntity of entities) {
     for (let eventEntity of eventEntities) {
-      if (considerEntitiesForOverlap(subjectEntity, eventEntity)) {
-
-        for (let overlap of eventEntity.overlaps) {
-          if (!isOverlapValid(eventEntity.event, subjectEntity.event, overlap, calendar)) {
-            return false
+      if (considerEntitiesForOverlap(eventEntity, subjectEntity)) {
+
+        // the "subject" (the thing being dragged) must be an event if we are comparing it to other events for overlap
+        if (subjectEntity.event) {
+          for (let overlap of eventEntity.overlaps) {
+            if (!isOverlapValid(eventEntity.event, subjectEntity.event, overlap, calendar)) {
+              return false
+            }
           }
         }
 
@@ -168,14 +171,14 @@ function constraintToSpans(constraint: Constraint, subjectSpan: DateSpan, calend
   return []
 }
 
-function isOverlapValid(still: EventTuple, moving: EventTuple | null, overlap: Overlap | null, calendar: Calendar): boolean {
+function isOverlapValid(stillEvent: EventTuple, movingEvent: EventTuple | null, overlap: Overlap | null, calendar: Calendar): boolean {
   if (typeof overlap === 'boolean') {
     return overlap
   } else if (typeof overlap === 'function') {
     return Boolean(
       overlap(
-        new EventApi(calendar, still.def, still.instance),
-        moving ? new EventApi(calendar, moving.def, moving.instance) : null
+        new EventApi(calendar, stillEvent.def, stillEvent.instance),
+        movingEvent ? new EventApi(calendar, movingEvent.def, movingEvent.instance) : null
       )
     )
   }