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

package/{main.cjs.js → internal.cjs}

@@ -1,109 +1,14 @@
-/*!
-FullCalendar Scheduler v6.0.0-beta.1
-Docs & License: https://fullcalendar.io/scheduler
-(c) 2022 Adam Shaw
-*/
 'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var common = require('@fullcalendar/common');
-var premiumCommonPlugin = require('@fullcalendar/premium-common');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? 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 internal_cjs = require('@fullcalendar/core/internal.cjs');
+var preact_cjs = require('@fullcalendar/core/preact.cjs');
 
 // 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_cjs.computeEdges(scrollEl); // TODO: pass in isRtl?
     return {
         left: rect.left + edges.borderLeft + edges.scrollbarLeft - getScrollFromLeftEdge(scrollEl),
         top: rect.top + edges.borderTop - scrollEl.scrollTop,
@@ -166,16 +71,13 @@ function detectRtlScrollSystem() {
             system = 'negative'; // scroll is a negative number from the right edge
         }
     }
-    common.removeElement(el);
+    internal_cjs.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.
@@ -186,41 +88,20 @@ class StickyScrolling {
     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_cjs.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_cjs.translateRect(internal_cjs.computeInnerRect(el.parentNode, true, true), // weird way to call this!!!
             -canvasOrigin.left, -canvasOrigin.top);
             let elRect = el.getBoundingClientRect();
             let computedStyles = window.getComputedStyle(el);
@@ -233,7 +114,7 @@ class StickyScrolling {
                 textAlign = isRtl ? 'left' : 'right';
             }
             if (computedStyles.position !== 'sticky') {
-                naturalBound = common.translateRect(elRect, -canvasOrigin.left - (parseFloat(computedStyles.left) || 0), // could be 'auto'
+                naturalBound = internal_cjs.translateRect(elRect, -canvasOrigin.left - (parseFloat(computedStyles.left) || 0), // could be 'auto'
                 -canvasOrigin.top - (parseFloat(computedStyles.top) || 0));
             }
             elGeoms.push({
@@ -246,59 +127,6 @@ class StickyScrolling {
         }
         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) => {
@@ -312,40 +140,25 @@ function assignStickyPositions(els, elGeoms, viewportWidth) {
         else { // if parent container can be completely in view, we don't need stickiness
             left = '';
         }
-        common.applyStyle(el, {
+        internal_cjs.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_cjs.BaseComponent {
     constructor() {
         super(...arguments);
-        this.elRef = common.createRef();
+        this.elRef = preact_cjs.createRef();
         this.state = {
             xScrollbarWidth: 0,
             yScrollbarWidth: 0,
         };
         this.handleScroller = (scroller) => {
             this.scroller = scroller;
-            common.setRef(this.props.scrollerRef, scroller);
+            internal_cjs.setRef(this.props.scrollerRef, scroller);
         };
         this.handleSizing = () => {
             let { props } = this;
@@ -359,7 +172,7 @@ class ClippedScroller extends common.BaseComponent {
     }
     render() {
         let { props, state, context } = this;
-        let isScrollbarOnLeft = context.isRtl && common.getIsRtlScrollbarOnLeft();
+        let isScrollbarOnLeft = context.isRtl && internal_cjs.getIsRtlScrollbarOnLeft();
         let overcomeLeft = 0;
         let overcomeRight = 0;
         let overcomeBottom = 0;
@@ -376,8 +189,8 @@ class ClippedScroller extends common.BaseComponent {
                 }
             }
         }
-        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_cjs.createElement("div", { ref: this.elRef, className: 'fc-scroller-harness' + (props.liquid ? ' fc-scroller-harness-liquid' : '') },
+            preact_cjs.createElement(internal_cjs.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)));
     }
@@ -386,7 +199,7 @@ class ClippedScroller extends common.BaseComponent {
         this.context.addResizeHandler(this.handleSizing);
     }
     componentDidUpdate(prevProps) {
-        if (!common.isPropsEqual(prevProps, this.props)) { // an external change?
+        if (!internal_cjs.isPropsEqual(prevProps, this.props)) { // an external change?
             this.handleSizing();
         }
     }
@@ -401,6 +214,92 @@ class ClippedScroller extends common.BaseComponent {
     }
 }
 
+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_cjs.Emitter();
+        this.isScrolling = false;
+        this.isTouching = false; // user currently has finger down?
+        this.isRecentlyWheeled = false;
+        this.isRecentlyScrolled = false;
+        this.wheelWaiter = new internal_cjs.DelayedRunner(this._handleWheelWaited.bind(this));
+        this.scrollWaiter = new internal_cjs.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;
@@ -471,20 +370,20 @@ class ScrollSyncer {
     }
 }
 
+internal_cjs.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_cjs.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_cjs.memoizeArraylike(compileColGroupStat, isColGroupStatsEqual);
+        this.renderMicroColGroups = internal_cjs.memoizeArraylike(internal_cjs.renderMicroColGroup); // yucky to memoize VNodes, but much more efficient for consumers
+        this.clippedScrollerRefs = new internal_cjs.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_cjs.RefMap(this._handleScrollerEl.bind(this));
+        this.chunkElRefs = new internal_cjs.RefMap(this._handleChunkEl.bind(this));
         this.scrollSyncersBySection = {};
         this.scrollSyncersByColumn = {};
         // for row-height-syncing
@@ -544,7 +443,7 @@ class ScrollGrid extends common.BaseComponent {
         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_cjs.getScrollGridClassNames(props.liquid, context);
         this.getDims();
         // TODO: make DRY
         let sectionConfigs = props.sections;
@@ -566,39 +465,39 @@ class ScrollGrid extends common.BaseComponent {
             footSectionNodes.push(this.renderSection(currentConfig, configI, colGroupStats, microColGroupNodes, state.sectionRowMaxHeights, true));
             configI += 1;
         }
-        const isBuggy = !common.getCanVGrowWithinCell(); // see NOTE in SimpleScrollGrid
+        const isBuggy = !internal_cjs.getCanVGrowWithinCell(); // see NOTE in SimpleScrollGrid
         const roleAttrs = { role: 'rowgroup' };
-        return common.createElement('table', {
+        return preact_cjs.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_cjs.createElement('thead', roleAttrs, ...headSectionNodes), Boolean(!isBuggy && bodySectionNodes.length) && preact_cjs.createElement('tbody', roleAttrs, ...bodySectionNodes), Boolean(!isBuggy && footSectionNodes.length) && preact_cjs.createElement('tfoot', roleAttrs, ...footSectionNodes), isBuggy && preact_cjs.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_cjs.createElement(preact_cjs.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_cjs.createElement("tr", { key: sectionConfig.key, role: "presentation", className: internal_cjs.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_cjs.createElement(preact_cjs.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_cjs.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_cjs.getAllowYScrolling(this.props, sectionConfig); // rename? do in section func?
+        let chunkVGrow = internal_cjs.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_cjs.renderChunkContent(sectionConfig, chunkConfig, {
             tableColGroupNode: microColGroupNode,
             tableMinWidth,
             clientWidth: scrollerClientWidths[index] !== undefined ? scrollerClientWidths[index] : null,
@@ -616,17 +515,17 @@ class ScrollGrid extends common.BaseComponent {
                 (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_cjs.createElement(ClippedScroller, { ref: this.clippedScrollerRefs.createRef(index), scrollerElRef: this.scrollerElRefs.createRef(index), overflowX: overflowX, overflowY: overflowY, liquid: chunkVGrow, maxHeight: sectionConfig.maxHeight }, content));
+        return preact_cjs.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_cjs.memoizeArraylike(initStickyScrolling);
+        this.getScrollSyncersBySection = internal_cjs.memoizeHashlike(initScrollSyncer.bind(this, true), null, destroyScrollSyncer);
+        this.getScrollSyncersByColumn = internal_cjs.memoizeHashlike(initScrollSyncer.bind(this, false), null, destroyScrollSyncer);
         this.updateScrollSyncers();
         this.handleSizing(false);
         this.context.addResizeHandler(this.handleSizing);
@@ -638,13 +537,12 @@ class ScrollGrid extends common.BaseComponent {
     }
     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_cjs.config.SCROLLGRID_RESIZE_INTERVAL) {
             this.lastSizingDate = now;
             this.recentSizingCnt = 0;
             return true;
@@ -659,7 +557,7 @@ class ScrollGrid extends common.BaseComponent {
         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_cjs.computeShrinkWidth(chunkEls);
             }
         });
         return shrinkWidths;
@@ -680,7 +578,7 @@ class ScrollGrid extends common.BaseComponent {
                     let rowHeights = [];
                     let chunkEl = this.chunkElRefs.currentMap[index];
                     if (chunkEl) {
-                        rowHeights = common.findElements(chunkEl, '.fc-scrollgrid-sync-table tr').map((rowEl) => {
+                        rowHeights = internal_cjs.findElements(chunkEl, '.fc-scrollgrid-sync-table tr').map((rowEl) => {
                             let max = getRowInnerMaxHeight(rowEl);
                             newHeightMap.set(rowEl, max);
                             return max;
@@ -751,9 +649,9 @@ class ScrollGrid extends common.BaseComponent {
         return sectionRowMaxHeights;
     }
     computeScrollerDims() {
-        let scrollbarWidth = common.getScrollbarWidths();
+        let scrollbarWidth = internal_cjs.getScrollbarWidths();
         let [sectionCnt, chunksPerSection] = this.getDims();
-        let sideScrollI = (!this.context.isRtl || common.getIsRtlScrollbarOnLeft()) ? chunksPerSection - 1 : 0;
+        let sideScrollI = (!this.context.isRtl || internal_cjs.getIsRtlScrollbarOnLeft()) ? chunksPerSection - 1 : 0;
         let lastSectionI = sectionCnt - 1;
         let currentScrollers = this.clippedScrollerRefs.currentMap;
         let scrollerEls = this.scrollerElRefs.currentMap;
@@ -798,12 +696,8 @@ class ScrollGrid extends common.BaseComponent {
     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();
@@ -814,7 +708,7 @@ class ScrollGrid extends common.BaseComponent {
         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_cjs.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
@@ -823,8 +717,8 @@ class ScrollGrid extends common.BaseComponent {
         this.scrollSyncersByColumn = this.getScrollSyncersByColumn(scrollElsByColumn);
     }
     destroyScrollSyncers() {
-        common.mapHash(this.scrollSyncersBySection, destroyScrollSyncer);
-        common.mapHash(this.scrollSyncersByColumn, destroyScrollSyncer);
+        internal_cjs.mapHash(this.scrollSyncersBySection, destroyScrollSyncer);
+        internal_cjs.mapHash(this.scrollSyncersByColumn, destroyScrollSyncer);
     }
     getChunkConfigByIndex(index) {
         let chunksPerSection = this.getDims()[1];
@@ -848,13 +742,13 @@ class ScrollGrid extends common.BaseComponent {
     _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_cjs.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_cjs.setRef(chunkConfig.scrollerElRef, scrollerEl);
         }
     }
     getDims() {
@@ -864,9 +758,9 @@ class ScrollGrid extends common.BaseComponent {
     }
 }
 ScrollGrid.addStateEquality({
-    shrinkWidths: common.isArraysEqual,
-    scrollerClientWidths: common.isPropsEqual,
-    scrollerClientHeights: common.isPropsEqual,
+    shrinkWidths: internal_cjs.isArraysEqual,
+    scrollerClientWidths: internal_cjs.isPropsEqual,
+    scrollerClientHeights: internal_cjs.isPropsEqual,
 });
 function sumNumbers(numbers) {
     let sum = 0;
@@ -876,7 +770,7 @@ function sumNumbers(numbers) {
     return sum;
 }
 function getRowInnerMaxHeight(rowEl) {
-    let innerHeights = common.findElements(rowEl, '.fc-scrollgrid-sync-inner').map(getElHeight);
+    let innerHeights = internal_cjs.findElements(rowEl, '.fc-scrollgrid-sync-inner').map(getElHeight);
     if (innerHeights.length) {
         return Math.max(...innerHeights);
     }
@@ -889,17 +783,17 @@ function renderMacroColGroup(colGroupStats, shrinkWidths) {
     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_cjs.sanitizeShrinkWidth(shrinkWidths[i]) + 1; // +1 for border :(
         }
         return ( // eslint-disable-next-line react/jsx-key
-        common.createElement("col", { style: { width } }));
+        preact_cjs.createElement("col", { style: { width } }));
     });
-    return common.createElement('colgroup', {}, ...children);
+    return preact_cjs.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_cjs.hasShrinkWidth(colGroupConfig.cols);
     let allowXScrolling = colGroupConfig.width !== 'shrink' && Boolean(totalColWidth || totalColMinWidth || hasShrinkCol);
     return {
         hasShrinkCol,
@@ -921,10 +815,10 @@ function sumColProp(cols, propName) {
     return total;
 }
 const COL_GROUP_STAT_EQUALITY = {
-    cols: common.isColPropsEqual,
+    cols: internal_cjs.isColPropsEqual,
 };
 function isColGroupStatsEqual(stat0, stat1) {
-    return common.compareObjs(stat0, stat1, COL_GROUP_STAT_EQUALITY);
+    return internal_cjs.compareObjs(stat0, stat1, COL_GROUP_STAT_EQUALITY);
 }
 // for memoizers...
 function initScrollSyncer(isVertical, ...scrollEls) {
@@ -936,18 +830,5 @@ function destroyScrollSyncer(scrollSyncer) {
 function initStickyScrolling(scrollEl, isRtl) {
     return new StickyScrolling(scrollEl, isRtl);
 }
-function destroyStickyScrolling(stickyScrolling) {
-    stickyScrolling.destroy();
-}
-
-var main = common.createPlugin({
-    deps: [
-        premiumCommonPlugin__default['default'],
-    ],
-    scrollGridImpl: ScrollGrid,
-});
-common.config.SCROLLGRID_RESIZE_INTERVAL = 500;
 
 exports.ScrollGrid = ScrollGrid;
-exports.default = main;
-exports.setScrollFromLeftEdge = setScrollFromLeftEdge;