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

package/index.js

@@ -1,4 +1,4 @@
-import { m as mergeProps, g as guid, i as isArraysEqual, T as Theme, a as mapHash, B as BaseComponent, V as ViewContextType, C as ContentContainer, b as buildViewClassNames, c as greatestDurationDenominator, d as createDuration, e as BASE_OPTION_DEFAULTS, f as arrayToHash, h as filterHash, j as buildEventSourceRefiners, p as parseEventSource, k as formatWithOrdinals, u as unpromisify, l as buildRangeApiWithTimeZone, n as identity, r as requestJson, s as subtractDurations, o as intersectRanges, q as startOfDay, t as addDays, v as hashValuesToArray, w as buildEventApis, D as DelayedRunner, x as createFormatter, y as diffWholeDays, z as memoize, A as memoizeObjArg, E as isPropsEqual, F as Emitter, G as getInitialDate, H as rangeContainsMarker, I as createEmptyEventStore, J as reduceCurrentDate, K as reduceEventStore, L as rezoneEventStoreDates, M as mergeRawOptions, N as BASE_OPTION_REFINERS, O as CALENDAR_LISTENER_REFINERS, P as CALENDAR_OPTION_REFINERS, Q as COMPLEX_OPTION_COMPARATORS, R as VIEW_OPTION_REFINERS, S as DateEnv, U as DateProfileGenerator, W as createEventUi, X as parseBusinessHours, Y as Interaction, Z as getElSeg, _ as elementClosest, $ as EventImpl, a0 as listenBySelector, a1 as listenToHoverBySelector, a2 as PureComponent, a3 as buildViewContext, a4 as parseInteractionSettings, a5 as interactionSettingsStore, a6 as getNow, a7 as getIsHeightAuto, a8 as CalendarImpl, a9 as flushSync, aa as CalendarRoot, ab as RenderId, ac as ensureElHasStyles, ad as applyStyleProp, ae as sliceEventStore } from './internal-common.js';
+import { m as mergeProps, g as guid, i as isArraysEqual, T as Theme, a as mapHash, B as BaseComponent, V as ViewContextType, C as ContentContainer, b as buildViewClassNames, c as greatestDurationDenominator, d as createDuration, e as BASE_OPTION_DEFAULTS, f as arrayToHash, h as filterHash, j as buildEventSourceRefiners, p as parseEventSource, k as formatWithOrdinals, u as unpromisify, l as buildRangeApiWithTimeZone, n as identity, r as requestJson, s as subtractDurations, o as intersectRanges, q as startOfDay, t as addDays, v as hashValuesToArray, w as buildEventApis, D as DelayedRunner, x as createFormatter, y as diffWholeDays, z as memoize, A as memoizeObjArg, E as isPropsEqual, F as Emitter, G as getInitialDate, H as rangeContainsMarker, I as createEmptyEventStore, J as reduceCurrentDate, K as reduceEventStore, L as rezoneEventStoreDates, M as mergeRawOptions, N as BASE_OPTION_REFINERS, O as CALENDAR_LISTENER_REFINERS, P as CALENDAR_OPTION_REFINERS, Q as COMPLEX_OPTION_COMPARATORS, R as VIEW_OPTION_REFINERS, S as DateEnv, U as DateProfileGenerator, W as createEventUi, X as parseBusinessHours, Y as Interaction, Z as getElEventRange, _ as elementClosest, $ as EventImpl, a0 as listenBySelector, a1 as listenToHoverBySelector, a2 as PureComponent, a3 as buildViewContext, a4 as parseInteractionSettings, a5 as interactionSettingsStore, a6 as getNow, a7 as getIsHeightAuto, a8 as CalendarImpl, a9 as flushSync, aa as CalendarRoot, ab as RenderId, ac as ensureElHasStyles, ad as applyStyleProp, ae as sliceEventStore } from './internal-common.js';
 export { af as JsonRequestError } from './internal-common.js';
 import { createElement, Component, Fragment, render } from 'preact';
 import 'preact/compat';
@@ -1705,8 +1705,8 @@ class EventClicking extends Interaction {
         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
@@ -1714,7 +1714,7 @@ class EventClicking extends Interaction {
                 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,
                 });
@@ -1742,7 +1742,7 @@ class EventHovering extends Interaction {
             }
         };
         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);
             }
@@ -1762,11 +1762,11 @@ class EventHovering extends Interaction {
     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,
             });
@@ -2074,6 +2074,6 @@ function sliceEvents(props, allDay) {
     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';
 
 export { Calendar, createPlugin, formatDate, formatRange, globalLocales, globalPlugins, sliceEvents, version };

package/internal-common.cjs

@@ -4297,12 +4297,12 @@ function sliceEventStore(eventStore, eventUiBases, framingRange, nextDayThreshol
 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
@@ -4322,7 +4322,7 @@ function compileEventUi(eventDef, eventUiBases) {
 }
 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
@@ -4335,29 +4335,23 @@ function buildSegCompareObj(seg) {
     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;
     }
@@ -4366,8 +4360,8 @@ startOverride, endOverride) {
     }
     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)) {
@@ -4385,8 +4379,8 @@ startOverride, endOverride) {
     }
     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),
@@ -4436,8 +4430,8 @@ function buildEventRangeKey(eventRange) {
         : `${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 };
@@ -6132,6 +6126,99 @@ class DayTableModel {
     }
 }
 
+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);
@@ -6151,6 +6238,7 @@ class Scroller extends DateComponent {
     }
     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;
@@ -6181,13 +6269,20 @@ class Scroller extends DateComponent {
         });
     }
     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;
@@ -6207,6 +6302,12 @@ class Scroller extends DateComponent {
             setNormalizedScrollX(el, isRtl, x);
         }
     }
+    addScrollEndListener(handler) {
+        this.listener.emitter.on('scrollEnd', handler);
+    }
+    removeScrollEndListener(handler) {
+        this.listener.emitter.off('scrollEnd', handler);
+    }
 }
 // Public API
 // -------------------------------------------------------------------------------------------------
@@ -6701,38 +6802,20 @@ function buildDayRange(date) {
     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),
@@ -6741,12 +6824,12 @@ class EventContainer extends BaseComponent {
             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),
@@ -6756,13 +6839,13 @@ class EventContainer extends BaseComponent {
         };
         return (preact.createElement(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);
         }
     }
 }
@@ -6772,14 +6855,14 @@ class StandardEvent extends BaseComponent {
     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 (preact.createElement(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) => (preact.createElement(preact.Fragment, null,
+            }, elAttrs: getEventRangeAnchorAttrs(eventRange, context), defaultGenerator: renderInnerContent$1, timeText: timeText }), (InnerContent, eventContentArg) => (preact.createElement(preact.Fragment, null,
             preact.createElement(InnerContent, { elTag: "div", elClasses: ['fc-event-inner'], elStyle: { color: eventContentArg.textColor } }),
             Boolean(eventContentArg.isStartResizable) && (preact.createElement("div", { className: "fc-event-resizer fc-event-resizer-start" })),
             Boolean(eventContentArg.isEndResizable) && (preact.createElement("div", { className: "fc-event-resizer fc-event-resizer-end" }))))));
@@ -6805,8 +6888,8 @@ const NowIndicatorContainer = (props) => (preact.createElement(ViewContextType.C
 class BgEvent extends BaseComponent {
     render() {
         let { props } = this;
-        let { seg } = props;
-        return (preact.createElement(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 (preact.createElement(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) {
@@ -7288,7 +7371,6 @@ exports.PureComponent = PureComponent;
 exports.RefMap = RefMap;
 exports.RenderId = RenderId;
 exports.ScrollController = ScrollController;
-exports.ScrollResponder = ScrollResponder;
 exports.Scroller = Scroller;
 exports.SegHierarchy = SegHierarchy;
 exports.Slicer = Slicer;
@@ -7320,11 +7402,11 @@ exports.buildElAttrs = buildElAttrs;
 exports.buildEntryKey = buildEntryKey;
 exports.buildEventApis = buildEventApis;
 exports.buildEventRangeKey = buildEventRangeKey;
+exports.buildEventRangeTimeText = buildEventRangeTimeText;
 exports.buildEventSourceRefiners = buildEventSourceRefiners;
 exports.buildIsoString = buildIsoString;
 exports.buildNavLinkAttrs = buildNavLinkAttrs;
 exports.buildRangeApiWithTimeZone = buildRangeApiWithTimeZone;
-exports.buildSegTimeText = buildSegTimeText;
 exports.buildViewClassNames = buildViewClassNames;
 exports.buildViewContext = buildViewContext;
 exports.collectFromHash = collectFromHash;
@@ -7372,8 +7454,10 @@ exports.getClippingParents = getClippingParents;
 exports.getDateMeta = getDateMeta;
 exports.getDayClassNames = getDayClassNames;
 exports.getDefaultEventEnd = getDefaultEventEnd;
-exports.getElSeg = getElSeg;
+exports.getElEventRange = getElEventRange;
 exports.getEntrySpanEnd = getEntrySpanEnd;
+exports.getEventRangeAnchorAttrs = getEventRangeAnchorAttrs;
+exports.getEventRangeMeta = getEventRangeMeta;
 exports.getEventTargetViaRoot = getEventTargetViaRoot;
 exports.getInitialDate = getInitialDate;
 exports.getIsHeightAuto = getIsHeightAuto;
@@ -7384,8 +7468,6 @@ exports.getRectCenter = getRectCenter;
 exports.getRelevantEvents = getRelevantEvents;
 exports.getScrollbarWidths = getScrollbarWidths;
 exports.getScrollerSyncerClass = getScrollerSyncerClass;
-exports.getSegAnchorAttrs = getSegAnchorAttrs;
-exports.getSegMeta = getSegMeta;
 exports.getSlotClassNames = getSlotClassNames;
 exports.getStickyFooterScrollbar = getStickyFooterScrollbar;
 exports.getStickyHeaderDates = getStickyHeaderDates;

package/internal-common.d.ts

@@ -956,16 +956,13 @@ interface Hit {
 }
 
 interface Seg {
-    component?: DateComponent<any, any>;
+    eventRange?: EventRenderRange;
     isStart: boolean;
     isEnd: boolean;
-    eventRange?: EventRenderRange;
-    [otherProp: string]: any;
-    el?: never;
 }
-interface EventSegUiInteractionState {
+interface EventSegUiInteractionState<S = Seg> {
     affectedInstances: EventInstanceHash;
-    segs: Seg[];
+    segs: S[];
     isEvent: boolean;
 }
 declare abstract class DateComponent<Props = Dictionary, State = Dictionary> extends BaseComponent<Props, State> {
@@ -1106,13 +1103,15 @@ interface ScrollerInterface {
         x?: number;
         y?: number;
     }): void;
+    addScrollEndListener(handler: (x: number, y: number) => void): void;
+    removeScrollEndListener(handler: (x: number, y: number) => void): void;
 }
 
 interface ScrollerSyncerClass {
     new (horizontal?: boolean): ScrollerSyncerInterface;
 }
 interface ScrollerSyncerInterface extends ScrollerInterface {
-    handleChildren(scrollers: ScrollerInterface[], isRtl: boolean): void;
+    handleChildren(scrollers: ScrollerInterface[]): void;
     destroy(): void;
 }
 
@@ -1374,8 +1373,8 @@ declare function sliceEventStore(eventStore: EventStore, eventUiBases: EventUiHa
     fg: EventRenderRange[];
 };
 declare function hasBgRendering(def: EventDef): boolean;
-declare function getElSeg(el: HTMLElement): Seg | null;
-declare function sortEventSegs(segs: any, eventOrderSpecs: OrderSpec<EventImpl>[]): Seg[];
+declare function getElEventRange(el: HTMLElement): EventRenderRange | null;
+declare function sortEventSegs<S extends Seg>(segs: S[], eventOrderSpecs: OrderSpec<EventImpl>[]): S[];
 interface EventContentArg {
     event: EventImpl;
     timeText: string;
@@ -1397,16 +1396,16 @@ interface EventContentArg {
     view: ViewApi;
 }
 type EventMountArg = MountArg<EventContentArg>;
-declare function buildSegTimeText(seg: Seg, timeFormat: DateFormatter, context: ViewContext, defaultDisplayEventTime?: boolean, // defaults to true
+declare function buildEventRangeTimeText(eventRange: EventRenderRange, timeFormat: DateFormatter, context: ViewContext, defaultDisplayEventTime?: boolean, // defaults to true
 defaultDisplayEventEnd?: boolean, // defaults to true
 startOverride?: DateMarker, endOverride?: DateMarker): string;
-declare function getSegMeta(seg: Seg, todayRange: DateRange, nowDate?: DateMarker): {
+declare function getEventRangeMeta(eventRange: EventRenderRange, todayRange: DateRange, nowDate?: DateMarker): {
     isPast: boolean;
     isFuture: boolean;
     isToday: boolean;
 };
 declare function buildEventRangeKey(eventRange: EventRenderRange): string;
-declare function getSegAnchorAttrs(seg: Seg, context: ViewContext): {
+declare function getEventRangeAnchorAttrs(eventRange: EventRenderRange, context: ViewContext): {
     tabIndex: number;
     onKeyDown(ev: KeyboardEvent): void;
 } | {
@@ -2475,6 +2474,27 @@ declare class DayTableModel {
     sliceRange(range: DateRange): DayTableSeg[];
 }
 
+declare class ScrollListener {
+    el: HTMLElement;
+    emitter: Emitter<any>;
+    private isScrolling;
+    private isTouching;
+    private isRecentlyWheeled;
+    private isRecentlyScrolled;
+    private wheelWaiter;
+    private scrollWaiter;
+    constructor(el: HTMLElement);
+    destroy(): void;
+    private startScroll;
+    endScroll(): void;
+    private handleScroll;
+    private _handleScrollWaited;
+    private handleWheel;
+    private _handleWheelWaited;
+    private handleTouchStart;
+    private handleTouchEnd;
+}
+
 interface ScrollerProps {
     vertical?: boolean;
     horizontal?: boolean;
@@ -2490,6 +2510,7 @@ interface ScrollerProps {
 }
 declare class Scroller extends DateComponent$1<ScrollerProps> implements ScrollerInterface {
     private elRef;
+    listener: ScrollListener;
     private disconnectSize?;
     private currentWidth;
     private currentHeight;
@@ -2499,13 +2520,15 @@ declare class Scroller extends DateComponent$1<ScrollerProps> implements Scrolle
     render(): createElement.JSX.Element;
     componentDidMount(): void;
     componentWillUnmount(): void;
-    get el(): HTMLElement;
+    endScroll(): void;
     get x(): number;
     get y(): number;
     scrollTo({ x, y }: {
         x?: number;
         y?: number;
     }): void;
+    addScrollEndListener(handler: (x: number, y: number) => void): void;
+    removeScrollEndListener(handler: (x: number, y: number) => void): void;
 }
 declare function getNormalizedScrollX(el: HTMLElement, isRtl: boolean): number;
 declare function setNormalizedScrollX(el: HTMLElement, isRtl: boolean, x: number): void;
@@ -2524,8 +2547,8 @@ interface SlicedProps<SegType extends Seg> {
     businessHourSegs: SegType[];
     fgEventSegs: SegType[];
     bgEventSegs: SegType[];
-    eventDrag: EventSegUiInteractionState | null;
-    eventResize: EventSegUiInteractionState | null;
+    eventDrag: EventSegUiInteractionState<SegType> | null;
+    eventResize: EventSegUiInteractionState<SegType> | null;
     eventSelection: string;
 }
 declare abstract class Slicer<SegType extends Seg, ExtraArgs extends any[] = []> {
@@ -2610,18 +2633,12 @@ declare class NowTimer extends Component<NowTimerProps, NowTimerState> {
     private clearTimeout;
 }
 
-declare class ScrollResponder<T> {
-    private _handleScroll;
-    protected queuedScroll?: T;
-    constructor(_handleScroll: (scroll: T) => boolean);
-    handleScroll: (scroll: T) => void;
-    drain(): void;
-}
-
 interface StandardEventProps {
     elRef?: ElRef;
     elClasses?: string[];
-    seg: Seg;
+    eventRange: EventRenderRange;
+    isStart: boolean;
+    isEnd: boolean;
     isDragging: boolean;
     isResizing: boolean;
     isDateSelecting: boolean;
@@ -2634,13 +2651,17 @@ interface StandardEventProps {
     defaultTimeFormat: DateFormatter;
     defaultDisplayEventTime?: boolean;
     defaultDisplayEventEnd?: boolean;
+    startOverride?: DateMarker;
+    endOverride?: DateMarker;
 }
 declare class StandardEvent extends BaseComponent<StandardEventProps> {
     render(): createElement.JSX.Element;
 }
 
 interface MinimalEventProps {
-    seg: Seg;
+    eventRange: EventRenderRange;
+    isStart: boolean;
+    isEnd: boolean;
     isDragging: boolean;
     isResizing: boolean;
     isDateSelecting: boolean;
@@ -2664,7 +2685,9 @@ declare class EventContainer extends BaseComponent<EventContainerProps> {
 }
 
 interface BgEventProps {
-    seg: Seg;
+    eventRange: EventRenderRange;
+    isStart: boolean;
+    isEnd: boolean;
     isPast: boolean;
     isFuture: boolean;
     isToday: boolean;
@@ -2676,4 +2699,4 @@ declare function renderFill(fillType: string): createElement.JSX.Element;
 
 declare function injectStyles(styleText: string): void;
 
-export { DayCellMountArg as $, AllowFunc as A, BusinessHoursInput as B, CalendarImpl as C, DateInput as D, EventSourceApi as E, FormatterInput as F, WeekNumberContentArg as G, WeekNumberMountArg as H, MoreLinkMountArg as I, JsonRequestError as J, SlotLaneContentArg as K, LocaleInput as L, MoreLinkContentArg as M, NativeFormatterOptions as N, OverlapFunc as O, PluginDefInput as P, SlotLaneMountArg as Q, SlotLabelContentArg as R, SpecificViewContentArg as S, SlotLabelMountArg as T, AllDayContentArg as U, ViewApi as V, WillUnmountHandler as W, AllDayMountArg as X, DayHeaderContentArg as Y, DayHeaderMountArg as Z, DayCellContentArg as _, CalendarOptions as a, enableCursor as a$, ViewContentArg as a0, ViewMountArg as a1, EventClickArg as a2, EventHoveringArg as a3, DateSelectArg as a4, DateUnselectArg as a5, WeekNumberCalculation as a6, ToolbarInput as a7, CustomButtonInput as a8, ButtonIconsInput as a9, RefinedOptionsFromRefiners as aA, CalendarListenerRefiners as aB, BASE_OPTION_DEFAULTS as aC, identity as aD, refineProps as aE, EventDef as aF, EventDefHash as aG, EventInstance as aH, EventInstanceHash as aI, createEventInstance as aJ, EventRefined as aK, EventTuple as aL, EventRefiners as aM, parseEventDef as aN, refineEventDef as aO, parseBusinessHours as aP, OrderSpec as aQ, padStart as aR, isInt as aS, parseFieldSpecs as aT, compareByFieldSpecs as aU, flexibleCompare as aV, preventSelection as aW, allowSelection as aX, preventContextMenu as aY, allowContextMenu as aZ, compareNumbers as a_, ButtonTextCompoundInput as aa, EventContentArg as ab, EventMountArg as ac, DatesSetArg as ad, EventAddArg as ae, EventChangeArg as af, EventDropArg as ag, EventRemoveArg as ah, ButtonHintCompoundInput as ai, CustomRenderingHandler as aj, CustomRenderingStore as ak, DateSpanApi as al, DatePointApi as am, DateSelectionApi as an, Duration as ao, EventSegment as ap, MoreLinkAction as aq, MoreLinkSimpleAction as ar, MoreLinkArg as as, MoreLinkHandler as at, Identity as au, Dictionary as av, BaseOptionRefiners as aw, BaseOptionsRefined as ax, ViewOptionsRefined as ay, RawOptionsFromRefiners as az, PluginDef as b, getClippingParents as b$, disableCursor as b0, guid as b1, computeVisibleDayRange as b2, isMultiDayRange as b3, diffDates as b4, removeExact as b5, isArraysEqual as b6, MemoizeHashFunc as b7, MemoiseArrayFunc as b8, memoize as b9, EventStore as bA, createEmptyEventStore as bB, mergeEventStores as bC, getRelevantEvents as bD, eventTupleToStore as bE, EventUiHash as bF, EventUi as bG, combineEventUis as bH, createEventUi as bI, SplittableProps as bJ, Splitter as bK, getDayClassNames as bL, getDateMeta as bM, getSlotClassNames as bN, DateMeta as bO, setStateDimMap as bP, isDimMapsEqual as bQ, isDimsEqual as bR, watchSize as bS, watchWidth as bT, watchHeight as bU, afterSize as bV, buildNavLinkAttrs as bW, preventDefault as bX, whenTransitionDone as bY, computeInnerRect as bZ, computeEdges as b_, memoizeObjArg as ba, memoizeArraylike as bb, memoizeHashlike as bc, Rect as bd, Point as be, intersectRects as bf, pointInsideRect as bg, constrainPoint as bh, getRectCenter as bi, diffPoints as bj, translateRect as bk, mapHash as bl, filterHash as bm, isPropsEqual as bn, compareObjs as bo, collectFromHash as bp, findElements as bq, findDirectChildren as br, removeElement as bs, applyStyle as bt, elementMatches as bu, elementClosest as bv, getEventTargetViaRoot as bw, getUniqueDomId as bx, parseClassNames as by, fracToCssDim as bz, CalendarApi as c, SegGroup as c$, computeRect as c0, unpromisify as c1, Emitter as c2, DateRange as c3, rangeContainsMarker as c4, intersectRanges as c5, rangesEqual as c6, rangesIntersect as c7, rangeContainsRange as c8, PositionCache as c9, isValidDate as cA, createDuration as cB, asCleanDays as cC, multiplyDuration as cD, addDurations as cE, asRoughMinutes as cF, asRoughSeconds as cG, asRoughMs as cH, wholeDivideDurations as cI, greatestDurationDenominator as cJ, DateEnv as cK, createFormatter as cL, DateFormatter as cM, VerboseFormattingArg as cN, formatIsoTimeString as cO, formatDayString as cP, buildIsoString as cQ, formatIsoMonthStr as cR, NamedTimeZoneImpl as cS, parse as cT, EventSourceDef as cU, EventSourceRefined as cV, EventSourceRefiners as cW, SegSpan as cX, SegRect as cY, SegEntry as cZ, SegInsertion as c_, ScrollController as ca, ElementScrollController as cb, WindowScrollController as cc, Theme as cd, ViewContext as ce, ViewContextType as cf, Seg as cg, EventSegUiInteractionState as ch, DateComponent as ci, CalendarData as cj, ViewProps as ck, DateProfile as cl, DateProfileGenerator as cm, ViewSpec as cn, DateSpan as co, isDateSpansEqual as cp, DateMarker as cq, addDays as cr, startOfDay as cs, addMs as ct, addWeeks as cu, diffWeeks as cv, diffWholeWeeks as cw, diffWholeDays as cx, diffDayAndTime as cy, diffDays as cz, EventApi as d, getIsRtlScrollbarOnLeft as d$, SegHierarchy as d0, buildEntryKey as d1, getEntrySpanEnd as d2, binarySearch as d3, groupIntersectingEntries as d4, intersectSpans as d5, InteractionSettings as d6, InteractionSettingsStore as d7, Interaction as d8, interactionSettingsToStore as d9, buildEventRangeKey as dA, getSegAnchorAttrs as dB, DayTableCell as dC, DayTableModel as dD, Scroller as dE, getNormalizedScrollX as dF, setNormalizedScrollX as dG, SlicedProps as dH, Slicer as dI, EventMutation as dJ, applyMutationToEventStore as dK, Constraint as dL, isPropsValid as dM, isInteractionValid as dN, isDateSelectionValid as dO, requestJson as dP, BaseComponent as dQ, setRef as dR, DelayedRunner as dS, getStickyFooterScrollbar as dT, getStickyHeaderDates as dU, getIsHeightAuto as dV, getScrollerSyncerClass as dW, ScrollerInterface as dX, ScrollerSyncerInterface as dY, getScrollbarWidths as dZ, RefMap as d_, interactionSettingsStore as da, PointerDragEvent as db, Hit as dc, dateSelectionJoinTransformer as dd, eventDragMutationMassager as de, EventDropTransformers as df, ElementDragging as dg, config as dh, RecurringType as di, DragMetaInput as dj, DragMeta as dk, parseDragMeta as dl, ViewPropsTransformer as dm, Action as dn, CalendarContext as dp, CalendarContentProps as dq, CalendarRoot as dr, DaySeriesModel as ds, EventInteractionState as dt, sliceEventStore as du, hasBgRendering as dv, getElSeg as dw, buildSegTimeText as dx, sortEventSegs as dy, getSegMeta as dz, EventRenderRange as e, NowTimer as e0, ScrollResponder as e1, MountArg as e2, StandardEvent as e3, NowIndicatorContainer as e4, DayCellContainer as e5, hasCustomDayCellContent as e6, MinimalEventProps as e7, EventContainer as e8, renderFill as e9, BgEvent as ea, WeekNumberContainerProps as eb, WeekNumberContainer as ec, MoreLinkContainer as ed, computeEarliestSegStart as ee, ViewContainerProps as ef, ViewContainer as eg, DatePointTransform as eh, DateSpanTransform as ei, triggerDateSelect as ej, getDefaultEventEnd as ek, injectStyles as el, EventImpl as em, buildEventApis as en, ElProps as eo, buildElAttrs as ep, InnerContainerFunc as eq, ContentContainer as er, CustomRendering as es, CalendarListeners as f, ViewOptions as g, DurationInput as h, DateSpanInput as i, DateRangeInput as j, EventSourceInput as k, EventSourceFunc as l, EventSourceFuncArg as m, EventInput as n, EventInputTransformer as o, CssDimValue as p, LocaleSingularArg as q, ConstraintInput as r, sliceEvents as s, ViewComponentType as t, SpecificViewMountArg as u, ClassNamesGenerator as v, CustomContentGenerator as w, DidMountHandler as x, NowIndicatorContentArg as y, NowIndicatorMountArg as z };
+export { DayCellMountArg as $, AllowFunc as A, BusinessHoursInput as B, CalendarImpl as C, DateInput as D, EventSourceApi as E, FormatterInput as F, WeekNumberContentArg as G, WeekNumberMountArg as H, MoreLinkMountArg as I, JsonRequestError as J, SlotLaneContentArg as K, LocaleInput as L, MoreLinkContentArg as M, NativeFormatterOptions as N, OverlapFunc as O, PluginDefInput as P, SlotLaneMountArg as Q, SlotLabelContentArg as R, SpecificViewContentArg as S, SlotLabelMountArg as T, AllDayContentArg as U, ViewApi as V, WillUnmountHandler as W, AllDayMountArg as X, DayHeaderContentArg as Y, DayHeaderMountArg as Z, DayCellContentArg as _, CalendarOptions as a, enableCursor as a$, ViewContentArg as a0, ViewMountArg as a1, EventClickArg as a2, EventHoveringArg as a3, DateSelectArg as a4, DateUnselectArg as a5, WeekNumberCalculation as a6, ToolbarInput as a7, CustomButtonInput as a8, ButtonIconsInput as a9, RefinedOptionsFromRefiners as aA, CalendarListenerRefiners as aB, BASE_OPTION_DEFAULTS as aC, identity as aD, refineProps as aE, EventDef as aF, EventDefHash as aG, EventInstance as aH, EventInstanceHash as aI, createEventInstance as aJ, EventRefined as aK, EventTuple as aL, EventRefiners as aM, parseEventDef as aN, refineEventDef as aO, parseBusinessHours as aP, OrderSpec as aQ, padStart as aR, isInt as aS, parseFieldSpecs as aT, compareByFieldSpecs as aU, flexibleCompare as aV, preventSelection as aW, allowSelection as aX, preventContextMenu as aY, allowContextMenu as aZ, compareNumbers as a_, ButtonTextCompoundInput as aa, EventContentArg as ab, EventMountArg as ac, DatesSetArg as ad, EventAddArg as ae, EventChangeArg as af, EventDropArg as ag, EventRemoveArg as ah, ButtonHintCompoundInput as ai, CustomRenderingHandler as aj, CustomRenderingStore as ak, DateSpanApi as al, DatePointApi as am, DateSelectionApi as an, Duration as ao, EventSegment as ap, MoreLinkAction as aq, MoreLinkSimpleAction as ar, MoreLinkArg as as, MoreLinkHandler as at, Identity as au, Dictionary as av, BaseOptionRefiners as aw, BaseOptionsRefined as ax, ViewOptionsRefined as ay, RawOptionsFromRefiners as az, PluginDef as b, getClippingParents as b$, disableCursor as b0, guid as b1, computeVisibleDayRange as b2, isMultiDayRange as b3, diffDates as b4, removeExact as b5, isArraysEqual as b6, MemoizeHashFunc as b7, MemoiseArrayFunc as b8, memoize as b9, EventStore as bA, createEmptyEventStore as bB, mergeEventStores as bC, getRelevantEvents as bD, eventTupleToStore as bE, EventUiHash as bF, EventUi as bG, combineEventUis as bH, createEventUi as bI, SplittableProps as bJ, Splitter as bK, getDayClassNames as bL, getDateMeta as bM, getSlotClassNames as bN, DateMeta as bO, setStateDimMap as bP, isDimMapsEqual as bQ, isDimsEqual as bR, watchSize as bS, watchWidth as bT, watchHeight as bU, afterSize as bV, buildNavLinkAttrs as bW, preventDefault as bX, whenTransitionDone as bY, computeInnerRect as bZ, computeEdges as b_, memoizeObjArg as ba, memoizeArraylike as bb, memoizeHashlike as bc, Rect as bd, Point as be, intersectRects as bf, pointInsideRect as bg, constrainPoint as bh, getRectCenter as bi, diffPoints as bj, translateRect as bk, mapHash as bl, filterHash as bm, isPropsEqual as bn, compareObjs as bo, collectFromHash as bp, findElements as bq, findDirectChildren as br, removeElement as bs, applyStyle as bt, elementMatches as bu, elementClosest as bv, getEventTargetViaRoot as bw, getUniqueDomId as bx, parseClassNames as by, fracToCssDim as bz, CalendarApi as c, SegGroup as c$, computeRect as c0, unpromisify as c1, Emitter as c2, DateRange as c3, rangeContainsMarker as c4, intersectRanges as c5, rangesEqual as c6, rangesIntersect as c7, rangeContainsRange as c8, PositionCache as c9, isValidDate as cA, createDuration as cB, asCleanDays as cC, multiplyDuration as cD, addDurations as cE, asRoughMinutes as cF, asRoughSeconds as cG, asRoughMs as cH, wholeDivideDurations as cI, greatestDurationDenominator as cJ, DateEnv as cK, createFormatter as cL, DateFormatter as cM, VerboseFormattingArg as cN, formatIsoTimeString as cO, formatDayString as cP, buildIsoString as cQ, formatIsoMonthStr as cR, NamedTimeZoneImpl as cS, parse as cT, EventSourceDef as cU, EventSourceRefined as cV, EventSourceRefiners as cW, SegSpan as cX, SegRect as cY, SegEntry as cZ, SegInsertion as c_, ScrollController as ca, ElementScrollController as cb, WindowScrollController as cc, Theme as cd, ViewContext as ce, ViewContextType as cf, Seg as cg, EventSegUiInteractionState as ch, DateComponent as ci, CalendarData as cj, ViewProps as ck, DateProfile as cl, DateProfileGenerator as cm, ViewSpec as cn, DateSpan as co, isDateSpansEqual as cp, DateMarker as cq, addDays as cr, startOfDay as cs, addMs as ct, addWeeks as cu, diffWeeks as cv, diffWholeWeeks as cw, diffWholeDays as cx, diffDayAndTime as cy, diffDays as cz, EventApi as d, getIsRtlScrollbarOnLeft as d$, SegHierarchy as d0, buildEntryKey as d1, getEntrySpanEnd as d2, binarySearch as d3, groupIntersectingEntries as d4, intersectSpans as d5, InteractionSettings as d6, InteractionSettingsStore as d7, Interaction as d8, interactionSettingsToStore as d9, buildEventRangeKey as dA, getEventRangeAnchorAttrs as dB, DayTableCell as dC, DayTableModel as dD, Scroller as dE, getNormalizedScrollX as dF, setNormalizedScrollX as dG, SlicedProps as dH, Slicer as dI, EventMutation as dJ, applyMutationToEventStore as dK, Constraint as dL, isPropsValid as dM, isInteractionValid as dN, isDateSelectionValid as dO, requestJson as dP, BaseComponent as dQ, setRef as dR, DelayedRunner as dS, getStickyFooterScrollbar as dT, getStickyHeaderDates as dU, getIsHeightAuto as dV, getScrollerSyncerClass as dW, ScrollerInterface as dX, ScrollerSyncerInterface as dY, getScrollbarWidths as dZ, RefMap as d_, interactionSettingsStore as da, PointerDragEvent as db, Hit as dc, dateSelectionJoinTransformer as dd, eventDragMutationMassager as de, EventDropTransformers as df, ElementDragging as dg, config as dh, RecurringType as di, DragMetaInput as dj, DragMeta as dk, parseDragMeta as dl, ViewPropsTransformer as dm, Action as dn, CalendarContext as dp, CalendarContentProps as dq, CalendarRoot as dr, DaySeriesModel as ds, EventInteractionState as dt, sliceEventStore as du, hasBgRendering as dv, getElEventRange as dw, buildEventRangeTimeText as dx, sortEventSegs as dy, getEventRangeMeta as dz, EventRenderRange as e, NowTimer as e0, MountArg as e1, StandardEvent as e2, NowIndicatorContainer as e3, DayCellContainer as e4, hasCustomDayCellContent as e5, MinimalEventProps as e6, EventContainer as e7, renderFill as e8, BgEvent as e9, WeekNumberContainerProps as ea, WeekNumberContainer as eb, MoreLinkContainer as ec, computeEarliestSegStart as ed, ViewContainerProps as ee, ViewContainer as ef, DatePointTransform as eg, DateSpanTransform as eh, triggerDateSelect as ei, getDefaultEventEnd as ej, injectStyles as ek, EventImpl as el, buildEventApis as em, ElProps as en, buildElAttrs as eo, InnerContainerFunc as ep, ContentContainer as eq, CustomRendering as er, CalendarListeners as f, ViewOptions as g, DurationInput as h, DateSpanInput as i, DateRangeInput as j, EventSourceInput as k, EventSourceFunc as l, EventSourceFuncArg as m, EventInput as n, EventInputTransformer as o, CssDimValue as p, LocaleSingularArg as q, ConstraintInput as r, sliceEvents as s, ViewComponentType as t, SpecificViewMountArg as u, ClassNamesGenerator as v, CustomContentGenerator as w, DidMountHandler as x, NowIndicatorContentArg as y, NowIndicatorMountArg as z };