@fullcalendar/core 7.0.0-beta.0 → 7.0.0-beta.1

package/index.cjs

@@ -1708,8 +1708,8 @@ class EventClicking extends internalCommon.Interaction {
         this.handleSegClick = (ev, segEl) => {
             let { component } = this;
             let { context } = component;
-            let seg = internalCommon.getElSeg(segEl);
-            if (seg && // might be the <div> surrounding the more link
+            let eventRange = internalCommon.getElEventRange(segEl);
+            if (eventRange && // might be the <div> surrounding the more link
                 component.isValidSegDownEl(ev.target)) {
                 // our way to simulate a link click for elements that can't be <a> tags
                 // grab before trigger fired in case trigger trashes DOM thru rerendering
@@ -1717,7 +1717,7 @@ class EventClicking extends internalCommon.Interaction {
                 let url = hasUrlContainer ? hasUrlContainer.querySelector('a[href]').href : '';
                 context.emitter.trigger('eventClick', {
                     el: segEl,
-                    event: new internalCommon.EventImpl(component.context, seg.eventRange.def, seg.eventRange.instance),
+                    event: new internalCommon.EventImpl(component.context, eventRange.def, eventRange.instance),
                     jsEvent: ev,
                     view: context.viewApi,
                 });
@@ -1745,7 +1745,7 @@ class EventHovering extends internalCommon.Interaction {
             }
         };
         this.handleSegEnter = (ev, segEl) => {
-            if (internalCommon.getElSeg(segEl)) { // TODO: better way to make sure not hovering over more+ link or its wrapper
+            if (internalCommon.getElEventRange(segEl)) { // TODO: better way to make sure not hovering over more+ link or its wrapper
                 this.currentSegEl = segEl;
                 this.triggerEvent('eventMouseEnter', ev, segEl);
             }
@@ -1765,11 +1765,11 @@ class EventHovering extends internalCommon.Interaction {
     triggerEvent(publicEvName, ev, segEl) {
         let { component } = this;
         let { context } = component;
-        let seg = internalCommon.getElSeg(segEl);
+        let eventRange = internalCommon.getElEventRange(segEl);
         if (!ev || component.isValidSegDownEl(ev.target)) {
             context.emitter.trigger(publicEvName, {
                 el: segEl,
-                event: new internalCommon.EventImpl(context, seg.eventRange.def, seg.eventRange.instance),
+                event: new internalCommon.EventImpl(context, eventRange.def, eventRange.instance),
                 jsEvent: ev,
                 view: context.viewApi,
             });
@@ -2077,7 +2077,7 @@ function sliceEvents(props, allDay) {
     return internalCommon.sliceEventStore(props.eventStore, props.eventUiBases, props.dateProfile.activeRange, allDay ? props.nextDayThreshold : null).fg;
 }
 
-const version = '7.0.0-beta.0';
+const version = '7.0.0-beta.1';
 
 exports.JsonRequestError = internalCommon.JsonRequestError;
 exports.Calendar = Calendar;

package/index.global.js

@@ -1,5 +1,5 @@
 /*!
-FullCalendar Core v7.0.0-beta.0
+FullCalendar Core v7.0.0-beta.1
 Docs & License: https://fullcalendar.io
 (c) 2024 Adam Shaw
 */
@@ -4192,12 +4192,12 @@ var FullCalendar = (function (exports) {
     function hasBgRendering(def) {
         return def.ui.display === 'background' || def.ui.display === 'inverse-background';
     }
-    function setElSeg(el, seg) {
-        el.fcSeg = seg;
+    function setElEventRange(el, eventRange) {
+        el.fcEventRange = eventRange;
     }
-    function getElSeg(el) {
-        return el.fcSeg ||
-            el.parentNode.fcSeg || // for the harness
+    function getElEventRange(el) {
+        return el.fcEventRange ||
+            el.parentNode.fcEventRange || // for the harness
             null;
     }
     // event ui computation
@@ -4217,7 +4217,7 @@ var FullCalendar = (function (exports) {
     }
     function sortEventSegs(segs, eventOrderSpecs) {
         let objs = segs.map(buildSegCompareObj);
-        objs.sort((obj0, obj1) => compareByFieldSpecs(obj0, obj1, eventOrderSpecs));
+        objs.sort((obj0, obj1) => compareByFieldSpecs(obj0, obj1, eventOrderSpecs)); // !!!
         return objs.map((c) => c._seg);
     }
     // returns a object with all primitive props that can be compared
@@ -4230,29 +4230,23 @@ var FullCalendar = (function (exports) {
         return Object.assign(Object.assign(Object.assign({}, eventDef.extendedProps), eventDef), { id: eventDef.publicId, start,
             end, duration: end - start, allDay: Number(eventDef.allDay), _seg: seg });
     }
-    function computeSegDraggable(seg, context) {
+    function computeEventRangeDraggable(eventRange, context) {
         let { pluginHooks } = context;
         let transformers = pluginHooks.isDraggableTransformers;
-        let { def, ui } = seg.eventRange;
+        let { def, ui } = eventRange;
         let val = ui.startEditable;
         for (let transformer of transformers) {
             val = transformer(val, def, ui, context);
         }
         return val;
     }
-    function computeSegStartResizable(seg, context) {
-        return seg.isStart && seg.eventRange.ui.durationEditable && context.options.eventResizableFromStart;
-    }
-    function computeSegEndResizable(seg, context) {
-        return seg.isEnd && seg.eventRange.ui.durationEditable;
-    }
-    function buildSegTimeText(seg, timeFormat, context, defaultDisplayEventTime, // defaults to true
+    function buildEventRangeTimeText(eventRange, timeFormat, context, defaultDisplayEventTime, // defaults to true
     defaultDisplayEventEnd, // defaults to true
     startOverride, endOverride) {
         let { dateEnv, options } = context;
         let { displayEventTime, displayEventEnd } = options;
-        let eventDef = seg.eventRange.def;
-        let eventInstance = seg.eventRange.instance;
+        let eventDef = eventRange.def;
+        let eventInstance = eventRange.instance;
         if (displayEventTime == null) {
             displayEventTime = defaultDisplayEventTime !== false;
         }
@@ -4261,8 +4255,8 @@ var FullCalendar = (function (exports) {
         }
         let wholeEventStart = eventInstance.range.start;
         let wholeEventEnd = eventInstance.range.end;
-        let segStart = startOverride || seg.start || seg.eventRange.range.start;
-        let segEnd = endOverride || seg.end || seg.eventRange.range.end;
+        let segStart = startOverride || eventRange.range.start;
+        let segEnd = endOverride || eventRange.range.end;
         let isStartDay = startOfDay(wholeEventStart).valueOf() === startOfDay(segStart).valueOf();
         let isEndDay = startOfDay(addMs(wholeEventEnd, -1)).valueOf() === startOfDay(addMs(segEnd, -1)).valueOf();
         if (displayEventTime && !eventDef.allDay && (isStartDay || isEndDay)) {
@@ -4280,8 +4274,8 @@ var FullCalendar = (function (exports) {
         }
         return '';
     }
-    function getSegMeta(seg, todayRange, nowDate) {
-        let segRange = seg.eventRange.range;
+    function getEventRangeMeta(eventRange, todayRange, nowDate) {
+        let segRange = eventRange.range;
         return {
             isPast: segRange.end <= (nowDate || todayRange.start),
             isFuture: segRange.start >= (nowDate || todayRange.end),
@@ -4331,8 +4325,8 @@ var FullCalendar = (function (exports) {
             : `${eventRange.def.defId}:${eventRange.range.start.toISOString()}`;
         // inverse-background events don't have specific instances. TODO: better solution
     }
-    function getSegAnchorAttrs(seg, context) {
-        let { def, instance } = seg.eventRange;
+    function getEventRangeAnchorAttrs(eventRange, context) {
+        let { def, instance } = eventRange;
         let { url } = def;
         if (url) {
             return { href: url };
@@ -5819,6 +5813,172 @@ var FullCalendar = (function (exports) {
         }
     }
 
+    class DelayedRunner {
+        constructor(drainedOption) {
+            this.drainedOption = drainedOption;
+            this.isRunning = false;
+            this.isDirty = false;
+            this.pauseDepths = {};
+            this.timeoutId = 0;
+        }
+        request(delay) {
+            this.isDirty = true;
+            if (!this.isPaused()) {
+                this.clearTimeout();
+                if (delay == null) {
+                    this.tryDrain();
+                }
+                else {
+                    this.timeoutId = setTimeout(// NOT OPTIMAL! TODO: look at debounce
+                    this.tryDrain.bind(this), delay);
+                }
+            }
+        }
+        pause(scope = '') {
+            let { pauseDepths } = this;
+            pauseDepths[scope] = (pauseDepths[scope] || 0) + 1;
+            this.clearTimeout();
+        }
+        resume(scope = '', force) {
+            let { pauseDepths } = this;
+            if (scope in pauseDepths) {
+                if (force) {
+                    delete pauseDepths[scope];
+                }
+                else {
+                    pauseDepths[scope] -= 1;
+                    let depth = pauseDepths[scope];
+                    if (depth <= 0) {
+                        delete pauseDepths[scope];
+                    }
+                }
+                this.tryDrain();
+            }
+        }
+        isPaused() {
+            return Object.keys(this.pauseDepths).length;
+        }
+        tryDrain() {
+            if (!this.isRunning && !this.isPaused()) {
+                this.isRunning = true;
+                while (this.isDirty) {
+                    this.isDirty = false;
+                    this.drained(); // might set isDirty to true again
+                }
+                this.isRunning = false;
+            }
+        }
+        clear() {
+            this.clearTimeout();
+            this.isDirty = false;
+            this.pauseDepths = {};
+        }
+        clearTimeout() {
+            if (this.timeoutId) {
+                clearTimeout(this.timeoutId);
+                this.timeoutId = 0;
+            }
+        }
+        drained() {
+            if (this.drainedOption) {
+                this.drainedOption();
+            }
+        }
+    }
+
+    const WHEEL_EVENT_NAMES = 'wheel mousewheel DomMouseScroll MozMousePixelScroll'.split(' ');
+    /*
+    Fires:
+    - scrollStart (always user)
+    - scroll
+    - scrollEnd (always user)
+
+    NOTE: detection is complicated (w/ touch and wheel) because ScrollerSyncer needs to know about it,
+    but are we sure we can't just ignore programmatic scrollTo() calls with a flag? and determine the
+    the scroll-master simply by who was the newest scroller? Does passive:true do things asynchronously?
+    */
+    class ScrollListener {
+        constructor(el) {
+            this.el = el;
+            this.emitter = new Emitter();
+            this.isScrolling = false;
+            this.isTouching = false; // user currently has finger down?
+            this.isRecentlyWheeled = false;
+            this.isRecentlyScrolled = false;
+            this.wheelWaiter = new DelayedRunner(this._handleWheelWaited.bind(this));
+            this.scrollWaiter = new DelayedRunner(this._handleScrollWaited.bind(this));
+            // Handlers
+            // ----------------------------------------------------------------------------------------------
+            this.handleScroll = () => {
+                this.startScroll();
+                this.emitter.trigger('scroll', this.isRecentlyWheeled, this.isTouching);
+                this.isRecentlyScrolled = true;
+                this.scrollWaiter.request(500);
+            };
+            // will fire *before* the scroll event is fired (might not cause a scroll)
+            this.handleWheel = () => {
+                this.isRecentlyWheeled = true;
+                this.wheelWaiter.request(500);
+            };
+            // will fire *before* the scroll event is fired (might not cause a scroll)
+            this.handleTouchStart = () => {
+                this.isTouching = true;
+            };
+            this.handleTouchEnd = () => {
+                this.isTouching = false;
+                // if the user ended their touch, and the scroll area wasn't moving,
+                // we consider this to be the end of the scroll.
+                if (!this.isRecentlyScrolled) {
+                    this.endScroll(); // won't fire if already ended
+                }
+            };
+            el.addEventListener('scroll', this.handleScroll);
+            el.addEventListener('touchstart', this.handleTouchStart, { passive: true });
+            el.addEventListener('touchend', this.handleTouchEnd);
+            for (let eventName of WHEEL_EVENT_NAMES) {
+                el.addEventListener(eventName, this.handleWheel, { passive: true });
+            }
+        }
+        destroy() {
+            let { el } = this;
+            el.removeEventListener('scroll', this.handleScroll);
+            el.removeEventListener('touchstart', this.handleTouchStart, { passive: true });
+            el.removeEventListener('touchend', this.handleTouchEnd);
+            for (let eventName of WHEEL_EVENT_NAMES) {
+                el.removeEventListener(eventName, this.handleWheel, { passive: true });
+            }
+        }
+        // Start / Stop
+        // ----------------------------------------------------------------------------------------------
+        startScroll() {
+            if (!this.isScrolling) {
+                this.isScrolling = true;
+                this.emitter.trigger('scrollStart', this.isRecentlyWheeled, this.isTouching);
+            }
+        }
+        endScroll() {
+            if (this.isScrolling) {
+                this.emitter.trigger('scrollEnd');
+                this.isScrolling = false;
+                this.isRecentlyScrolled = true;
+                this.isRecentlyWheeled = false;
+                this.scrollWaiter.clear();
+                this.wheelWaiter.clear();
+            }
+        }
+        _handleScrollWaited() {
+            this.isRecentlyScrolled = false;
+            // only end the scroll if not currently touching.
+            // if touching, the scrolling will end later, on touchend.
+            if (!this.isTouching) {
+                this.endScroll(); // won't fire if already ended
+            }
+        }
+        _handleWheelWaited() {
+            this.isRecentlyWheeled = false;
+        }
+    }
+
     class Scroller extends DateComponent {
         constructor() {
             super(...arguments);
@@ -5838,6 +5998,7 @@ var FullCalendar = (function (exports) {
         }
         componentDidMount() {
             const el = this.elRef.current; // TODO: make dynamic with useEffect
+            this.listener = new ScrollListener(el);
             this.disconnectSize = watchSize(el, (contentWidth, contentHeight) => {
                 const { props, context } = this;
                 const bottomScrollbarWidth = el.offsetHeight - el.clientHeight;
@@ -5868,13 +6029,20 @@ var FullCalendar = (function (exports) {
             });
         }
         componentWillUnmount() {
+            const { props } = this;
             this.disconnectSize();
+            this.listener.destroy();
+            setRef(props.widthRef, null);
+            setRef(props.heightRef, null);
+            setRef(props.bottomScrollbarWidthRef, null);
+            setRef(props.rightScrollbarWidthRef, null);
+            setRef(props.leftScrollbarWidthRef, null);
+        }
+        endScroll() {
+            this.listener.endScroll();
         }
         // Public API
         // -----------------------------------------------------------------------------------------------
-        get el() {
-            return this.elRef.current;
-        }
         get x() {
             const { isRtl } = this.context;
             const el = this.elRef.current;
@@ -5894,6 +6062,12 @@ var FullCalendar = (function (exports) {
                 setNormalizedScrollX(el, isRtl, x);
             }
         }
+        addScrollEndListener(handler) {
+            this.listener.emitter.on('scrollEnd', handler);
+        }
+        removeScrollEndListener(handler) {
+            this.listener.emitter.off('scrollEnd', handler);
+        }
     }
     // Public API
     // -------------------------------------------------------------------------------------------------
@@ -6436,79 +6610,6 @@ var FullCalendar = (function (exports) {
         });
     }
 
-    class DelayedRunner {
-        constructor(drainedOption) {
-            this.drainedOption = drainedOption;
-            this.isRunning = false;
-            this.isDirty = false;
-            this.pauseDepths = {};
-            this.timeoutId = 0;
-        }
-        request(delay) {
-            this.isDirty = true;
-            if (!this.isPaused()) {
-                this.clearTimeout();
-                if (delay == null) {
-                    this.tryDrain();
-                }
-                else {
-                    this.timeoutId = setTimeout(// NOT OPTIMAL! TODO: look at debounce
-                    this.tryDrain.bind(this), delay);
-                }
-            }
-        }
-        pause(scope = '') {
-            let { pauseDepths } = this;
-            pauseDepths[scope] = (pauseDepths[scope] || 0) + 1;
-            this.clearTimeout();
-        }
-        resume(scope = '', force) {
-            let { pauseDepths } = this;
-            if (scope in pauseDepths) {
-                if (force) {
-                    delete pauseDepths[scope];
-                }
-                else {
-                    pauseDepths[scope] -= 1;
-                    let depth = pauseDepths[scope];
-                    if (depth <= 0) {
-                        delete pauseDepths[scope];
-                    }
-                }
-                this.tryDrain();
-            }
-        }
-        isPaused() {
-            return Object.keys(this.pauseDepths).length;
-        }
-        tryDrain() {
-            if (!this.isRunning && !this.isPaused()) {
-                this.isRunning = true;
-                while (this.isDirty) {
-                    this.isDirty = false;
-                    this.drained(); // might set isDirty to true again
-                }
-                this.isRunning = false;
-            }
-        }
-        clear() {
-            this.clearTimeout();
-            this.isDirty = false;
-            this.pauseDepths = {};
-        }
-        clearTimeout() {
-            if (this.timeoutId) {
-                clearTimeout(this.timeoutId);
-                this.timeoutId = 0;
-            }
-        }
-        drained() {
-            if (this.drainedOption) {
-                this.drainedOption();
-            }
-        }
-    }
-
     function getIsHeightAuto(options) {
         return options.height === 'auto' || options.viewHeight === 'auto';
     }
@@ -6629,38 +6730,20 @@ var FullCalendar = (function (exports) {
         return { start, end };
     }
 
-    class ScrollResponder {
-        constructor(_handleScroll) {
-            this._handleScroll = _handleScroll;
-            this.handleScroll = (scroll) => {
-                this.queuedScroll = scroll;
-                this.drain();
-            };
-        }
-        drain() {
-            if (this.queuedScroll) {
-                if (this._handleScroll(this.queuedScroll)) {
-                    this.queuedScroll = undefined;
-                }
-            }
-        }
-    }
-
     class EventContainer extends BaseComponent {
         constructor() {
             super(...arguments);
             this.handleEl = (el) => {
                 this.el = el;
                 if (el) {
-                    setElSeg(el, this.props.seg);
+                    setElEventRange(el, this.props.eventRange);
                 }
             };
         }
         render() {
             const { props, context } = this;
             const { options } = context;
-            const { seg } = props;
-            const { eventRange } = seg;
+            const { eventRange } = props;
             const { ui } = eventRange;
             const renderProps = {
                 event: new EventImpl(context, eventRange.def, eventRange.instance),
@@ -6669,12 +6752,12 @@ var FullCalendar = (function (exports) {
                 textColor: ui.textColor,
                 backgroundColor: ui.backgroundColor,
                 borderColor: ui.borderColor,
-                isDraggable: !props.disableDragging && computeSegDraggable(seg, context),
-                isStartResizable: !props.disableResizing && computeSegStartResizable(seg, context),
-                isEndResizable: !props.disableResizing && computeSegEndResizable(seg),
+                isDraggable: !props.disableDragging && computeEventRangeDraggable(eventRange, context),
+                isStartResizable: !props.disableResizing && props.isStart && eventRange.ui.durationEditable && options.eventResizableFromStart,
+                isEndResizable: !props.disableResizing && props.isEnd && eventRange.ui.durationEditable,
                 isMirror: Boolean(props.isDragging || props.isResizing || props.isDateSelecting),
-                isStart: Boolean(seg.isStart),
-                isEnd: Boolean(seg.isEnd),
+                isStart: Boolean(props.isStart),
+                isEnd: Boolean(props.isEnd),
                 isPast: Boolean(props.isPast),
                 isFuture: Boolean(props.isFuture),
                 isToday: Boolean(props.isToday),
@@ -6684,13 +6767,13 @@ var FullCalendar = (function (exports) {
             };
             return (_(ContentContainer, Object.assign({}, props /* contains children */, { elRef: this.handleEl, elClasses: [
                     ...getEventClassNames(renderProps),
-                    ...seg.eventRange.ui.classNames,
+                    ...eventRange.ui.classNames,
                     ...(props.elClasses || []),
                 ], renderProps: renderProps, generatorName: "eventContent", customGenerator: options.eventContent, defaultGenerator: props.defaultGenerator, classNameGenerator: options.eventClassNames, didMount: options.eventDidMount, willUnmount: options.eventWillUnmount })));
         }
         componentDidUpdate(prevProps) {
-            if (this.el && this.props.seg !== prevProps.seg) {
-                setElSeg(this.el, this.props.seg);
+            if (this.el && this.props.eventRange !== prevProps.eventRange) {
+                setElEventRange(this.el, this.props.eventRange);
             }
         }
     }
@@ -6700,14 +6783,14 @@ var FullCalendar = (function (exports) {
         render() {
             let { props, context } = this;
             let { options } = context;
-            let { seg } = props;
-            let { ui } = seg.eventRange;
+            let { eventRange } = props;
+            let { ui } = eventRange;
             let timeFormat = options.eventTimeFormat || props.defaultTimeFormat;
-            let timeText = buildSegTimeText(seg, timeFormat, context, props.defaultDisplayEventTime, props.defaultDisplayEventEnd);
+            let timeText = buildEventRangeTimeText(eventRange, timeFormat, context, props.defaultDisplayEventTime, props.defaultDisplayEventEnd, props.startOverride, props.endOverride);
             return (_(EventContainer, Object.assign({}, props /* includes elRef */, { elTag: "a", elStyle: {
                     borderColor: ui.borderColor,
                     backgroundColor: ui.backgroundColor,
-                }, elAttrs: getSegAnchorAttrs(seg, context), defaultGenerator: renderInnerContent$1, timeText: timeText }), (InnerContent, eventContentArg) => (_(k$1, null,
+                }, elAttrs: getEventRangeAnchorAttrs(eventRange, context), defaultGenerator: renderInnerContent$1, timeText: timeText }), (InnerContent, eventContentArg) => (_(k$1, null,
                 _(InnerContent, { elTag: "div", elClasses: ['fc-event-inner'], elStyle: { color: eventContentArg.textColor } }),
                 Boolean(eventContentArg.isStartResizable) && (_("div", { className: "fc-event-resizer fc-event-resizer-start" })),
                 Boolean(eventContentArg.isEndResizable) && (_("div", { className: "fc-event-resizer fc-event-resizer-end" }))))));
@@ -6733,8 +6816,8 @@ var FullCalendar = (function (exports) {
     class BgEvent extends BaseComponent {
         render() {
             let { props } = this;
-            let { seg } = props;
-            return (_(EventContainer, { elTag: "div", elClasses: ['fc-bg-event'], elStyle: { backgroundColor: seg.eventRange.ui.backgroundColor }, defaultGenerator: renderInnerContent, seg: seg, timeText: "", isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, isPast: props.isPast, isFuture: props.isFuture, isToday: props.isToday, disableDragging: true, disableResizing: true }));
+            let { eventRange } = props;
+            return (_(EventContainer, { elTag: "div", elClasses: ['fc-bg-event'], elStyle: { backgroundColor: eventRange.ui.backgroundColor }, defaultGenerator: renderInnerContent, eventRange: eventRange, isStart: props.isStart, isEnd: props.isEnd, timeText: "", isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, isPast: props.isPast, isFuture: props.isFuture, isToday: props.isToday, disableDragging: true, disableResizing: true }));
         }
     }
     function renderInnerContent(props) {
@@ -7396,12 +7479,12 @@ var FullCalendar = (function (exports) {
         DaySeriesModel: DaySeriesModel,
         sliceEventStore: sliceEventStore,
         hasBgRendering: hasBgRendering,
-        getElSeg: getElSeg,
-        buildSegTimeText: buildSegTimeText,
+        getElEventRange: getElEventRange,
+        buildEventRangeTimeText: buildEventRangeTimeText,
         sortEventSegs: sortEventSegs,
-        getSegMeta: getSegMeta,
+        getEventRangeMeta: getEventRangeMeta,
         buildEventRangeKey: buildEventRangeKey,
-        getSegAnchorAttrs: getSegAnchorAttrs,
+        getEventRangeAnchorAttrs: getEventRangeAnchorAttrs,
         DayTableModel: DayTableModel,
         Scroller: Scroller,
         getNormalizedScrollX: getNormalizedScrollX,
@@ -7423,7 +7506,6 @@ var FullCalendar = (function (exports) {
         RefMap: RefMap,
         getIsRtlScrollbarOnLeft: getIsRtlScrollbarOnLeft,
         NowTimer: NowTimer,
-        ScrollResponder: ScrollResponder,
         StandardEvent: StandardEvent,
         NowIndicatorContainer: NowIndicatorContainer,
         DayCellContainer: DayCellContainer,
@@ -9148,8 +9230,8 @@ var FullCalendar = (function (exports) {
             this.handleSegClick = (ev, segEl) => {
                 let { component } = this;
                 let { context } = component;
-                let seg = getElSeg(segEl);
-                if (seg && // might be the <div> surrounding the more link
+                let eventRange = getElEventRange(segEl);
+                if (eventRange && // might be the <div> surrounding the more link
                     component.isValidSegDownEl(ev.target)) {
                     // our way to simulate a link click for elements that can't be <a> tags
                     // grab before trigger fired in case trigger trashes DOM thru rerendering
@@ -9157,7 +9239,7 @@ var FullCalendar = (function (exports) {
                     let url = hasUrlContainer ? hasUrlContainer.querySelector('a[href]').href : '';
                     context.emitter.trigger('eventClick', {
                         el: segEl,
-                        event: new EventImpl(component.context, seg.eventRange.def, seg.eventRange.instance),
+                        event: new EventImpl(component.context, eventRange.def, eventRange.instance),
                         jsEvent: ev,
                         view: context.viewApi,
                     });
@@ -9185,7 +9267,7 @@ var FullCalendar = (function (exports) {
                 }
             };
             this.handleSegEnter = (ev, segEl) => {
-                if (getElSeg(segEl)) { // TODO: better way to make sure not hovering over more+ link or its wrapper
+                if (getElEventRange(segEl)) { // TODO: better way to make sure not hovering over more+ link or its wrapper
                     this.currentSegEl = segEl;
                     this.triggerEvent('eventMouseEnter', ev, segEl);
                 }
@@ -9205,11 +9287,11 @@ var FullCalendar = (function (exports) {
         triggerEvent(publicEvName, ev, segEl) {
             let { component } = this;
             let { context } = component;
-            let seg = getElSeg(segEl);
+            let eventRange = getElEventRange(segEl);
             if (!ev || component.isValidSegDownEl(ev.target)) {
                 context.emitter.trigger(publicEvName, {
                     el: segEl,
-                    event: new EventImpl(context, seg.eventRange.def, seg.eventRange.instance),
+                    event: new EventImpl(context, eventRange.def, eventRange.instance),
                     jsEvent: ev,
                     view: context.viewApi,
                 });
@@ -9517,7 +9599,7 @@ var FullCalendar = (function (exports) {
         return sliceEventStore(props.eventStore, props.eventUiBases, props.dateProfile.activeRange, allDay ? props.nextDayThreshold : null).fg;
     }
 
-    const version = '7.0.0-beta.0';
+    const version = '7.0.0-beta.1';
 
     exports.Calendar = Calendar;
     exports.Internal = internal;