@fullcalendar/scrollgrid 6.0.0-beta.1 → 6.0.0-beta.2

package/{main.global.js → index.global.js}

@@ -1,105 +1,19 @@
 /*!
-FullCalendar Scheduler v6.0.0-beta.1
-Docs & License: https://fullcalendar.io/scheduler
+FullCalendar ScrollGrid Plugin v6.0.0-beta.2
+Docs & License: https://fullcalendar.io/premium
 (c) 2022 Adam Shaw
 */
-var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
+FullCalendar.ScrollGrid = (function (exports, internal$1, core, premiumCommonPlugin, preact) {
     'use strict';
 
-    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+    function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
-    var premiumCommonPlugin__default = /*#__PURE__*/_interopDefaultLegacy(premiumCommonPlugin);
-
-    const WHEEL_EVENT_NAMES = 'wheel mousewheel DomMouseScroll MozMousePixelScroll'.split(' ');
-    /*
-    ALSO, with the ability to disable touch
-    */
-    class ScrollListener {
-        constructor(el) {
-            this.el = el;
-            this.emitter = new common.Emitter();
-            this.isScrolling = false;
-            this.isTouching = false; // user currently has finger down?
-            this.isRecentlyWheeled = false;
-            this.isRecentlyScrolled = false;
-            this.wheelWaiter = new common.DelayedRunner(this._handleWheelWaited.bind(this));
-            this.scrollWaiter = new common.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);
-            }
-        }
-        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);
-            }
-        }
-        // 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;
-        }
-    }
+    var premiumCommonPlugin__default = /*#__PURE__*/_interopDefault(premiumCommonPlugin);
 
     // TODO: assume the el has no borders?
     function getScrollCanvasOrigin(scrollEl) {
         let rect = scrollEl.getBoundingClientRect();
-        let edges = common.computeEdges(scrollEl); // TODO: pass in isRtl?
+        let edges = internal$1.computeEdges(scrollEl); // TODO: pass in isRtl?
         return {
             left: rect.left + edges.borderLeft + edges.scrollbarLeft - getScrollFromLeftEdge(scrollEl),
             top: rect.top + edges.borderTop - scrollEl.scrollTop,
@@ -162,16 +76,13 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
                 system = 'negative'; // scroll is a negative number from the right edge
             }
         }
-        common.removeElement(el);
+        internal$1.removeElement(el);
         return system;
     }
 
-    const IS_MS_EDGE = typeof navigator !== 'undefined' && /Edge/.test(navigator.userAgent); // TODO: what about Chromeum-based Edge?
     const STICKY_SELECTOR = '.fc-sticky';
     /*
-    useful beyond the native position:sticky for these reasons:
-    - support in IE11
-    - nice centering support
+    Goes beyond mere position:sticky, allows horizontal centering
 
     REQUIREMENT: fc-sticky elements, if the fc-sticky className is taken away, should NOT have relative or absolute positioning.
     This is because we attach the coords with JS, and the VDOM might take away the fc-sticky class but doesn't know kill the positioning.
@@ -182,41 +93,20 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         constructor(scrollEl, isRtl) {
             this.scrollEl = scrollEl;
             this.isRtl = isRtl;
-            this.usingRelative = null;
             this.updateSize = () => {
                 let { scrollEl } = this;
-                let els = common.findElements(scrollEl, STICKY_SELECTOR);
+                let els = internal$1.findElements(scrollEl, STICKY_SELECTOR);
                 let elGeoms = this.queryElGeoms(els);
                 let viewportWidth = scrollEl.clientWidth;
-                let viewportHeight = scrollEl.clientHeight;
-                if (this.usingRelative) {
-                    let elDestinations = this.computeElDestinations(elGeoms, viewportWidth); // read before prepPositioning
-                    assignRelativePositions(els, elGeoms, elDestinations, viewportWidth, viewportHeight);
-                }
-                else {
-                    assignStickyPositions(els, elGeoms, viewportWidth);
-                }
+                assignStickyPositions(els, elGeoms, viewportWidth);
             };
-            this.usingRelative =
-                !getStickySupported() || // IE11
-                    // https://stackoverflow.com/questions/56835658/in-microsoft-edge-sticky-positioning-doesnt-work-when-combined-with-dir-rtl
-                    (IS_MS_EDGE && isRtl);
-            if (this.usingRelative) {
-                this.listener = new ScrollListener(scrollEl);
-                this.listener.emitter.on('scrollEnd', this.updateSize);
-            }
-        }
-        destroy() {
-            if (this.listener) {
-                this.listener.destroy();
-            }
         }
         queryElGeoms(els) {
             let { scrollEl, isRtl } = this;
             let canvasOrigin = getScrollCanvasOrigin(scrollEl);
             let elGeoms = [];
             for (let el of els) {
-                let parentBound = common.translateRect(common.computeInnerRect(el.parentNode, true, true), // weird way to call this!!!
+                let parentBound = internal$1.translateRect(internal$1.computeInnerRect(el.parentNode, true, true), // weird way to call this!!!
                 -canvasOrigin.left, -canvasOrigin.top);
                 let elRect = el.getBoundingClientRect();
                 let computedStyles = window.getComputedStyle(el);
@@ -229,7 +119,7 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
                     textAlign = isRtl ? 'left' : 'right';
                 }
                 if (computedStyles.position !== 'sticky') {
-                    naturalBound = common.translateRect(elRect, -canvasOrigin.left - (parseFloat(computedStyles.left) || 0), // could be 'auto'
+                    naturalBound = internal$1.translateRect(elRect, -canvasOrigin.left - (parseFloat(computedStyles.left) || 0), // could be 'auto'
                     -canvasOrigin.top - (parseFloat(computedStyles.top) || 0));
                 }
                 elGeoms.push({
@@ -242,59 +132,6 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
             }
             return elGeoms;
         }
-        // only for IE
-        computeElDestinations(elGeoms, viewportWidth) {
-            let { scrollEl } = this;
-            let viewportTop = scrollEl.scrollTop;
-            let viewportLeft = getScrollFromLeftEdge(scrollEl);
-            let viewportRight = viewportLeft + viewportWidth;
-            return elGeoms.map((elGeom) => {
-                let { elWidth, elHeight, parentBound, naturalBound } = elGeom;
-                let destLeft; // relative to canvas topleft
-                let destTop; // "
-                switch (elGeom.textAlign) {
-                    case 'left':
-                        destLeft = viewportLeft;
-                        break;
-                    case 'right':
-                        destLeft = viewportRight - elWidth;
-                        break;
-                    case 'center':
-                        destLeft = (viewportLeft + viewportRight) / 2 - elWidth / 2; /// noooo, use half-width insteadddddddd
-                        break;
-                }
-                destLeft = Math.min(destLeft, parentBound.right - elWidth);
-                destLeft = Math.max(destLeft, parentBound.left);
-                destTop = viewportTop;
-                destTop = Math.min(destTop, parentBound.bottom - elHeight);
-                destTop = Math.max(destTop, naturalBound.top); // better to use natural top for upper bound
-                return { left: destLeft, top: destTop };
-            });
-        }
-    }
-    function assignRelativePositions(els, elGeoms, elDestinations, viewportWidth, viewportHeight) {
-        els.forEach((el, i) => {
-            let { naturalBound, parentBound } = elGeoms[i];
-            let parentWidth = parentBound.right - parentBound.left;
-            let parentHeight = parentBound.bottom - parentBound.bottom;
-            let left;
-            let top;
-            if (parentWidth > viewportWidth ||
-                parentHeight > viewportHeight) {
-                left = elDestinations[i].left - naturalBound.left;
-                top = elDestinations[i].top - naturalBound.top;
-            }
-            else { // if parent container can be completely in view, we don't need stickiness
-                left = '';
-                top = '';
-            }
-            common.applyStyle(el, {
-                position: 'relative',
-                left,
-                right: -left,
-                top,
-            });
-        });
     }
     function assignStickyPositions(els, elGeoms, viewportWidth) {
         els.forEach((el, i) => {
@@ -308,40 +145,25 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
             else { // if parent container can be completely in view, we don't need stickiness
                 left = '';
             }
-            common.applyStyle(el, {
+            internal$1.applyStyle(el, {
                 left,
                 right: left,
                 top: 0,
             });
         });
     }
-    let _isStickySupported;
-    function getStickySupported() {
-        if (_isStickySupported == null) {
-            _isStickySupported = computeStickySupported();
-        }
-        return _isStickySupported;
-    }
-    function computeStickySupported() {
-        let el = document.createElement('div');
-        el.style.position = 'sticky';
-        document.body.appendChild(el);
-        let val = window.getComputedStyle(el).position;
-        common.removeElement(el);
-        return val === 'sticky';
-    }
 
-    class ClippedScroller extends common.BaseComponent {
+    class ClippedScroller extends internal$1.BaseComponent {
         constructor() {
             super(...arguments);
-            this.elRef = common.createRef();
+            this.elRef = preact.createRef();
             this.state = {
                 xScrollbarWidth: 0,
                 yScrollbarWidth: 0,
             };
             this.handleScroller = (scroller) => {
                 this.scroller = scroller;
-                common.setRef(this.props.scrollerRef, scroller);
+                internal$1.setRef(this.props.scrollerRef, scroller);
             };
             this.handleSizing = () => {
                 let { props } = this;
@@ -355,7 +177,7 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         }
         render() {
             let { props, state, context } = this;
-            let isScrollbarOnLeft = context.isRtl && common.getIsRtlScrollbarOnLeft();
+            let isScrollbarOnLeft = context.isRtl && internal$1.getIsRtlScrollbarOnLeft();
             let overcomeLeft = 0;
             let overcomeRight = 0;
             let overcomeBottom = 0;
@@ -372,8 +194,8 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
                     }
                 }
             }
-            return (common.createElement("div", { ref: this.elRef, className: 'fc-scroller-harness' + (props.liquid ? ' fc-scroller-harness-liquid' : '') },
-                common.createElement(common.Scroller, { ref: this.handleScroller, elRef: this.props.scrollerElRef, overflowX: props.overflowX === 'scroll-hidden' ? 'scroll' : props.overflowX, overflowY: props.overflowY === 'scroll-hidden' ? 'scroll' : props.overflowY, overcomeLeft: overcomeLeft, overcomeRight: overcomeRight, overcomeBottom: overcomeBottom, maxHeight: typeof props.maxHeight === 'number'
+            return (preact.createElement("div", { ref: this.elRef, className: 'fc-scroller-harness' + (props.liquid ? ' fc-scroller-harness-liquid' : '') },
+                preact.createElement(internal$1.Scroller, { ref: this.handleScroller, elRef: this.props.scrollerElRef, overflowX: props.overflowX === 'scroll-hidden' ? 'scroll' : props.overflowX, overflowY: props.overflowY === 'scroll-hidden' ? 'scroll' : props.overflowY, overcomeLeft: overcomeLeft, overcomeRight: overcomeRight, overcomeBottom: overcomeBottom, maxHeight: typeof props.maxHeight === 'number'
                         ? (props.maxHeight + (props.overflowX === 'scroll-hidden' ? state.xScrollbarWidth : 0))
                         : '', liquid: props.liquid, liquidIsAbsolute: true }, props.children)));
         }
@@ -382,7 +204,7 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
             this.context.addResizeHandler(this.handleSizing);
         }
         componentDidUpdate(prevProps) {
-            if (!common.isPropsEqual(prevProps, this.props)) { // an external change?
+            if (!internal$1.isPropsEqual(prevProps, this.props)) { // an external change?
                 this.handleSizing();
             }
         }
@@ -397,6 +219,92 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         }
     }
 
+    const WHEEL_EVENT_NAMES = 'wheel mousewheel DomMouseScroll MozMousePixelScroll'.split(' ');
+    /*
+    ALSO, with the ability to disable touch
+    */
+    class ScrollListener {
+        constructor(el) {
+            this.el = el;
+            this.emitter = new internal$1.Emitter();
+            this.isScrolling = false;
+            this.isTouching = false; // user currently has finger down?
+            this.isRecentlyWheeled = false;
+            this.isRecentlyScrolled = false;
+            this.wheelWaiter = new internal$1.DelayedRunner(this._handleWheelWaited.bind(this));
+            this.scrollWaiter = new internal$1.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);
+            }
+        }
+        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);
+            }
+        }
+        // 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 ScrollSyncer {
         constructor(isVertical, scrollEls) {
             this.isVertical = isVertical;
@@ -467,20 +375,20 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         }
     }
 
+    internal$1.config.SCROLLGRID_RESIZE_INTERVAL = 500;
     /*
     TODO: make <ScrollGridSection> subcomponent
     NOTE: doesn't support collapsibleWidth (which is sortof a hack anyway)
     */
-    class ScrollGrid extends common.BaseComponent {
+    class ScrollGrid extends internal$1.BaseComponent {
         constructor() {
             super(...arguments);
-            this.compileColGroupStats = common.memoizeArraylike(compileColGroupStat, isColGroupStatsEqual);
-            this.renderMicroColGroups = common.memoizeArraylike(common.renderMicroColGroup); // yucky to memoize VNodes, but much more efficient for consumers
-            this.clippedScrollerRefs = new common.RefMap();
+            this.compileColGroupStats = internal$1.memoizeArraylike(compileColGroupStat, isColGroupStatsEqual);
+            this.renderMicroColGroups = internal$1.memoizeArraylike(internal$1.renderMicroColGroup); // yucky to memoize VNodes, but much more efficient for consumers
+            this.clippedScrollerRefs = new internal$1.RefMap();
             // doesn't hold non-scrolling els used just for padding
-            this.scrollerElRefs = new common.RefMap(this._handleScrollerEl.bind(this));
-            this.chunkElRefs = new common.RefMap(this._handleChunkEl.bind(this));
-            this.stickyScrollings = [];
+            this.scrollerElRefs = new internal$1.RefMap(this._handleScrollerEl.bind(this));
+            this.chunkElRefs = new internal$1.RefMap(this._handleChunkEl.bind(this));
             this.scrollSyncersBySection = {};
             this.scrollSyncersByColumn = {};
             // for row-height-syncing
@@ -540,7 +448,7 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
             let { shrinkWidths } = state;
             let colGroupStats = this.compileColGroupStats(props.colGroups.map((colGroup) => [colGroup]));
             let microColGroupNodes = this.renderMicroColGroups(colGroupStats.map((stat, i) => [stat.cols, shrinkWidths[i]]));
-            let classNames = common.getScrollGridClassNames(props.liquid, context);
+            let classNames = internal$1.getScrollGridClassNames(props.liquid, context);
             this.getDims();
             // TODO: make DRY
             let sectionConfigs = props.sections;
@@ -562,39 +470,39 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
                 footSectionNodes.push(this.renderSection(currentConfig, configI, colGroupStats, microColGroupNodes, state.sectionRowMaxHeights, true));
                 configI += 1;
             }
-            const isBuggy = !common.getCanVGrowWithinCell(); // see NOTE in SimpleScrollGrid
+            const isBuggy = !internal$1.getCanVGrowWithinCell(); // see NOTE in SimpleScrollGrid
             const roleAttrs = { role: 'rowgroup' };
-            return common.createElement('table', {
+            return preact.createElement('table', {
                 ref: props.elRef,
                 role: 'grid',
                 className: classNames.join(' '),
-            }, renderMacroColGroup(colGroupStats, shrinkWidths), Boolean(!isBuggy && headSectionNodes.length) && common.createElement('thead', roleAttrs, ...headSectionNodes), Boolean(!isBuggy && bodySectionNodes.length) && common.createElement('tbody', roleAttrs, ...bodySectionNodes), Boolean(!isBuggy && footSectionNodes.length) && common.createElement('tfoot', roleAttrs, ...footSectionNodes), isBuggy && common.createElement('tbody', roleAttrs, ...headSectionNodes, ...bodySectionNodes, ...footSectionNodes));
+            }, renderMacroColGroup(colGroupStats, shrinkWidths), Boolean(!isBuggy && headSectionNodes.length) && preact.createElement('thead', roleAttrs, ...headSectionNodes), Boolean(!isBuggy && bodySectionNodes.length) && preact.createElement('tbody', roleAttrs, ...bodySectionNodes), Boolean(!isBuggy && footSectionNodes.length) && preact.createElement('tfoot', roleAttrs, ...footSectionNodes), isBuggy && preact.createElement('tbody', roleAttrs, ...headSectionNodes, ...bodySectionNodes, ...footSectionNodes));
         }
         renderSection(sectionConfig, sectionIndex, colGroupStats, microColGroupNodes, sectionRowMaxHeights, isHeader) {
             if ('outerContent' in sectionConfig) {
-                return (common.createElement(common.Fragment, { key: sectionConfig.key }, sectionConfig.outerContent));
+                return (preact.createElement(preact.Fragment, { key: sectionConfig.key }, sectionConfig.outerContent));
             }
-            return (common.createElement("tr", { key: sectionConfig.key, role: "presentation", className: common.getSectionClassNames(sectionConfig, this.props.liquid).join(' ') }, sectionConfig.chunks.map((chunkConfig, i) => this.renderChunk(sectionConfig, sectionIndex, colGroupStats[i], microColGroupNodes[i], chunkConfig, i, (sectionRowMaxHeights[sectionIndex] || [])[i] || [], isHeader))));
+            return (preact.createElement("tr", { key: sectionConfig.key, role: "presentation", className: internal$1.getSectionClassNames(sectionConfig, this.props.liquid).join(' ') }, sectionConfig.chunks.map((chunkConfig, i) => this.renderChunk(sectionConfig, sectionIndex, colGroupStats[i], microColGroupNodes[i], chunkConfig, i, (sectionRowMaxHeights[sectionIndex] || [])[i] || [], isHeader))));
         }
         renderChunk(sectionConfig, sectionIndex, colGroupStat, microColGroupNode, chunkConfig, chunkIndex, rowHeights, isHeader) {
             if ('outerContent' in chunkConfig) {
-                return (common.createElement(common.Fragment, { key: chunkConfig.key }, chunkConfig.outerContent));
+                return (preact.createElement(preact.Fragment, { key: chunkConfig.key }, chunkConfig.outerContent));
             }
             let { state } = this;
             let { scrollerClientWidths, scrollerClientHeights } = state;
             let [sectionCnt, chunksPerSection] = this.getDims();
             let index = sectionIndex * chunksPerSection + chunkIndex;
-            let sideScrollIndex = (!this.context.isRtl || common.getIsRtlScrollbarOnLeft()) ? chunksPerSection - 1 : 0;
+            let sideScrollIndex = (!this.context.isRtl || internal$1.getIsRtlScrollbarOnLeft()) ? chunksPerSection - 1 : 0;
             let isVScrollSide = chunkIndex === sideScrollIndex;
             let isLastSection = sectionIndex === sectionCnt - 1;
             let forceXScrollbars = isLastSection && state.forceXScrollbars; // NOOOO can result in `null`
             let forceYScrollbars = isVScrollSide && state.forceYScrollbars; // NOOOO can result in `null`
             let allowXScrolling = colGroupStat && colGroupStat.allowXScrolling; // rename?
-            let allowYScrolling = common.getAllowYScrolling(this.props, sectionConfig); // rename? do in section func?
-            let chunkVGrow = common.getSectionHasLiquidHeight(this.props, sectionConfig); // do in section func?
+            let allowYScrolling = internal$1.getAllowYScrolling(this.props, sectionConfig); // rename? do in section func?
+            let chunkVGrow = internal$1.getSectionHasLiquidHeight(this.props, sectionConfig); // do in section func?
             let expandRows = sectionConfig.expandRows && chunkVGrow;
             let tableMinWidth = (colGroupStat && colGroupStat.totalColMinWidth) || '';
-            let content = common.renderChunkContent(sectionConfig, chunkConfig, {
+            let content = internal$1.renderChunkContent(sectionConfig, chunkConfig, {
                 tableColGroupNode: microColGroupNode,
                 tableMinWidth,
                 clientWidth: scrollerClientWidths[index] !== undefined ? scrollerClientWidths[index] : null,
@@ -612,17 +520,17 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
                     (isVScrollSide ? 'auto' : 'scroll-hidden');
             // it *could* be possible to reduce DOM wrappers by only doing a ClippedScroller when allowXScrolling or allowYScrolling,
             // but if these values were to change, the inner components would be unmounted/remounted because of the parent change.
-            content = (common.createElement(ClippedScroller, { ref: this.clippedScrollerRefs.createRef(index), scrollerElRef: this.scrollerElRefs.createRef(index), overflowX: overflowX, overflowY: overflowY, liquid: chunkVGrow, maxHeight: sectionConfig.maxHeight }, content));
-            return common.createElement(isHeader ? 'th' : 'td', {
+            content = (preact.createElement(ClippedScroller, { ref: this.clippedScrollerRefs.createRef(index), scrollerElRef: this.scrollerElRefs.createRef(index), overflowX: overflowX, overflowY: overflowY, liquid: chunkVGrow, maxHeight: sectionConfig.maxHeight }, content));
+            return preact.createElement(isHeader ? 'th' : 'td', {
                 key: chunkConfig.key,
                 ref: this.chunkElRefs.createRef(index),
                 role: 'presentation',
             }, content);
         }
         componentDidMount() {
-            this.getStickyScrolling = common.memoizeArraylike(initStickyScrolling, null, destroyStickyScrolling);
-            this.getScrollSyncersBySection = common.memoizeHashlike(initScrollSyncer.bind(this, true), null, destroyScrollSyncer);
-            this.getScrollSyncersByColumn = common.memoizeHashlike(initScrollSyncer.bind(this, false), null, destroyScrollSyncer);
+            this.getStickyScrolling = internal$1.memoizeArraylike(initStickyScrolling);
+            this.getScrollSyncersBySection = internal$1.memoizeHashlike(initScrollSyncer.bind(this, true), null, destroyScrollSyncer);
+            this.getScrollSyncersByColumn = internal$1.memoizeHashlike(initScrollSyncer.bind(this, false), null, destroyScrollSyncer);
             this.updateScrollSyncers();
             this.handleSizing(false);
             this.context.addResizeHandler(this.handleSizing);
@@ -634,13 +542,12 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         }
         componentWillUnmount() {
             this.context.removeResizeHandler(this.handleSizing);
-            this.destroyStickyScrolling();
             this.destroyScrollSyncers();
         }
         allowSizing() {
             let now = new Date();
             if (!this.lastSizingDate ||
-                now.valueOf() > this.lastSizingDate.valueOf() + common.config.SCROLLGRID_RESIZE_INTERVAL) {
+                now.valueOf() > this.lastSizingDate.valueOf() + internal$1.config.SCROLLGRID_RESIZE_INTERVAL) {
                 this.lastSizingDate = now;
                 this.recentSizingCnt = 0;
                 return true;
@@ -655,7 +562,7 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
             colGroupStats.forEach((colGroupStat, i) => {
                 if (colGroupStat.hasShrinkCol) {
                     let chunkEls = this.chunkElRefs.collect(i, cnt, chunksPerSection); // in one col
-                    shrinkWidths[i] = common.computeShrinkWidth(chunkEls);
+                    shrinkWidths[i] = internal$1.computeShrinkWidth(chunkEls);
                 }
             });
             return shrinkWidths;
@@ -676,7 +583,7 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
                         let rowHeights = [];
                         let chunkEl = this.chunkElRefs.currentMap[index];
                         if (chunkEl) {
-                            rowHeights = common.findElements(chunkEl, '.fc-scrollgrid-sync-table tr').map((rowEl) => {
+                            rowHeights = internal$1.findElements(chunkEl, '.fc-scrollgrid-sync-table tr').map((rowEl) => {
                                 let max = getRowInnerMaxHeight(rowEl);
                                 newHeightMap.set(rowEl, max);
                                 return max;
@@ -747,9 +654,9 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
             return sectionRowMaxHeights;
         }
         computeScrollerDims() {
-            let scrollbarWidth = common.getScrollbarWidths();
+            let scrollbarWidth = internal$1.getScrollbarWidths();
             let [sectionCnt, chunksPerSection] = this.getDims();
-            let sideScrollI = (!this.context.isRtl || common.getIsRtlScrollbarOnLeft()) ? chunksPerSection - 1 : 0;
+            let sideScrollI = (!this.context.isRtl || internal$1.getIsRtlScrollbarOnLeft()) ? chunksPerSection - 1 : 0;
             let lastSectionI = sectionCnt - 1;
             let currentScrollers = this.clippedScrollerRefs.currentMap;
             let scrollerEls = this.scrollerElRefs.currentMap;
@@ -794,12 +701,8 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         updateStickyScrolling() {
             let { isRtl } = this.context;
             let argsByKey = this.scrollerElRefs.getAll().map((scrollEl) => [scrollEl, isRtl]);
-            let stickyScrollings = this.getStickyScrolling(argsByKey);
-            stickyScrollings.forEach((stickyScrolling) => stickyScrolling.updateSize());
-            this.stickyScrollings = stickyScrollings;
-        }
-        destroyStickyScrolling() {
-            this.stickyScrollings.forEach(destroyStickyScrolling);
+            this.getStickyScrolling(argsByKey)
+                .forEach((stickyScrolling) => stickyScrolling.updateSize());
         }
         updateScrollSyncers() {
             let [sectionCnt, chunksPerSection] = this.getDims();
@@ -810,7 +713,7 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
             for (let sectionI = 0; sectionI < sectionCnt; sectionI += 1) {
                 let startIndex = sectionI * chunksPerSection;
                 let endIndex = startIndex + chunksPerSection;
-                scrollElsBySection[sectionI] = common.collectFromHash(scrollElMap, startIndex, endIndex, 1); // use the filtered
+                scrollElsBySection[sectionI] = internal$1.collectFromHash(scrollElMap, startIndex, endIndex, 1); // use the filtered
             }
             for (let col = 0; col < chunksPerSection; col += 1) {
                 scrollElsByColumn[col] = this.scrollerElRefs.collect(col, cnt, chunksPerSection); // DON'T use the filtered
@@ -819,8 +722,8 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
             this.scrollSyncersByColumn = this.getScrollSyncersByColumn(scrollElsByColumn);
         }
         destroyScrollSyncers() {
-            common.mapHash(this.scrollSyncersBySection, destroyScrollSyncer);
-            common.mapHash(this.scrollSyncersByColumn, destroyScrollSyncer);
+            internal$1.mapHash(this.scrollSyncersBySection, destroyScrollSyncer);
+            internal$1.mapHash(this.scrollSyncersByColumn, destroyScrollSyncer);
         }
         getChunkConfigByIndex(index) {
             let chunksPerSection = this.getDims()[1];
@@ -844,13 +747,13 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         _handleChunkEl(chunkEl, key) {
             let chunkConfig = this.getChunkConfigByIndex(parseInt(key, 10));
             if (chunkConfig) { // null if section disappeared. bad, b/c won't null-set the elRef
-                common.setRef(chunkConfig.elRef, chunkEl);
+                internal$1.setRef(chunkConfig.elRef, chunkEl);
             }
         }
         _handleScrollerEl(scrollerEl, key) {
             let chunkConfig = this.getChunkConfigByIndex(parseInt(key, 10));
             if (chunkConfig) { // null if section disappeared. bad, b/c won't null-set the elRef
-                common.setRef(chunkConfig.scrollerElRef, scrollerEl);
+                internal$1.setRef(chunkConfig.scrollerElRef, scrollerEl);
             }
         }
         getDims() {
@@ -860,9 +763,9 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         }
     }
     ScrollGrid.addStateEquality({
-        shrinkWidths: common.isArraysEqual,
-        scrollerClientWidths: common.isPropsEqual,
-        scrollerClientHeights: common.isPropsEqual,
+        shrinkWidths: internal$1.isArraysEqual,
+        scrollerClientWidths: internal$1.isPropsEqual,
+        scrollerClientHeights: internal$1.isPropsEqual,
     });
     function sumNumbers(numbers) {
         let sum = 0;
@@ -872,7 +775,7 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         return sum;
     }
     function getRowInnerMaxHeight(rowEl) {
-        let innerHeights = common.findElements(rowEl, '.fc-scrollgrid-sync-inner').map(getElHeight);
+        let innerHeights = internal$1.findElements(rowEl, '.fc-scrollgrid-sync-inner').map(getElHeight);
         if (innerHeights.length) {
             return Math.max(...innerHeights);
         }
@@ -885,17 +788,17 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         let children = colGroupStats.map((colGroupStat, i) => {
             let width = colGroupStat.width;
             if (width === 'shrink') {
-                width = colGroupStat.totalColWidth + common.sanitizeShrinkWidth(shrinkWidths[i]) + 1; // +1 for border :(
+                width = colGroupStat.totalColWidth + internal$1.sanitizeShrinkWidth(shrinkWidths[i]) + 1; // +1 for border :(
             }
             return ( // eslint-disable-next-line react/jsx-key
-            common.createElement("col", { style: { width } }));
+            preact.createElement("col", { style: { width } }));
         });
-        return common.createElement('colgroup', {}, ...children);
+        return preact.createElement('colgroup', {}, ...children);
     }
     function compileColGroupStat(colGroupConfig) {
         let totalColWidth = sumColProp(colGroupConfig.cols, 'width'); // excludes "shrink"
         let totalColMinWidth = sumColProp(colGroupConfig.cols, 'minWidth');
-        let hasShrinkCol = common.hasShrinkWidth(colGroupConfig.cols);
+        let hasShrinkCol = internal$1.hasShrinkWidth(colGroupConfig.cols);
         let allowXScrolling = colGroupConfig.width !== 'shrink' && Boolean(totalColWidth || totalColMinWidth || hasShrinkCol);
         return {
             hasShrinkCol,
@@ -917,10 +820,10 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
         return total;
     }
     const COL_GROUP_STAT_EQUALITY = {
-        cols: common.isColPropsEqual,
+        cols: internal$1.isColPropsEqual,
     };
     function isColGroupStatsEqual(stat0, stat1) {
-        return common.compareObjs(stat0, stat1, COL_GROUP_STAT_EQUALITY);
+        return internal$1.compareObjs(stat0, stat1, COL_GROUP_STAT_EQUALITY);
     }
     // for memoizers...
     function initScrollSyncer(isVertical, ...scrollEls) {
@@ -932,26 +835,26 @@ var FullCalendarScrollGrid = (function (exports, common, premiumCommonPlugin) {
     function initStickyScrolling(scrollEl, isRtl) {
         return new StickyScrolling(scrollEl, isRtl);
     }
-    function destroyStickyScrolling(stickyScrolling) {
-        stickyScrolling.destroy();
-    }
 
-    var plugin = common.createPlugin({
-        deps: [
-            premiumCommonPlugin__default['default'],
-        ],
+    var plugin = core.createPlugin({
+        name: '@fullcalendar/scrollgrid',
+        premiumReleaseDate: '2022-11-22',
+        deps: [premiumCommonPlugin__default["default"]],
         scrollGridImpl: ScrollGrid,
     });
-    common.config.SCROLLGRID_RESIZE_INTERVAL = 500;
 
-    common.globalPlugins.push(plugin);
+    var internal = {
+        __proto__: null,
+        ScrollGrid: ScrollGrid
+    };
+
+    internal$1.globalPlugins.push(plugin);
 
-    exports.ScrollGrid = ScrollGrid;
-    exports.default = plugin;
-    exports.setScrollFromLeftEdge = setScrollFromLeftEdge;
+    exports.Internal = internal;
+    exports["default"] = plugin;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
     return exports;
 
-}({}, FullCalendar, FullCalendarPremiumCommon));
+})({}, FullCalendar.Internal, FullCalendar, FullCalendar.PremiumCommon, FullCalendar.Preact);