serves as a min-height
+ },
+ }, arg.tableColGroupNode, createElement(isHeader ? 'thead' : 'tbody', {
+ role: 'presentation',
+ }, typeof chunkConfig.rowContent === 'function'
+ ? chunkConfig.rowContent(arg)
+ : chunkConfig.rowContent));
+ return content;
+ }
+ function isColPropsEqual(cols0, cols1) {
+ return isArraysEqual(cols0, cols1, isPropsEqual);
+ }
+ function renderMicroColGroup(cols, shrinkWidth) {
+ var colNodes = [];
+ /*
+ for ColProps with spans, it would have been great to make a single
+ HOWEVER, Chrome was getting messing up distributing the width to | / | elements with colspans.
+ SOLUTION: making individual elements makes Chrome behave.
+ */
+ for (var _i = 0, cols_1 = cols; _i < cols_1.length; _i++) {
+ var colProps = cols_1[_i];
+ var span = colProps.span || 1;
+ for (var i = 0; i < span; i += 1) {
+ colNodes.push(createElement("col", { style: {
+ width: colProps.width === 'shrink' ? sanitizeShrinkWidth(shrinkWidth) : (colProps.width || ''),
+ minWidth: colProps.minWidth || '',
+ } }));
+ }
+ }
+ return createElement.apply(void 0, __spreadArray(['colgroup', {}], colNodes));
+ }
+ function sanitizeShrinkWidth(shrinkWidth) {
+ /* why 4? if we do 0, it will kill any border, which are needed for computeSmallestCellWidth
+ 4 accounts for 2 2-pixel borders. TODO: better solution? */
+ return shrinkWidth == null ? 4 : shrinkWidth;
+ }
+ function hasShrinkWidth(cols) {
+ for (var _i = 0, cols_2 = cols; _i < cols_2.length; _i++) {
+ var col = cols_2[_i];
+ if (col.width === 'shrink') {
+ return true;
+ }
+ }
+ return false;
+ }
+ function getScrollGridClassNames(liquid, context) {
+ var classNames = [
+ 'fc-scrollgrid',
+ context.theme.getClass('table'),
+ ];
+ if (liquid) {
+ classNames.push('fc-scrollgrid-liquid');
+ }
+ return classNames;
+ }
+ function getSectionClassNames(sectionConfig, wholeTableVGrow) {
+ var classNames = [
+ 'fc-scrollgrid-section',
+ "fc-scrollgrid-section-" + sectionConfig.type,
+ sectionConfig.className, // used?
+ ];
+ if (wholeTableVGrow && sectionConfig.liquid && sectionConfig.maxHeight == null) {
+ classNames.push('fc-scrollgrid-section-liquid');
+ }
+ if (sectionConfig.isSticky) {
+ classNames.push('fc-scrollgrid-section-sticky');
+ }
+ return classNames;
+ }
+ function renderScrollShim(arg) {
+ return (createElement("div", { className: "fc-scrollgrid-sticky-shim", style: {
+ width: arg.clientWidth,
+ minWidth: arg.tableMinWidth,
+ } }));
+ }
+ function getStickyHeaderDates(options) {
+ var stickyHeaderDates = options.stickyHeaderDates;
+ if (stickyHeaderDates == null || stickyHeaderDates === 'auto') {
+ stickyHeaderDates = options.height === 'auto' || options.viewHeight === 'auto';
+ }
+ return stickyHeaderDates;
+ }
+ function getStickyFooterScrollbar(options) {
+ var stickyFooterScrollbar = options.stickyFooterScrollbar;
+ if (stickyFooterScrollbar == null || stickyFooterScrollbar === 'auto') {
+ stickyFooterScrollbar = options.height === 'auto' || options.viewHeight === 'auto';
+ }
+ return stickyFooterScrollbar;
+ }
+
+ var SimpleScrollGrid = /** @class */ (function (_super) {
+ __extends(SimpleScrollGrid, _super);
+ function SimpleScrollGrid() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.processCols = memoize(function (a) { return a; }, isColPropsEqual); // so we get same `cols` props every time
+ // yucky to memoize VNodes, but much more efficient for consumers
+ _this.renderMicroColGroup = memoize(renderMicroColGroup);
+ _this.scrollerRefs = new RefMap();
+ _this.scrollerElRefs = new RefMap(_this._handleScrollerEl.bind(_this));
+ _this.state = {
+ shrinkWidth: null,
+ forceYScrollbars: false,
+ scrollerClientWidths: {},
+ scrollerClientHeights: {},
+ };
+ // TODO: can do a really simple print-view. dont need to join rows
+ _this.handleSizing = function () {
+ _this.setState(__assign({ shrinkWidth: _this.computeShrinkWidth() }, _this.computeScrollerDims()));
+ };
+ return _this;
+ }
+ SimpleScrollGrid.prototype.render = function () {
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ var sectionConfigs = props.sections || [];
+ var cols = this.processCols(props.cols);
+ var microColGroupNode = this.renderMicroColGroup(cols, state.shrinkWidth);
+ var classNames = getScrollGridClassNames(props.liquid, context);
+ if (props.collapsibleWidth) {
+ classNames.push('fc-scrollgrid-collapsible');
+ }
+ // TODO: make DRY
+ var configCnt = sectionConfigs.length;
+ var configI = 0;
+ var currentConfig;
+ var headSectionNodes = [];
+ var bodySectionNodes = [];
+ var footSectionNodes = [];
+ while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'header') {
+ headSectionNodes.push(this.renderSection(currentConfig, microColGroupNode, true));
+ configI += 1;
+ }
+ while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'body') {
+ bodySectionNodes.push(this.renderSection(currentConfig, microColGroupNode, false));
+ configI += 1;
+ }
+ while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'footer') {
+ footSectionNodes.push(this.renderSection(currentConfig, microColGroupNode, true));
+ configI += 1;
+ }
+ // firefox bug: when setting height on table and there is a thead or tfoot,
+ // the necessary height:100% on the liquid-height body section forces the *whole* table to be taller. (bug #5524)
+ // use getCanVGrowWithinCell as a way to detect table-stupid firefox.
+ // if so, use a simpler dom structure, jam everything into a lone tbody.
+ var isBuggy = !getCanVGrowWithinCell();
+ var roleAttrs = { role: 'rowgroup' };
+ return createElement('table', {
+ role: 'grid',
+ className: classNames.join(' '),
+ style: { height: props.height },
+ }, Boolean(!isBuggy && headSectionNodes.length) && createElement.apply(void 0, __spreadArray(['thead', roleAttrs], headSectionNodes)), Boolean(!isBuggy && bodySectionNodes.length) && createElement.apply(void 0, __spreadArray(['tbody', roleAttrs], bodySectionNodes)), Boolean(!isBuggy && footSectionNodes.length) && createElement.apply(void 0, __spreadArray(['tfoot', roleAttrs], footSectionNodes)), isBuggy && createElement.apply(void 0, __spreadArray(__spreadArray(__spreadArray(['tbody', roleAttrs], headSectionNodes), bodySectionNodes), footSectionNodes)));
+ };
+ SimpleScrollGrid.prototype.renderSection = function (sectionConfig, microColGroupNode, isHeader) {
+ if ('outerContent' in sectionConfig) {
+ return (createElement(Fragment, { key: sectionConfig.key }, sectionConfig.outerContent));
+ }
+ return (createElement("tr", { key: sectionConfig.key, role: "presentation", className: getSectionClassNames(sectionConfig, this.props.liquid).join(' ') }, this.renderChunkTd(sectionConfig, microColGroupNode, sectionConfig.chunk, isHeader)));
+ };
+ SimpleScrollGrid.prototype.renderChunkTd = function (sectionConfig, microColGroupNode, chunkConfig, isHeader) {
+ if ('outerContent' in chunkConfig) {
+ return chunkConfig.outerContent;
+ }
+ var props = this.props;
+ var _a = this.state, forceYScrollbars = _a.forceYScrollbars, scrollerClientWidths = _a.scrollerClientWidths, scrollerClientHeights = _a.scrollerClientHeights;
+ var needsYScrolling = getAllowYScrolling(props, sectionConfig); // TODO: do lazily. do in section config?
+ var isLiquid = getSectionHasLiquidHeight(props, sectionConfig);
+ // for `!props.liquid` - is WHOLE scrollgrid natural height?
+ // TODO: do same thing in advanced scrollgrid? prolly not b/c always has horizontal scrollbars
+ var overflowY = !props.liquid ? 'visible' :
+ forceYScrollbars ? 'scroll' :
+ !needsYScrolling ? 'hidden' :
+ 'auto';
+ var sectionKey = sectionConfig.key;
+ var content = renderChunkContent(sectionConfig, chunkConfig, {
+ tableColGroupNode: microColGroupNode,
+ tableMinWidth: '',
+ clientWidth: (!props.collapsibleWidth && scrollerClientWidths[sectionKey] !== undefined) ? scrollerClientWidths[sectionKey] : null,
+ clientHeight: scrollerClientHeights[sectionKey] !== undefined ? scrollerClientHeights[sectionKey] : null,
+ expandRows: sectionConfig.expandRows,
+ syncRowHeights: false,
+ rowSyncHeights: [],
+ reportRowHeightChange: function () { },
+ }, isHeader);
+ return createElement(isHeader ? 'th' : 'td', {
+ ref: chunkConfig.elRef,
+ role: 'presentation',
+ }, createElement("div", { className: "fc-scroller-harness" + (isLiquid ? ' fc-scroller-harness-liquid' : '') },
+ createElement(Scroller, { ref: this.scrollerRefs.createRef(sectionKey), elRef: this.scrollerElRefs.createRef(sectionKey), overflowY: overflowY, overflowX: !props.liquid ? 'visible' : 'hidden' /* natural height? */, maxHeight: sectionConfig.maxHeight, liquid: isLiquid, liquidIsAbsolute // because its within a harness
+ : true }, content)));
+ };
+ SimpleScrollGrid.prototype._handleScrollerEl = function (scrollerEl, key) {
+ var section = getSectionByKey(this.props.sections, key);
+ if (section) {
+ setRef(section.chunk.scrollerElRef, scrollerEl);
+ }
+ };
+ SimpleScrollGrid.prototype.componentDidMount = function () {
+ this.handleSizing();
+ this.context.addResizeHandler(this.handleSizing);
+ };
+ SimpleScrollGrid.prototype.componentDidUpdate = function () {
+ // TODO: need better solution when state contains non-sizing things
+ this.handleSizing();
+ };
+ SimpleScrollGrid.prototype.componentWillUnmount = function () {
+ this.context.removeResizeHandler(this.handleSizing);
+ };
+ SimpleScrollGrid.prototype.computeShrinkWidth = function () {
+ return hasShrinkWidth(this.props.cols)
+ ? computeShrinkWidth(this.scrollerElRefs.getAll())
+ : 0;
+ };
+ SimpleScrollGrid.prototype.computeScrollerDims = function () {
+ var scrollbarWidth = getScrollbarWidths();
+ var _a = this, scrollerRefs = _a.scrollerRefs, scrollerElRefs = _a.scrollerElRefs;
+ var forceYScrollbars = false;
+ var scrollerClientWidths = {};
+ var scrollerClientHeights = {};
+ for (var sectionKey in scrollerRefs.currentMap) {
+ var scroller = scrollerRefs.currentMap[sectionKey];
+ if (scroller && scroller.needsYScrolling()) {
+ forceYScrollbars = true;
+ break;
+ }
+ }
+ for (var _i = 0, _b = this.props.sections; _i < _b.length; _i++) {
+ var section = _b[_i];
+ var sectionKey = section.key;
+ var scrollerEl = scrollerElRefs.currentMap[sectionKey];
+ if (scrollerEl) {
+ var harnessEl = scrollerEl.parentNode; // TODO: weird way to get this. need harness b/c doesn't include table borders
+ scrollerClientWidths[sectionKey] = Math.floor(harnessEl.getBoundingClientRect().width - (forceYScrollbars
+ ? scrollbarWidth.y // use global because scroller might not have scrollbars yet but will need them in future
+ : 0));
+ scrollerClientHeights[sectionKey] = Math.floor(harnessEl.getBoundingClientRect().height);
+ }
+ }
+ return { forceYScrollbars: forceYScrollbars, scrollerClientWidths: scrollerClientWidths, scrollerClientHeights: scrollerClientHeights };
+ };
+ return SimpleScrollGrid;
+ }(BaseComponent));
+ SimpleScrollGrid.addStateEquality({
+ scrollerClientWidths: isPropsEqual,
+ scrollerClientHeights: isPropsEqual,
+ });
+ function getSectionByKey(sections, key) {
+ for (var _i = 0, sections_1 = sections; _i < sections_1.length; _i++) {
+ var section = sections_1[_i];
+ if (section.key === key) {
+ return section;
+ }
+ }
+ return null;
+ }
+
+ var EventRoot = /** @class */ (function (_super) {
+ __extends(EventRoot, _super);
+ function EventRoot() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.elRef = createRef();
+ return _this;
+ }
+ EventRoot.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var options = context.options;
+ var seg = props.seg;
+ var eventRange = seg.eventRange;
+ var ui = eventRange.ui;
+ var hookProps = {
+ event: new EventApi(context, eventRange.def, eventRange.instance),
+ view: context.viewApi,
+ timeText: props.timeText,
+ 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),
+ isMirror: Boolean(props.isDragging || props.isResizing || props.isDateSelecting),
+ isStart: Boolean(seg.isStart),
+ isEnd: Boolean(seg.isEnd),
+ isPast: Boolean(props.isPast),
+ isFuture: Boolean(props.isFuture),
+ isToday: Boolean(props.isToday),
+ isSelected: Boolean(props.isSelected),
+ isDragging: Boolean(props.isDragging),
+ isResizing: Boolean(props.isResizing),
+ };
+ var standardClassNames = getEventClassNames(hookProps).concat(ui.classNames);
+ return (createElement(RenderHook, { hookProps: hookProps, classNames: options.eventClassNames, content: options.eventContent, defaultContent: props.defaultContent, didMount: options.eventDidMount, willUnmount: options.eventWillUnmount, elRef: this.elRef }, function (rootElRef, customClassNames, innerElRef, innerContent) { return props.children(rootElRef, standardClassNames.concat(customClassNames), innerElRef, innerContent, hookProps); }));
+ };
+ EventRoot.prototype.componentDidMount = function () {
+ setElSeg(this.elRef.current, this.props.seg);
+ };
+ /*
+ need to re-assign seg to the element if seg changes, even if the element is the same
+ */
+ EventRoot.prototype.componentDidUpdate = function (prevProps) {
+ var seg = this.props.seg;
+ if (seg !== prevProps.seg) {
+ setElSeg(this.elRef.current, seg);
+ }
+ };
+ return EventRoot;
+ }(BaseComponent));
+
+ // should not be a purecomponent
+ var StandardEvent = /** @class */ (function (_super) {
+ __extends(StandardEvent, _super);
+ function StandardEvent() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ StandardEvent.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var seg = props.seg;
+ var timeFormat = context.options.eventTimeFormat || props.defaultTimeFormat;
+ var timeText = buildSegTimeText(seg, timeFormat, context, props.defaultDisplayEventTime, props.defaultDisplayEventEnd);
+ return (createElement(EventRoot, { seg: seg, timeText: timeText, disableDragging: props.disableDragging, disableResizing: props.disableResizing, defaultContent: props.defaultContent || renderInnerContent$6, isDragging: props.isDragging, isResizing: props.isResizing, isDateSelecting: props.isDateSelecting, isSelected: props.isSelected, isPast: props.isPast, isFuture: props.isFuture, isToday: props.isToday }, function (rootElRef, classNames, innerElRef, innerContent, hookProps) { return (createElement("a", __assign({ className: props.extraClassNames.concat(classNames).join(' '), style: {
+ borderColor: hookProps.borderColor,
+ backgroundColor: hookProps.backgroundColor,
+ }, ref: rootElRef }, getSegAnchorAttrs(seg, context)),
+ createElement("div", { className: "fc-event-main", ref: innerElRef, style: { color: hookProps.textColor } }, innerContent),
+ hookProps.isStartResizable &&
+ createElement("div", { className: "fc-event-resizer fc-event-resizer-start" }),
+ hookProps.isEndResizable &&
+ createElement("div", { className: "fc-event-resizer fc-event-resizer-end" }))); }));
+ };
+ return StandardEvent;
+ }(BaseComponent));
+ function renderInnerContent$6(innerProps) {
+ return (createElement("div", { className: "fc-event-main-frame" },
+ innerProps.timeText && (createElement("div", { className: "fc-event-time" }, innerProps.timeText)),
+ createElement("div", { className: "fc-event-title-container" },
+ createElement("div", { className: "fc-event-title fc-sticky" }, innerProps.event.title || createElement(Fragment, null, "\u00A0")))));
+ }
+
+ var NowIndicatorRoot = function (props) { return (createElement(ViewContextType.Consumer, null, function (context) {
+ var options = context.options;
+ var hookProps = {
+ isAxis: props.isAxis,
+ date: context.dateEnv.toDate(props.date),
+ view: context.viewApi,
+ };
+ return (createElement(RenderHook, { hookProps: hookProps, classNames: options.nowIndicatorClassNames, content: options.nowIndicatorContent, didMount: options.nowIndicatorDidMount, willUnmount: options.nowIndicatorWillUnmount }, props.children));
+ })); };
+
+ var DAY_NUM_FORMAT = createFormatter({ day: 'numeric' });
+ var DayCellContent = /** @class */ (function (_super) {
+ __extends(DayCellContent, _super);
+ function DayCellContent() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ DayCellContent.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var options = context.options;
+ var hookProps = refineDayCellHookProps({
+ date: props.date,
+ dateProfile: props.dateProfile,
+ todayRange: props.todayRange,
+ showDayNumber: props.showDayNumber,
+ extraProps: props.extraHookProps,
+ viewApi: context.viewApi,
+ dateEnv: context.dateEnv,
+ });
+ return (createElement(ContentHook, { hookProps: hookProps, content: options.dayCellContent, defaultContent: props.defaultContent }, props.children));
+ };
+ return DayCellContent;
+ }(BaseComponent));
+ function refineDayCellHookProps(raw) {
+ var date = raw.date, dateEnv = raw.dateEnv;
+ var dayMeta = getDateMeta(date, raw.todayRange, null, raw.dateProfile);
+ return __assign(__assign(__assign({ date: dateEnv.toDate(date), view: raw.viewApi }, dayMeta), { dayNumberText: raw.showDayNumber ? dateEnv.format(date, DAY_NUM_FORMAT) : '' }), raw.extraProps);
+ }
+
+ var DayCellRoot = /** @class */ (function (_super) {
+ __extends(DayCellRoot, _super);
+ function DayCellRoot() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.refineHookProps = memoizeObjArg(refineDayCellHookProps);
+ _this.normalizeClassNames = buildClassNameNormalizer();
+ return _this;
+ }
+ DayCellRoot.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var options = context.options;
+ var hookProps = this.refineHookProps({
+ date: props.date,
+ dateProfile: props.dateProfile,
+ todayRange: props.todayRange,
+ showDayNumber: props.showDayNumber,
+ extraProps: props.extraHookProps,
+ viewApi: context.viewApi,
+ dateEnv: context.dateEnv,
+ });
+ var classNames = getDayClassNames(hookProps, context.theme).concat(hookProps.isDisabled
+ ? [] // don't use custom classNames if disabled
+ : this.normalizeClassNames(options.dayCellClassNames, hookProps));
+ var dataAttrs = hookProps.isDisabled ? {} : {
+ 'data-date': formatDayString(props.date),
+ };
+ return (createElement(MountHook, { hookProps: hookProps, didMount: options.dayCellDidMount, willUnmount: options.dayCellWillUnmount, elRef: props.elRef }, function (rootElRef) { return props.children(rootElRef, classNames, dataAttrs, hookProps.isDisabled); }));
+ };
+ return DayCellRoot;
+ }(BaseComponent));
+
+ function renderFill(fillType) {
+ return (createElement("div", { className: "fc-" + fillType }));
+ }
+ var BgEvent = function (props) { return (createElement(EventRoot, { defaultContent: renderInnerContent$5, seg: props.seg /* uselesss i think */, timeText: "", disableDragging: true, disableResizing: true, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, isPast: props.isPast, isFuture: props.isFuture, isToday: props.isToday }, function (rootElRef, classNames, innerElRef, innerContent, hookProps) { return (createElement("div", { ref: rootElRef, className: ['fc-bg-event'].concat(classNames).join(' '), style: {
+ backgroundColor: hookProps.backgroundColor,
+ } }, innerContent)); })); };
+ function renderInnerContent$5(props) {
+ var title = props.event.title;
+ return title && (createElement("div", { className: "fc-event-title" }, props.event.title));
+ }
+
+ var WeekNumberRoot = function (props) { return (createElement(ViewContextType.Consumer, null, function (context) {
+ var dateEnv = context.dateEnv, options = context.options;
+ var date = props.date;
+ var format = options.weekNumberFormat || props.defaultFormat;
+ var num = dateEnv.computeWeekNumber(date); // TODO: somehow use for formatting as well?
+ var text = dateEnv.format(date, format);
+ var hookProps = { num: num, text: text, date: date };
+ return (createElement(RenderHook, { hookProps: hookProps, classNames: options.weekNumberClassNames, content: options.weekNumberContent, defaultContent: renderInner, didMount: options.weekNumberDidMount, willUnmount: options.weekNumberWillUnmount }, props.children));
+ })); };
+ function renderInner(innerProps) {
+ return innerProps.text;
+ }
+
+ var PADDING_FROM_VIEWPORT = 10;
+ var Popover = /** @class */ (function (_super) {
+ __extends(Popover, _super);
+ function Popover() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.state = {
+ titleId: getUniqueDomId(),
+ };
+ _this.handleRootEl = function (el) {
+ _this.rootEl = el;
+ if (_this.props.elRef) {
+ setRef(_this.props.elRef, el);
+ }
+ };
+ // Triggered when the user clicks *anywhere* in the document, for the autoHide feature
+ _this.handleDocumentMouseDown = function (ev) {
+ // only hide the popover if the click happened outside the popover
+ var target = getEventTargetViaRoot(ev);
+ if (!_this.rootEl.contains(target)) {
+ _this.handleCloseClick();
+ }
+ };
+ _this.handleDocumentKeyDown = function (ev) {
+ if (ev.key === 'Escape') {
+ _this.handleCloseClick();
+ }
+ };
+ _this.handleCloseClick = function () {
+ var onClose = _this.props.onClose;
+ if (onClose) {
+ onClose();
+ }
+ };
+ return _this;
+ }
+ Popover.prototype.render = function () {
+ var _a = this.context, theme = _a.theme, options = _a.options;
+ var _b = this, props = _b.props, state = _b.state;
+ var classNames = [
+ 'fc-popover',
+ theme.getClass('popover'),
+ ].concat(props.extraClassNames || []);
+ return createPortal(createElement("div", __assign({ id: props.id, className: classNames.join(' '), "aria-labelledby": state.titleId }, props.extraAttrs, { ref: this.handleRootEl }),
+ createElement("div", { className: 'fc-popover-header ' + theme.getClass('popoverHeader') },
+ createElement("span", { className: "fc-popover-title", id: state.titleId }, props.title),
+ createElement("span", { className: 'fc-popover-close ' + theme.getIconClass('close'), title: options.closeHint, onClick: this.handleCloseClick })),
+ createElement("div", { className: 'fc-popover-body ' + theme.getClass('popoverContent') }, props.children)), props.parentEl);
+ };
+ Popover.prototype.componentDidMount = function () {
+ document.addEventListener('mousedown', this.handleDocumentMouseDown);
+ document.addEventListener('keydown', this.handleDocumentKeyDown);
+ this.updateSize();
+ };
+ Popover.prototype.componentWillUnmount = function () {
+ document.removeEventListener('mousedown', this.handleDocumentMouseDown);
+ document.removeEventListener('keydown', this.handleDocumentKeyDown);
+ };
+ Popover.prototype.updateSize = function () {
+ var isRtl = this.context.isRtl;
+ var _a = this.props, alignmentEl = _a.alignmentEl, alignGridTop = _a.alignGridTop;
+ var rootEl = this.rootEl;
+ var alignmentRect = computeClippedClientRect(alignmentEl);
+ if (alignmentRect) {
+ var popoverDims = rootEl.getBoundingClientRect();
+ // position relative to viewport
+ var popoverTop = alignGridTop
+ ? elementClosest(alignmentEl, '.fc-scrollgrid').getBoundingClientRect().top
+ : alignmentRect.top;
+ var popoverLeft = isRtl ? alignmentRect.right - popoverDims.width : alignmentRect.left;
+ // constrain
+ popoverTop = Math.max(popoverTop, PADDING_FROM_VIEWPORT);
+ popoverLeft = Math.min(popoverLeft, document.documentElement.clientWidth - PADDING_FROM_VIEWPORT - popoverDims.width);
+ popoverLeft = Math.max(popoverLeft, PADDING_FROM_VIEWPORT);
+ var origin_1 = rootEl.offsetParent.getBoundingClientRect();
+ applyStyle(rootEl, {
+ top: popoverTop - origin_1.top,
+ left: popoverLeft - origin_1.left,
+ });
+ }
+ };
+ return Popover;
+ }(BaseComponent));
+
+ var MorePopover = /** @class */ (function (_super) {
+ __extends(MorePopover, _super);
+ function MorePopover() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.handleRootEl = function (rootEl) {
+ _this.rootEl = rootEl;
+ if (rootEl) {
+ _this.context.registerInteractiveComponent(_this, {
+ el: rootEl,
+ useEventCenter: false,
+ });
+ }
+ else {
+ _this.context.unregisterInteractiveComponent(_this);
+ }
+ };
+ return _this;
+ }
+ MorePopover.prototype.render = function () {
+ var _a = this.context, options = _a.options, dateEnv = _a.dateEnv;
+ var props = this.props;
+ var startDate = props.startDate, todayRange = props.todayRange, dateProfile = props.dateProfile;
+ var title = dateEnv.format(startDate, options.dayPopoverFormat);
+ return (createElement(DayCellRoot, { date: startDate, dateProfile: dateProfile, todayRange: todayRange, elRef: this.handleRootEl }, function (rootElRef, dayClassNames, dataAttrs) { return (createElement(Popover, { elRef: rootElRef, id: props.id, title: title, extraClassNames: ['fc-more-popover'].concat(dayClassNames), extraAttrs: dataAttrs /* TODO: make these time-based when not whole-day? */, parentEl: props.parentEl, alignmentEl: props.alignmentEl, alignGridTop: props.alignGridTop, onClose: props.onClose },
+ createElement(DayCellContent, { date: startDate, dateProfile: dateProfile, todayRange: todayRange }, function (innerElRef, innerContent) { return (innerContent &&
+ createElement("div", { className: "fc-more-popover-misc", ref: innerElRef }, innerContent)); }),
+ props.children)); }));
+ };
+ MorePopover.prototype.queryHit = function (positionLeft, positionTop, elWidth, elHeight) {
+ var _a = this, rootEl = _a.rootEl, props = _a.props;
+ if (positionLeft >= 0 && positionLeft < elWidth &&
+ positionTop >= 0 && positionTop < elHeight) {
+ return {
+ dateProfile: props.dateProfile,
+ dateSpan: __assign({ allDay: true, range: {
+ start: props.startDate,
+ end: props.endDate,
+ } }, props.extraDateSpan),
+ dayEl: rootEl,
+ rect: {
+ left: 0,
+ top: 0,
+ right: elWidth,
+ bottom: elHeight,
+ },
+ layer: 1, // important when comparing with hits from other components
+ };
+ }
+ return null;
+ };
+ return MorePopover;
+ }(DateComponent));
+
+ var MoreLinkRoot = /** @class */ (function (_super) {
+ __extends(MoreLinkRoot, _super);
+ function MoreLinkRoot() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.linkElRef = createRef();
+ _this.state = {
+ isPopoverOpen: false,
+ popoverId: getUniqueDomId(),
+ };
+ _this.handleClick = function (ev) {
+ var _a = _this, props = _a.props, context = _a.context;
+ var moreLinkClick = context.options.moreLinkClick;
+ var date = computeRange(props).start;
+ function buildPublicSeg(seg) {
+ var _a = seg.eventRange, def = _a.def, instance = _a.instance, range = _a.range;
+ return {
+ event: new EventApi(context, def, instance),
+ start: context.dateEnv.toDate(range.start),
+ end: context.dateEnv.toDate(range.end),
+ isStart: seg.isStart,
+ isEnd: seg.isEnd,
+ };
+ }
+ if (typeof moreLinkClick === 'function') {
+ moreLinkClick = moreLinkClick({
+ date: date,
+ allDay: Boolean(props.allDayDate),
+ allSegs: props.allSegs.map(buildPublicSeg),
+ hiddenSegs: props.hiddenSegs.map(buildPublicSeg),
+ jsEvent: ev,
+ view: context.viewApi,
+ });
+ }
+ if (!moreLinkClick || moreLinkClick === 'popover') {
+ _this.setState({ isPopoverOpen: true });
+ }
+ else if (typeof moreLinkClick === 'string') { // a view name
+ context.calendarApi.zoomTo(date, moreLinkClick);
+ }
+ };
+ _this.handlePopoverClose = function () {
+ _this.setState({ isPopoverOpen: false });
+ };
+ return _this;
+ }
+ MoreLinkRoot.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, state = _a.state;
+ return (createElement(ViewContextType.Consumer, null, function (context) {
+ var viewApi = context.viewApi, options = context.options, calendarApi = context.calendarApi;
+ var moreLinkText = options.moreLinkText;
+ var moreCnt = props.moreCnt;
+ var range = computeRange(props);
+ var text = typeof moreLinkText === 'function' // TODO: eventually use formatWithOrdinals
+ ? moreLinkText.call(calendarApi, moreCnt)
+ : "+" + moreCnt + " " + moreLinkText;
+ var title = formatWithOrdinals(options.moreLinkHint, [moreCnt], text);
+ var hookProps = {
+ num: moreCnt,
+ shortText: "+" + moreCnt,
+ text: text,
+ view: viewApi,
+ };
+ return (createElement(Fragment, null,
+ Boolean(props.moreCnt) && (createElement(RenderHook, { elRef: _this.linkElRef, hookProps: hookProps, classNames: options.moreLinkClassNames, content: options.moreLinkContent, defaultContent: props.defaultContent || renderMoreLinkInner$1, didMount: options.moreLinkDidMount, willUnmount: options.moreLinkWillUnmount }, function (rootElRef, customClassNames, innerElRef, innerContent) { return props.children(rootElRef, ['fc-more-link'].concat(customClassNames), innerElRef, innerContent, _this.handleClick, title, state.isPopoverOpen, state.isPopoverOpen ? state.popoverId : ''); })),
+ state.isPopoverOpen && (createElement(MorePopover, { id: state.popoverId, startDate: range.start, endDate: range.end, dateProfile: props.dateProfile, todayRange: props.todayRange, extraDateSpan: props.extraDateSpan, parentEl: _this.parentEl, alignmentEl: props.alignmentElRef.current, alignGridTop: props.alignGridTop, onClose: _this.handlePopoverClose }, props.popoverContent()))));
+ }));
+ };
+ MoreLinkRoot.prototype.componentDidMount = function () {
+ this.updateParentEl();
+ };
+ MoreLinkRoot.prototype.componentDidUpdate = function () {
+ this.updateParentEl();
+ };
+ MoreLinkRoot.prototype.updateParentEl = function () {
+ if (this.linkElRef.current) {
+ this.parentEl = elementClosest(this.linkElRef.current, '.fc-view-harness');
+ }
+ };
+ return MoreLinkRoot;
+ }(BaseComponent));
+ function renderMoreLinkInner$1(props) {
+ return props.text;
+ }
+ function computeRange(props) {
+ if (props.allDayDate) {
+ return {
+ start: props.allDayDate,
+ end: addDays(props.allDayDate, 1),
+ };
+ }
+ var hiddenSegs = props.hiddenSegs;
+ return {
+ start: computeEarliestSegStart(hiddenSegs),
+ end: computeLatestSegEnd(hiddenSegs),
+ };
+ }
+ function computeEarliestSegStart(segs) {
+ return segs.reduce(pickEarliestStart).eventRange.range.start;
+ }
+ function pickEarliestStart(seg0, seg1) {
+ return seg0.eventRange.range.start < seg1.eventRange.range.start ? seg0 : seg1;
+ }
+ function computeLatestSegEnd(segs) {
+ return segs.reduce(pickLatestEnd).eventRange.range.end;
+ }
+ function pickLatestEnd(seg0, seg1) {
+ return seg0.eventRange.range.end > seg1.eventRange.range.end ? seg0 : seg1;
+ }
+
+ // exports
+ // --------------------------------------------------------------------------------------------------
+ var version = '5.10.1'; // important to type it, so .d.ts has generic string
+
+ var Calendar = /** @class */ (function (_super) {
+ __extends(Calendar, _super);
+ function Calendar(el, optionOverrides) {
+ if (optionOverrides === void 0) { optionOverrides = {}; }
+ var _this = _super.call(this) || this;
+ _this.isRendering = false;
+ _this.isRendered = false;
+ _this.currentClassNames = [];
+ _this.customContentRenderId = 0; // will affect custom generated classNames?
+ _this.handleAction = function (action) {
+ // actions we know we want to render immediately
+ switch (action.type) {
+ case 'SET_EVENT_DRAG':
+ case 'SET_EVENT_RESIZE':
+ _this.renderRunner.tryDrain();
+ }
+ };
+ _this.handleData = function (data) {
+ _this.currentData = data;
+ _this.renderRunner.request(data.calendarOptions.rerenderDelay);
+ };
+ _this.handleRenderRequest = function () {
+ if (_this.isRendering) {
+ _this.isRendered = true;
+ var currentData_1 = _this.currentData;
+ render(createElement(CalendarRoot, { options: currentData_1.calendarOptions, theme: currentData_1.theme, emitter: currentData_1.emitter }, function (classNames, height, isHeightAuto, forPrint) {
+ _this.setClassNames(classNames);
+ _this.setHeight(height);
+ return (createElement(CustomContentRenderContext.Provider, { value: _this.customContentRenderId },
+ createElement(CalendarContent, __assign({ isHeightAuto: isHeightAuto, forPrint: forPrint }, currentData_1))));
+ }), _this.el);
+ }
+ else if (_this.isRendered) {
+ _this.isRendered = false;
+ unmountComponentAtNode(_this.el);
+ _this.setClassNames([]);
+ _this.setHeight('');
+ }
+ flushToDom();
+ };
+ _this.el = el;
+ _this.renderRunner = new DelayedRunner(_this.handleRenderRequest);
+ new CalendarDataManager({
+ optionOverrides: optionOverrides,
+ calendarApi: _this,
+ onAction: _this.handleAction,
+ onData: _this.handleData,
+ });
+ return _this;
+ }
+ Object.defineProperty(Calendar.prototype, "view", {
+ get: function () { return this.currentData.viewApi; } // for public API
+ ,
+ enumerable: false,
+ configurable: true
+ });
+ Calendar.prototype.render = function () {
+ var wasRendering = this.isRendering;
+ if (!wasRendering) {
+ this.isRendering = true;
+ }
+ else {
+ this.customContentRenderId += 1;
+ }
+ this.renderRunner.request();
+ if (wasRendering) {
+ this.updateSize();
+ }
+ };
+ Calendar.prototype.destroy = function () {
+ if (this.isRendering) {
+ this.isRendering = false;
+ this.renderRunner.request();
+ }
+ };
+ Calendar.prototype.updateSize = function () {
+ _super.prototype.updateSize.call(this);
+ flushToDom();
+ };
+ Calendar.prototype.batchRendering = function (func) {
+ this.renderRunner.pause('batchRendering');
+ func();
+ this.renderRunner.resume('batchRendering');
+ };
+ Calendar.prototype.pauseRendering = function () {
+ this.renderRunner.pause('pauseRendering');
+ };
+ Calendar.prototype.resumeRendering = function () {
+ this.renderRunner.resume('pauseRendering', true);
+ };
+ Calendar.prototype.resetOptions = function (optionOverrides, append) {
+ this.currentDataManager.resetOptions(optionOverrides, append);
+ };
+ Calendar.prototype.setClassNames = function (classNames) {
+ if (!isArraysEqual(classNames, this.currentClassNames)) {
+ var classList = this.el.classList;
+ for (var _i = 0, _a = this.currentClassNames; _i < _a.length; _i++) {
+ var className = _a[_i];
+ classList.remove(className);
+ }
+ for (var _b = 0, classNames_1 = classNames; _b < classNames_1.length; _b++) {
+ var className = classNames_1[_b];
+ classList.add(className);
+ }
+ this.currentClassNames = classNames;
+ }
+ };
+ Calendar.prototype.setHeight = function (height) {
+ applyStyleProp(this.el, 'height', height);
+ };
+ return Calendar;
+ }(CalendarApi));
+
+ config.touchMouseIgnoreWait = 500;
+ var ignoreMouseDepth = 0;
+ var listenerCnt = 0;
+ var isWindowTouchMoveCancelled = false;
+ /*
+ Uses a "pointer" abstraction, which monitors UI events for both mouse and touch.
+ Tracks when the pointer "drags" on a certain element, meaning down+move+up.
+
+ Also, tracks if there was touch-scrolling.
+ Also, can prevent touch-scrolling from happening.
+ Also, can fire pointermove events when scrolling happens underneath, even when no real pointer movement.
+
+ emits:
+ - pointerdown
+ - pointermove
+ - pointerup
+ */
+ var PointerDragging = /** @class */ (function () {
+ function PointerDragging(containerEl) {
+ var _this = this;
+ this.subjectEl = null;
+ // options that can be directly assigned by caller
+ this.selector = ''; // will cause subjectEl in all emitted events to be this element
+ this.handleSelector = '';
+ this.shouldIgnoreMove = false;
+ this.shouldWatchScroll = true; // for simulating pointermove on scroll
+ // internal states
+ this.isDragging = false;
+ this.isTouchDragging = false;
+ this.wasTouchScroll = false;
+ // Mouse
+ // ----------------------------------------------------------------------------------------------------
+ this.handleMouseDown = function (ev) {
+ if (!_this.shouldIgnoreMouse() &&
+ isPrimaryMouseButton(ev) &&
+ _this.tryStart(ev)) {
+ var pev = _this.createEventFromMouse(ev, true);
+ _this.emitter.trigger('pointerdown', pev);
+ _this.initScrollWatch(pev);
+ if (!_this.shouldIgnoreMove) {
+ document.addEventListener('mousemove', _this.handleMouseMove);
+ }
+ document.addEventListener('mouseup', _this.handleMouseUp);
+ }
+ };
+ this.handleMouseMove = function (ev) {
+ var pev = _this.createEventFromMouse(ev);
+ _this.recordCoords(pev);
+ _this.emitter.trigger('pointermove', pev);
+ };
+ this.handleMouseUp = function (ev) {
+ document.removeEventListener('mousemove', _this.handleMouseMove);
+ document.removeEventListener('mouseup', _this.handleMouseUp);
+ _this.emitter.trigger('pointerup', _this.createEventFromMouse(ev));
+ _this.cleanup(); // call last so that pointerup has access to props
+ };
+ // Touch
+ // ----------------------------------------------------------------------------------------------------
+ this.handleTouchStart = function (ev) {
+ if (_this.tryStart(ev)) {
+ _this.isTouchDragging = true;
+ var pev = _this.createEventFromTouch(ev, true);
+ _this.emitter.trigger('pointerdown', pev);
+ _this.initScrollWatch(pev);
+ // unlike mouse, need to attach to target, not document
+ // https://stackoverflow.com/a/45760014
+ var targetEl = ev.target;
+ if (!_this.shouldIgnoreMove) {
+ targetEl.addEventListener('touchmove', _this.handleTouchMove);
+ }
+ targetEl.addEventListener('touchend', _this.handleTouchEnd);
+ targetEl.addEventListener('touchcancel', _this.handleTouchEnd); // treat it as a touch end
+ // attach a handler to get called when ANY scroll action happens on the page.
+ // this was impossible to do with normal on/off because 'scroll' doesn't bubble.
+ // http://stackoverflow.com/a/32954565/96342
+ window.addEventListener('scroll', _this.handleTouchScroll, true);
+ }
+ };
+ this.handleTouchMove = function (ev) {
+ var pev = _this.createEventFromTouch(ev);
+ _this.recordCoords(pev);
+ _this.emitter.trigger('pointermove', pev);
+ };
+ this.handleTouchEnd = function (ev) {
+ if (_this.isDragging) { // done to guard against touchend followed by touchcancel
+ var targetEl = ev.target;
+ targetEl.removeEventListener('touchmove', _this.handleTouchMove);
+ targetEl.removeEventListener('touchend', _this.handleTouchEnd);
+ targetEl.removeEventListener('touchcancel', _this.handleTouchEnd);
+ window.removeEventListener('scroll', _this.handleTouchScroll, true); // useCaptured=true
+ _this.emitter.trigger('pointerup', _this.createEventFromTouch(ev));
+ _this.cleanup(); // call last so that pointerup has access to props
+ _this.isTouchDragging = false;
+ startIgnoringMouse();
+ }
+ };
+ this.handleTouchScroll = function () {
+ _this.wasTouchScroll = true;
+ };
+ this.handleScroll = function (ev) {
+ if (!_this.shouldIgnoreMove) {
+ var pageX = (window.pageXOffset - _this.prevScrollX) + _this.prevPageX;
+ var pageY = (window.pageYOffset - _this.prevScrollY) + _this.prevPageY;
+ _this.emitter.trigger('pointermove', {
+ origEvent: ev,
+ isTouch: _this.isTouchDragging,
+ subjectEl: _this.subjectEl,
+ pageX: pageX,
+ pageY: pageY,
+ deltaX: pageX - _this.origPageX,
+ deltaY: pageY - _this.origPageY,
+ });
+ }
+ };
+ this.containerEl = containerEl;
+ this.emitter = new Emitter();
+ containerEl.addEventListener('mousedown', this.handleMouseDown);
+ containerEl.addEventListener('touchstart', this.handleTouchStart, { passive: true });
+ listenerCreated();
+ }
+ PointerDragging.prototype.destroy = function () {
+ this.containerEl.removeEventListener('mousedown', this.handleMouseDown);
+ this.containerEl.removeEventListener('touchstart', this.handleTouchStart, { passive: true });
+ listenerDestroyed();
+ };
+ PointerDragging.prototype.tryStart = function (ev) {
+ var subjectEl = this.querySubjectEl(ev);
+ var downEl = ev.target;
+ if (subjectEl &&
+ (!this.handleSelector || elementClosest(downEl, this.handleSelector))) {
+ this.subjectEl = subjectEl;
+ this.isDragging = true; // do this first so cancelTouchScroll will work
+ this.wasTouchScroll = false;
+ return true;
+ }
+ return false;
+ };
+ PointerDragging.prototype.cleanup = function () {
+ isWindowTouchMoveCancelled = false;
+ this.isDragging = false;
+ this.subjectEl = null;
+ // keep wasTouchScroll around for later access
+ this.destroyScrollWatch();
+ };
+ PointerDragging.prototype.querySubjectEl = function (ev) {
+ if (this.selector) {
+ return elementClosest(ev.target, this.selector);
+ }
+ return this.containerEl;
+ };
+ PointerDragging.prototype.shouldIgnoreMouse = function () {
+ return ignoreMouseDepth || this.isTouchDragging;
+ };
+ // can be called by user of this class, to cancel touch-based scrolling for the current drag
+ PointerDragging.prototype.cancelTouchScroll = function () {
+ if (this.isDragging) {
+ isWindowTouchMoveCancelled = true;
+ }
+ };
+ // Scrolling that simulates pointermoves
+ // ----------------------------------------------------------------------------------------------------
+ PointerDragging.prototype.initScrollWatch = function (ev) {
+ if (this.shouldWatchScroll) {
+ this.recordCoords(ev);
+ window.addEventListener('scroll', this.handleScroll, true); // useCapture=true
+ }
+ };
+ PointerDragging.prototype.recordCoords = function (ev) {
+ if (this.shouldWatchScroll) {
+ this.prevPageX = ev.pageX;
+ this.prevPageY = ev.pageY;
+ this.prevScrollX = window.pageXOffset;
+ this.prevScrollY = window.pageYOffset;
+ }
+ };
+ PointerDragging.prototype.destroyScrollWatch = function () {
+ if (this.shouldWatchScroll) {
+ window.removeEventListener('scroll', this.handleScroll, true); // useCaptured=true
+ }
+ };
+ // Event Normalization
+ // ----------------------------------------------------------------------------------------------------
+ PointerDragging.prototype.createEventFromMouse = function (ev, isFirst) {
+ var deltaX = 0;
+ var deltaY = 0;
+ // TODO: repeat code
+ if (isFirst) {
+ this.origPageX = ev.pageX;
+ this.origPageY = ev.pageY;
+ }
+ else {
+ deltaX = ev.pageX - this.origPageX;
+ deltaY = ev.pageY - this.origPageY;
+ }
+ return {
+ origEvent: ev,
+ isTouch: false,
+ subjectEl: this.subjectEl,
+ pageX: ev.pageX,
+ pageY: ev.pageY,
+ deltaX: deltaX,
+ deltaY: deltaY,
+ };
+ };
+ PointerDragging.prototype.createEventFromTouch = function (ev, isFirst) {
+ var touches = ev.touches;
+ var pageX;
+ var pageY;
+ var deltaX = 0;
+ var deltaY = 0;
+ // if touch coords available, prefer,
+ // because FF would give bad ev.pageX ev.pageY
+ if (touches && touches.length) {
+ pageX = touches[0].pageX;
+ pageY = touches[0].pageY;
+ }
+ else {
+ pageX = ev.pageX;
+ pageY = ev.pageY;
+ }
+ // TODO: repeat code
+ if (isFirst) {
+ this.origPageX = pageX;
+ this.origPageY = pageY;
+ }
+ else {
+ deltaX = pageX - this.origPageX;
+ deltaY = pageY - this.origPageY;
+ }
+ return {
+ origEvent: ev,
+ isTouch: true,
+ subjectEl: this.subjectEl,
+ pageX: pageX,
+ pageY: pageY,
+ deltaX: deltaX,
+ deltaY: deltaY,
+ };
+ };
+ return PointerDragging;
+ }());
+ // Returns a boolean whether this was a left mouse click and no ctrl key (which means right click on Mac)
+ function isPrimaryMouseButton(ev) {
+ return ev.button === 0 && !ev.ctrlKey;
+ }
+ // Ignoring fake mouse events generated by touch
+ // ----------------------------------------------------------------------------------------------------
+ function startIgnoringMouse() {
+ ignoreMouseDepth += 1;
+ setTimeout(function () {
+ ignoreMouseDepth -= 1;
+ }, config.touchMouseIgnoreWait);
+ }
+ // We want to attach touchmove as early as possible for Safari
+ // ----------------------------------------------------------------------------------------------------
+ function listenerCreated() {
+ listenerCnt += 1;
+ if (listenerCnt === 1) {
+ window.addEventListener('touchmove', onWindowTouchMove, { passive: false });
+ }
+ }
+ function listenerDestroyed() {
+ listenerCnt -= 1;
+ if (!listenerCnt) {
+ window.removeEventListener('touchmove', onWindowTouchMove, { passive: false });
+ }
+ }
+ function onWindowTouchMove(ev) {
+ if (isWindowTouchMoveCancelled) {
+ ev.preventDefault();
+ }
+ }
+
+ /*
+ An effect in which an element follows the movement of a pointer across the screen.
+ The moving element is a clone of some other element.
+ Must call start + handleMove + stop.
+ */
+ var ElementMirror = /** @class */ (function () {
+ function ElementMirror() {
+ this.isVisible = false; // must be explicitly enabled
+ this.sourceEl = null;
+ this.mirrorEl = null;
+ this.sourceElRect = null; // screen coords relative to viewport
+ // options that can be set directly by caller
+ this.parentNode = document.body; // HIGHLY SUGGESTED to set this to sidestep ShadowDOM issues
+ this.zIndex = 9999;
+ this.revertDuration = 0;
+ }
+ ElementMirror.prototype.start = function (sourceEl, pageX, pageY) {
+ this.sourceEl = sourceEl;
+ this.sourceElRect = this.sourceEl.getBoundingClientRect();
+ this.origScreenX = pageX - window.pageXOffset;
+ this.origScreenY = pageY - window.pageYOffset;
+ this.deltaX = 0;
+ this.deltaY = 0;
+ this.updateElPosition();
+ };
+ ElementMirror.prototype.handleMove = function (pageX, pageY) {
+ this.deltaX = (pageX - window.pageXOffset) - this.origScreenX;
+ this.deltaY = (pageY - window.pageYOffset) - this.origScreenY;
+ this.updateElPosition();
+ };
+ // can be called before start
+ ElementMirror.prototype.setIsVisible = function (bool) {
+ if (bool) {
+ if (!this.isVisible) {
+ if (this.mirrorEl) {
+ this.mirrorEl.style.display = '';
+ }
+ this.isVisible = bool; // needs to happen before updateElPosition
+ this.updateElPosition(); // because was not updating the position while invisible
+ }
+ }
+ else if (this.isVisible) {
+ if (this.mirrorEl) {
+ this.mirrorEl.style.display = 'none';
+ }
+ this.isVisible = bool;
+ }
+ };
+ // always async
+ ElementMirror.prototype.stop = function (needsRevertAnimation, callback) {
+ var _this = this;
+ var done = function () {
+ _this.cleanup();
+ callback();
+ };
+ if (needsRevertAnimation &&
+ this.mirrorEl &&
+ this.isVisible &&
+ this.revertDuration && // if 0, transition won't work
+ (this.deltaX || this.deltaY) // if same coords, transition won't work
+ ) {
+ this.doRevertAnimation(done, this.revertDuration);
+ }
+ else {
+ setTimeout(done, 0);
+ }
+ };
+ ElementMirror.prototype.doRevertAnimation = function (callback, revertDuration) {
+ var mirrorEl = this.mirrorEl;
+ var finalSourceElRect = this.sourceEl.getBoundingClientRect(); // because autoscrolling might have happened
+ mirrorEl.style.transition =
+ 'top ' + revertDuration + 'ms,' +
+ 'left ' + revertDuration + 'ms';
+ applyStyle(mirrorEl, {
+ left: finalSourceElRect.left,
+ top: finalSourceElRect.top,
+ });
+ whenTransitionDone(mirrorEl, function () {
+ mirrorEl.style.transition = '';
+ callback();
+ });
+ };
+ ElementMirror.prototype.cleanup = function () {
+ if (this.mirrorEl) {
+ removeElement(this.mirrorEl);
+ this.mirrorEl = null;
+ }
+ this.sourceEl = null;
+ };
+ ElementMirror.prototype.updateElPosition = function () {
+ if (this.sourceEl && this.isVisible) {
+ applyStyle(this.getMirrorEl(), {
+ left: this.sourceElRect.left + this.deltaX,
+ top: this.sourceElRect.top + this.deltaY,
+ });
+ }
+ };
+ ElementMirror.prototype.getMirrorEl = function () {
+ var sourceElRect = this.sourceElRect;
+ var mirrorEl = this.mirrorEl;
+ if (!mirrorEl) {
+ mirrorEl = this.mirrorEl = this.sourceEl.cloneNode(true); // cloneChildren=true
+ // we don't want long taps or any mouse interaction causing selection/menus.
+ // would use preventSelection(), but that prevents selectstart, causing problems.
+ mirrorEl.classList.add('fc-unselectable');
+ mirrorEl.classList.add('fc-event-dragging');
+ applyStyle(mirrorEl, {
+ position: 'fixed',
+ zIndex: this.zIndex,
+ visibility: '',
+ boxSizing: 'border-box',
+ width: sourceElRect.right - sourceElRect.left,
+ height: sourceElRect.bottom - sourceElRect.top,
+ right: 'auto',
+ bottom: 'auto',
+ margin: 0,
+ });
+ this.parentNode.appendChild(mirrorEl);
+ }
+ return mirrorEl;
+ };
+ return ElementMirror;
+ }());
+
+ /*
+ Is a cache for a given element's scroll information (all the info that ScrollController stores)
+ in addition the "client rectangle" of the element.. the area within the scrollbars.
+
+ The cache can be in one of two modes:
+ - doesListening:false - ignores when the container is scrolled by someone else
+ - doesListening:true - watch for scrolling and update the cache
+ */
+ var ScrollGeomCache = /** @class */ (function (_super) {
+ __extends(ScrollGeomCache, _super);
+ function ScrollGeomCache(scrollController, doesListening) {
+ var _this = _super.call(this) || this;
+ _this.handleScroll = function () {
+ _this.scrollTop = _this.scrollController.getScrollTop();
+ _this.scrollLeft = _this.scrollController.getScrollLeft();
+ _this.handleScrollChange();
+ };
+ _this.scrollController = scrollController;
+ _this.doesListening = doesListening;
+ _this.scrollTop = _this.origScrollTop = scrollController.getScrollTop();
+ _this.scrollLeft = _this.origScrollLeft = scrollController.getScrollLeft();
+ _this.scrollWidth = scrollController.getScrollWidth();
+ _this.scrollHeight = scrollController.getScrollHeight();
+ _this.clientWidth = scrollController.getClientWidth();
+ _this.clientHeight = scrollController.getClientHeight();
+ _this.clientRect = _this.computeClientRect(); // do last in case it needs cached values
+ if (_this.doesListening) {
+ _this.getEventTarget().addEventListener('scroll', _this.handleScroll);
+ }
+ return _this;
+ }
+ ScrollGeomCache.prototype.destroy = function () {
+ if (this.doesListening) {
+ this.getEventTarget().removeEventListener('scroll', this.handleScroll);
+ }
+ };
+ ScrollGeomCache.prototype.getScrollTop = function () {
+ return this.scrollTop;
+ };
+ ScrollGeomCache.prototype.getScrollLeft = function () {
+ return this.scrollLeft;
+ };
+ ScrollGeomCache.prototype.setScrollTop = function (top) {
+ this.scrollController.setScrollTop(top);
+ if (!this.doesListening) {
+ // we are not relying on the element to normalize out-of-bounds scroll values
+ // so we need to sanitize ourselves
+ this.scrollTop = Math.max(Math.min(top, this.getMaxScrollTop()), 0);
+ this.handleScrollChange();
+ }
+ };
+ ScrollGeomCache.prototype.setScrollLeft = function (top) {
+ this.scrollController.setScrollLeft(top);
+ if (!this.doesListening) {
+ // we are not relying on the element to normalize out-of-bounds scroll values
+ // so we need to sanitize ourselves
+ this.scrollLeft = Math.max(Math.min(top, this.getMaxScrollLeft()), 0);
+ this.handleScrollChange();
+ }
+ };
+ ScrollGeomCache.prototype.getClientWidth = function () {
+ return this.clientWidth;
+ };
+ ScrollGeomCache.prototype.getClientHeight = function () {
+ return this.clientHeight;
+ };
+ ScrollGeomCache.prototype.getScrollWidth = function () {
+ return this.scrollWidth;
+ };
+ ScrollGeomCache.prototype.getScrollHeight = function () {
+ return this.scrollHeight;
+ };
+ ScrollGeomCache.prototype.handleScrollChange = function () {
+ };
+ return ScrollGeomCache;
+ }(ScrollController));
+
+ var ElementScrollGeomCache = /** @class */ (function (_super) {
+ __extends(ElementScrollGeomCache, _super);
+ function ElementScrollGeomCache(el, doesListening) {
+ return _super.call(this, new ElementScrollController(el), doesListening) || this;
+ }
+ ElementScrollGeomCache.prototype.getEventTarget = function () {
+ return this.scrollController.el;
+ };
+ ElementScrollGeomCache.prototype.computeClientRect = function () {
+ return computeInnerRect(this.scrollController.el);
+ };
+ return ElementScrollGeomCache;
+ }(ScrollGeomCache));
+
+ var WindowScrollGeomCache = /** @class */ (function (_super) {
+ __extends(WindowScrollGeomCache, _super);
+ function WindowScrollGeomCache(doesListening) {
+ return _super.call(this, new WindowScrollController(), doesListening) || this;
+ }
+ WindowScrollGeomCache.prototype.getEventTarget = function () {
+ return window;
+ };
+ WindowScrollGeomCache.prototype.computeClientRect = function () {
+ return {
+ left: this.scrollLeft,
+ right: this.scrollLeft + this.clientWidth,
+ top: this.scrollTop,
+ bottom: this.scrollTop + this.clientHeight,
+ };
+ };
+ // the window is the only scroll object that changes it's rectangle relative
+ // to the document's topleft as it scrolls
+ WindowScrollGeomCache.prototype.handleScrollChange = function () {
+ this.clientRect = this.computeClientRect();
+ };
+ return WindowScrollGeomCache;
+ }(ScrollGeomCache));
+
+ // If available we are using native "performance" API instead of "Date"
+ // Read more about it on MDN:
+ // https://developer.mozilla.org/en-US/docs/Web/API/Performance
+ var getTime = typeof performance === 'function' ? performance.now : Date.now;
+ /*
+ For a pointer interaction, automatically scrolls certain scroll containers when the pointer
+ approaches the edge.
+
+ The caller must call start + handleMove + stop.
+ */
+ var AutoScroller = /** @class */ (function () {
+ function AutoScroller() {
+ var _this = this;
+ // options that can be set by caller
+ this.isEnabled = true;
+ this.scrollQuery = [window, '.fc-scroller'];
+ this.edgeThreshold = 50; // pixels
+ this.maxVelocity = 300; // pixels per second
+ // internal state
+ this.pointerScreenX = null;
+ this.pointerScreenY = null;
+ this.isAnimating = false;
+ this.scrollCaches = null;
+ // protect against the initial pointerdown being too close to an edge and starting the scroll
+ this.everMovedUp = false;
+ this.everMovedDown = false;
+ this.everMovedLeft = false;
+ this.everMovedRight = false;
+ this.animate = function () {
+ if (_this.isAnimating) { // wasn't cancelled between animation calls
+ var edge = _this.computeBestEdge(_this.pointerScreenX + window.pageXOffset, _this.pointerScreenY + window.pageYOffset);
+ if (edge) {
+ var now = getTime();
+ _this.handleSide(edge, (now - _this.msSinceRequest) / 1000);
+ _this.requestAnimation(now);
+ }
+ else {
+ _this.isAnimating = false; // will stop animation
+ }
+ }
+ };
+ }
+ AutoScroller.prototype.start = function (pageX, pageY, scrollStartEl) {
+ if (this.isEnabled) {
+ this.scrollCaches = this.buildCaches(scrollStartEl);
+ this.pointerScreenX = null;
+ this.pointerScreenY = null;
+ this.everMovedUp = false;
+ this.everMovedDown = false;
+ this.everMovedLeft = false;
+ this.everMovedRight = false;
+ this.handleMove(pageX, pageY);
+ }
+ };
+ AutoScroller.prototype.handleMove = function (pageX, pageY) {
+ if (this.isEnabled) {
+ var pointerScreenX = pageX - window.pageXOffset;
+ var pointerScreenY = pageY - window.pageYOffset;
+ var yDelta = this.pointerScreenY === null ? 0 : pointerScreenY - this.pointerScreenY;
+ var xDelta = this.pointerScreenX === null ? 0 : pointerScreenX - this.pointerScreenX;
+ if (yDelta < 0) {
+ this.everMovedUp = true;
+ }
+ else if (yDelta > 0) {
+ this.everMovedDown = true;
+ }
+ if (xDelta < 0) {
+ this.everMovedLeft = true;
+ }
+ else if (xDelta > 0) {
+ this.everMovedRight = true;
+ }
+ this.pointerScreenX = pointerScreenX;
+ this.pointerScreenY = pointerScreenY;
+ if (!this.isAnimating) {
+ this.isAnimating = true;
+ this.requestAnimation(getTime());
+ }
+ }
+ };
+ AutoScroller.prototype.stop = function () {
+ if (this.isEnabled) {
+ this.isAnimating = false; // will stop animation
+ for (var _i = 0, _a = this.scrollCaches; _i < _a.length; _i++) {
+ var scrollCache = _a[_i];
+ scrollCache.destroy();
+ }
+ this.scrollCaches = null;
+ }
+ };
+ AutoScroller.prototype.requestAnimation = function (now) {
+ this.msSinceRequest = now;
+ requestAnimationFrame(this.animate);
+ };
+ AutoScroller.prototype.handleSide = function (edge, seconds) {
+ var scrollCache = edge.scrollCache;
+ var edgeThreshold = this.edgeThreshold;
+ var invDistance = edgeThreshold - edge.distance;
+ var velocity = // the closer to the edge, the faster we scroll
+ ((invDistance * invDistance) / (edgeThreshold * edgeThreshold)) * // quadratic
+ this.maxVelocity * seconds;
+ var sign = 1;
+ switch (edge.name) {
+ case 'left':
+ sign = -1;
+ // falls through
+ case 'right':
+ scrollCache.setScrollLeft(scrollCache.getScrollLeft() + velocity * sign);
+ break;
+ case 'top':
+ sign = -1;
+ // falls through
+ case 'bottom':
+ scrollCache.setScrollTop(scrollCache.getScrollTop() + velocity * sign);
+ break;
+ }
+ };
+ // left/top are relative to document topleft
+ AutoScroller.prototype.computeBestEdge = function (left, top) {
+ var edgeThreshold = this.edgeThreshold;
+ var bestSide = null;
+ for (var _i = 0, _a = this.scrollCaches; _i < _a.length; _i++) {
+ var scrollCache = _a[_i];
+ var rect = scrollCache.clientRect;
+ var leftDist = left - rect.left;
+ var rightDist = rect.right - left;
+ var topDist = top - rect.top;
+ var bottomDist = rect.bottom - top;
+ // completely within the rect?
+ if (leftDist >= 0 && rightDist >= 0 && topDist >= 0 && bottomDist >= 0) {
+ if (topDist <= edgeThreshold && this.everMovedUp && scrollCache.canScrollUp() &&
+ (!bestSide || bestSide.distance > topDist)) {
+ bestSide = { scrollCache: scrollCache, name: 'top', distance: topDist };
+ }
+ if (bottomDist <= edgeThreshold && this.everMovedDown && scrollCache.canScrollDown() &&
+ (!bestSide || bestSide.distance > bottomDist)) {
+ bestSide = { scrollCache: scrollCache, name: 'bottom', distance: bottomDist };
+ }
+ if (leftDist <= edgeThreshold && this.everMovedLeft && scrollCache.canScrollLeft() &&
+ (!bestSide || bestSide.distance > leftDist)) {
+ bestSide = { scrollCache: scrollCache, name: 'left', distance: leftDist };
+ }
+ if (rightDist <= edgeThreshold && this.everMovedRight && scrollCache.canScrollRight() &&
+ (!bestSide || bestSide.distance > rightDist)) {
+ bestSide = { scrollCache: scrollCache, name: 'right', distance: rightDist };
+ }
+ }
+ }
+ return bestSide;
+ };
+ AutoScroller.prototype.buildCaches = function (scrollStartEl) {
+ return this.queryScrollEls(scrollStartEl).map(function (el) {
+ if (el === window) {
+ return new WindowScrollGeomCache(false); // false = don't listen to user-generated scrolls
+ }
+ return new ElementScrollGeomCache(el, false); // false = don't listen to user-generated scrolls
+ });
+ };
+ AutoScroller.prototype.queryScrollEls = function (scrollStartEl) {
+ var els = [];
+ for (var _i = 0, _a = this.scrollQuery; _i < _a.length; _i++) {
+ var query = _a[_i];
+ if (typeof query === 'object') {
+ els.push(query);
+ }
+ else {
+ els.push.apply(els, Array.prototype.slice.call(getElRoot(scrollStartEl).querySelectorAll(query)));
+ }
+ }
+ return els;
+ };
+ return AutoScroller;
+ }());
+
+ /*
+ Monitors dragging on an element. Has a number of high-level features:
+ - minimum distance required before dragging
+ - minimum wait time ("delay") before dragging
+ - a mirror element that follows the pointer
+ */
+ var FeaturefulElementDragging = /** @class */ (function (_super) {
+ __extends(FeaturefulElementDragging, _super);
+ function FeaturefulElementDragging(containerEl, selector) {
+ var _this = _super.call(this, containerEl) || this;
+ _this.containerEl = containerEl;
+ // options that can be directly set by caller
+ // the caller can also set the PointerDragging's options as well
+ _this.delay = null;
+ _this.minDistance = 0;
+ _this.touchScrollAllowed = true; // prevents drag from starting and blocks scrolling during drag
+ _this.mirrorNeedsRevert = false;
+ _this.isInteracting = false; // is the user validly moving the pointer? lasts until pointerup
+ _this.isDragging = false; // is it INTENTFULLY dragging? lasts until after revert animation
+ _this.isDelayEnded = false;
+ _this.isDistanceSurpassed = false;
+ _this.delayTimeoutId = null;
+ _this.onPointerDown = function (ev) {
+ if (!_this.isDragging) { // so new drag doesn't happen while revert animation is going
+ _this.isInteracting = true;
+ _this.isDelayEnded = false;
+ _this.isDistanceSurpassed = false;
+ preventSelection(document.body);
+ preventContextMenu(document.body);
+ // prevent links from being visited if there's an eventual drag.
+ // also prevents selection in older browsers (maybe?).
+ // not necessary for touch, besides, browser would complain about passiveness.
+ if (!ev.isTouch) {
+ ev.origEvent.preventDefault();
+ }
+ _this.emitter.trigger('pointerdown', ev);
+ if (_this.isInteracting && // not destroyed via pointerdown handler
+ !_this.pointer.shouldIgnoreMove) {
+ // actions related to initiating dragstart+dragmove+dragend...
+ _this.mirror.setIsVisible(false); // reset. caller must set-visible
+ _this.mirror.start(ev.subjectEl, ev.pageX, ev.pageY); // must happen on first pointer down
+ _this.startDelay(ev);
+ if (!_this.minDistance) {
+ _this.handleDistanceSurpassed(ev);
+ }
+ }
+ }
+ };
+ _this.onPointerMove = function (ev) {
+ if (_this.isInteracting) {
+ _this.emitter.trigger('pointermove', ev);
+ if (!_this.isDistanceSurpassed) {
+ var minDistance = _this.minDistance;
+ var distanceSq = void 0; // current distance from the origin, squared
+ var deltaX = ev.deltaX, deltaY = ev.deltaY;
+ distanceSq = deltaX * deltaX + deltaY * deltaY;
+ if (distanceSq >= minDistance * minDistance) { // use pythagorean theorem
+ _this.handleDistanceSurpassed(ev);
+ }
+ }
+ if (_this.isDragging) {
+ // a real pointer move? (not one simulated by scrolling)
+ if (ev.origEvent.type !== 'scroll') {
+ _this.mirror.handleMove(ev.pageX, ev.pageY);
+ _this.autoScroller.handleMove(ev.pageX, ev.pageY);
+ }
+ _this.emitter.trigger('dragmove', ev);
+ }
+ }
+ };
+ _this.onPointerUp = function (ev) {
+ if (_this.isInteracting) {
+ _this.isInteracting = false;
+ allowSelection(document.body);
+ allowContextMenu(document.body);
+ _this.emitter.trigger('pointerup', ev); // can potentially set mirrorNeedsRevert
+ if (_this.isDragging) {
+ _this.autoScroller.stop();
+ _this.tryStopDrag(ev); // which will stop the mirror
+ }
+ if (_this.delayTimeoutId) {
+ clearTimeout(_this.delayTimeoutId);
+ _this.delayTimeoutId = null;
+ }
+ }
+ };
+ var pointer = _this.pointer = new PointerDragging(containerEl);
+ pointer.emitter.on('pointerdown', _this.onPointerDown);
+ pointer.emitter.on('pointermove', _this.onPointerMove);
+ pointer.emitter.on('pointerup', _this.onPointerUp);
+ if (selector) {
+ pointer.selector = selector;
+ }
+ _this.mirror = new ElementMirror();
+ _this.autoScroller = new AutoScroller();
+ return _this;
+ }
+ FeaturefulElementDragging.prototype.destroy = function () {
+ this.pointer.destroy();
+ // HACK: simulate a pointer-up to end the current drag
+ // TODO: fire 'dragend' directly and stop interaction. discourage use of pointerup event (b/c might not fire)
+ this.onPointerUp({});
+ };
+ FeaturefulElementDragging.prototype.startDelay = function (ev) {
+ var _this = this;
+ if (typeof this.delay === 'number') {
+ this.delayTimeoutId = setTimeout(function () {
+ _this.delayTimeoutId = null;
+ _this.handleDelayEnd(ev);
+ }, this.delay); // not assignable to number!
+ }
+ else {
+ this.handleDelayEnd(ev);
+ }
+ };
+ FeaturefulElementDragging.prototype.handleDelayEnd = function (ev) {
+ this.isDelayEnded = true;
+ this.tryStartDrag(ev);
+ };
+ FeaturefulElementDragging.prototype.handleDistanceSurpassed = function (ev) {
+ this.isDistanceSurpassed = true;
+ this.tryStartDrag(ev);
+ };
+ FeaturefulElementDragging.prototype.tryStartDrag = function (ev) {
+ if (this.isDelayEnded && this.isDistanceSurpassed) {
+ if (!this.pointer.wasTouchScroll || this.touchScrollAllowed) {
+ this.isDragging = true;
+ this.mirrorNeedsRevert = false;
+ this.autoScroller.start(ev.pageX, ev.pageY, this.containerEl);
+ this.emitter.trigger('dragstart', ev);
+ if (this.touchScrollAllowed === false) {
+ this.pointer.cancelTouchScroll();
+ }
+ }
+ }
+ };
+ FeaturefulElementDragging.prototype.tryStopDrag = function (ev) {
+ // .stop() is ALWAYS asynchronous, which we NEED because we want all pointerup events
+ // that come from the document to fire beforehand. much more convenient this way.
+ this.mirror.stop(this.mirrorNeedsRevert, this.stopDrag.bind(this, ev));
+ };
+ FeaturefulElementDragging.prototype.stopDrag = function (ev) {
+ this.isDragging = false;
+ this.emitter.trigger('dragend', ev);
+ };
+ // fill in the implementations...
+ FeaturefulElementDragging.prototype.setIgnoreMove = function (bool) {
+ this.pointer.shouldIgnoreMove = bool;
+ };
+ FeaturefulElementDragging.prototype.setMirrorIsVisible = function (bool) {
+ this.mirror.setIsVisible(bool);
+ };
+ FeaturefulElementDragging.prototype.setMirrorNeedsRevert = function (bool) {
+ this.mirrorNeedsRevert = bool;
+ };
+ FeaturefulElementDragging.prototype.setAutoScrollEnabled = function (bool) {
+ this.autoScroller.isEnabled = bool;
+ };
+ return FeaturefulElementDragging;
+ }(ElementDragging));
+
+ /*
+ When this class is instantiated, it records the offset of an element (relative to the document topleft),
+ and continues to monitor scrolling, updating the cached coordinates if it needs to.
+ Does not access the DOM after instantiation, so highly performant.
+
+ Also keeps track of all scrolling/overflow:hidden containers that are parents of the given element
+ and an determine if a given point is inside the combined clipping rectangle.
+ */
+ var OffsetTracker = /** @class */ (function () {
+ function OffsetTracker(el) {
+ this.origRect = computeRect(el);
+ // will work fine for divs that have overflow:hidden
+ this.scrollCaches = getClippingParents(el).map(function (scrollEl) { return new ElementScrollGeomCache(scrollEl, true); });
+ }
+ OffsetTracker.prototype.destroy = function () {
+ for (var _i = 0, _a = this.scrollCaches; _i < _a.length; _i++) {
+ var scrollCache = _a[_i];
+ scrollCache.destroy();
+ }
+ };
+ OffsetTracker.prototype.computeLeft = function () {
+ var left = this.origRect.left;
+ for (var _i = 0, _a = this.scrollCaches; _i < _a.length; _i++) {
+ var scrollCache = _a[_i];
+ left += scrollCache.origScrollLeft - scrollCache.getScrollLeft();
+ }
+ return left;
+ };
+ OffsetTracker.prototype.computeTop = function () {
+ var top = this.origRect.top;
+ for (var _i = 0, _a = this.scrollCaches; _i < _a.length; _i++) {
+ var scrollCache = _a[_i];
+ top += scrollCache.origScrollTop - scrollCache.getScrollTop();
+ }
+ return top;
+ };
+ OffsetTracker.prototype.isWithinClipping = function (pageX, pageY) {
+ var point = { left: pageX, top: pageY };
+ for (var _i = 0, _a = this.scrollCaches; _i < _a.length; _i++) {
+ var scrollCache = _a[_i];
+ if (!isIgnoredClipping(scrollCache.getEventTarget()) &&
+ !pointInsideRect(point, scrollCache.clientRect)) {
+ return false;
+ }
+ }
+ return true;
+ };
+ return OffsetTracker;
+ }());
+ // certain clipping containers should never constrain interactions, like and
+ // https://github.com/fullcalendar/fullcalendar/issues/3615
+ function isIgnoredClipping(node) {
+ var tagName = node.tagName;
+ return tagName === 'HTML' || tagName === 'BODY';
+ }
+
+ /*
+ Tracks movement over multiple droppable areas (aka "hits")
+ that exist in one or more DateComponents.
+ Relies on an existing draggable.
+
+ emits:
+ - pointerdown
+ - dragstart
+ - hitchange - fires initially, even if not over a hit
+ - pointerup
+ - (hitchange - again, to null, if ended over a hit)
+ - dragend
+ */
+ var HitDragging = /** @class */ (function () {
+ function HitDragging(dragging, droppableStore) {
+ var _this = this;
+ // options that can be set by caller
+ this.useSubjectCenter = false;
+ this.requireInitial = true; // if doesn't start out on a hit, won't emit any events
+ this.initialHit = null;
+ this.movingHit = null;
+ this.finalHit = null; // won't ever be populated if shouldIgnoreMove
+ this.handlePointerDown = function (ev) {
+ var dragging = _this.dragging;
+ _this.initialHit = null;
+ _this.movingHit = null;
+ _this.finalHit = null;
+ _this.prepareHits();
+ _this.processFirstCoord(ev);
+ if (_this.initialHit || !_this.requireInitial) {
+ dragging.setIgnoreMove(false);
+ // TODO: fire this before computing processFirstCoord, so listeners can cancel. this gets fired by almost every handler :(
+ _this.emitter.trigger('pointerdown', ev);
+ }
+ else {
+ dragging.setIgnoreMove(true);
+ }
+ };
+ this.handleDragStart = function (ev) {
+ _this.emitter.trigger('dragstart', ev);
+ _this.handleMove(ev, true); // force = fire even if initially null
+ };
+ this.handleDragMove = function (ev) {
+ _this.emitter.trigger('dragmove', ev);
+ _this.handleMove(ev);
+ };
+ this.handlePointerUp = function (ev) {
+ _this.releaseHits();
+ _this.emitter.trigger('pointerup', ev);
+ };
+ this.handleDragEnd = function (ev) {
+ if (_this.movingHit) {
+ _this.emitter.trigger('hitupdate', null, true, ev);
+ }
+ _this.finalHit = _this.movingHit;
+ _this.movingHit = null;
+ _this.emitter.trigger('dragend', ev);
+ };
+ this.droppableStore = droppableStore;
+ dragging.emitter.on('pointerdown', this.handlePointerDown);
+ dragging.emitter.on('dragstart', this.handleDragStart);
+ dragging.emitter.on('dragmove', this.handleDragMove);
+ dragging.emitter.on('pointerup', this.handlePointerUp);
+ dragging.emitter.on('dragend', this.handleDragEnd);
+ this.dragging = dragging;
+ this.emitter = new Emitter();
+ }
+ // sets initialHit
+ // sets coordAdjust
+ HitDragging.prototype.processFirstCoord = function (ev) {
+ var origPoint = { left: ev.pageX, top: ev.pageY };
+ var adjustedPoint = origPoint;
+ var subjectEl = ev.subjectEl;
+ var subjectRect;
+ if (subjectEl instanceof HTMLElement) { // i.e. not a Document/ShadowRoot
+ subjectRect = computeRect(subjectEl);
+ adjustedPoint = constrainPoint(adjustedPoint, subjectRect);
+ }
+ var initialHit = this.initialHit = this.queryHitForOffset(adjustedPoint.left, adjustedPoint.top);
+ if (initialHit) {
+ if (this.useSubjectCenter && subjectRect) {
+ var slicedSubjectRect = intersectRects(subjectRect, initialHit.rect);
+ if (slicedSubjectRect) {
+ adjustedPoint = getRectCenter(slicedSubjectRect);
+ }
+ }
+ this.coordAdjust = diffPoints(adjustedPoint, origPoint);
+ }
+ else {
+ this.coordAdjust = { left: 0, top: 0 };
+ }
+ };
+ HitDragging.prototype.handleMove = function (ev, forceHandle) {
+ var hit = this.queryHitForOffset(ev.pageX + this.coordAdjust.left, ev.pageY + this.coordAdjust.top);
+ if (forceHandle || !isHitsEqual(this.movingHit, hit)) {
+ this.movingHit = hit;
+ this.emitter.trigger('hitupdate', hit, false, ev);
+ }
+ };
+ HitDragging.prototype.prepareHits = function () {
+ this.offsetTrackers = mapHash(this.droppableStore, function (interactionSettings) {
+ interactionSettings.component.prepareHits();
+ return new OffsetTracker(interactionSettings.el);
+ });
+ };
+ HitDragging.prototype.releaseHits = function () {
+ var offsetTrackers = this.offsetTrackers;
+ for (var id in offsetTrackers) {
+ offsetTrackers[id].destroy();
+ }
+ this.offsetTrackers = {};
+ };
+ HitDragging.prototype.queryHitForOffset = function (offsetLeft, offsetTop) {
+ var _a = this, droppableStore = _a.droppableStore, offsetTrackers = _a.offsetTrackers;
+ var bestHit = null;
+ for (var id in droppableStore) {
+ var component = droppableStore[id].component;
+ var offsetTracker = offsetTrackers[id];
+ if (offsetTracker && // wasn't destroyed mid-drag
+ offsetTracker.isWithinClipping(offsetLeft, offsetTop)) {
+ var originLeft = offsetTracker.computeLeft();
+ var originTop = offsetTracker.computeTop();
+ var positionLeft = offsetLeft - originLeft;
+ var positionTop = offsetTop - originTop;
+ var origRect = offsetTracker.origRect;
+ var width = origRect.right - origRect.left;
+ var height = origRect.bottom - origRect.top;
+ if (
+ // must be within the element's bounds
+ positionLeft >= 0 && positionLeft < width &&
+ positionTop >= 0 && positionTop < height) {
+ var hit = component.queryHit(positionLeft, positionTop, width, height);
+ if (hit && (
+ // make sure the hit is within activeRange, meaning it's not a dead cell
+ rangeContainsRange(hit.dateProfile.activeRange, hit.dateSpan.range)) &&
+ (!bestHit || hit.layer > bestHit.layer)) {
+ hit.componentId = id;
+ hit.context = component.context;
+ // TODO: better way to re-orient rectangle
+ hit.rect.left += originLeft;
+ hit.rect.right += originLeft;
+ hit.rect.top += originTop;
+ hit.rect.bottom += originTop;
+ bestHit = hit;
+ }
+ }
+ }
+ }
+ return bestHit;
+ };
+ return HitDragging;
+ }());
+ function isHitsEqual(hit0, hit1) {
+ if (!hit0 && !hit1) {
+ return true;
+ }
+ if (Boolean(hit0) !== Boolean(hit1)) {
+ return false;
+ }
+ return isDateSpansEqual(hit0.dateSpan, hit1.dateSpan);
+ }
+
+ function buildDatePointApiWithContext(dateSpan, context) {
+ var props = {};
+ for (var _i = 0, _a = context.pluginHooks.datePointTransforms; _i < _a.length; _i++) {
+ var transform = _a[_i];
+ __assign(props, transform(dateSpan, context));
+ }
+ __assign(props, buildDatePointApi(dateSpan, context.dateEnv));
+ return props;
+ }
+ function buildDatePointApi(span, dateEnv) {
+ return {
+ date: dateEnv.toDate(span.range.start),
+ dateStr: dateEnv.formatIso(span.range.start, { omitTime: span.allDay }),
+ allDay: span.allDay,
+ };
+ }
+
+ /*
+ Monitors when the user clicks on a specific date/time of a component.
+ A pointerdown+pointerup on the same "hit" constitutes a click.
+ */
+ var DateClicking = /** @class */ (function (_super) {
+ __extends(DateClicking, _super);
+ function DateClicking(settings) {
+ var _this = _super.call(this, settings) || this;
+ _this.handlePointerDown = function (pev) {
+ var dragging = _this.dragging;
+ var downEl = pev.origEvent.target;
+ // do this in pointerdown (not dragend) because DOM might be mutated by the time dragend is fired
+ dragging.setIgnoreMove(!_this.component.isValidDateDownEl(downEl));
+ };
+ // won't even fire if moving was ignored
+ _this.handleDragEnd = function (ev) {
+ var component = _this.component;
+ var pointer = _this.dragging.pointer;
+ if (!pointer.wasTouchScroll) {
+ var _a = _this.hitDragging, initialHit = _a.initialHit, finalHit = _a.finalHit;
+ if (initialHit && finalHit && isHitsEqual(initialHit, finalHit)) {
+ var context = component.context;
+ var arg = __assign(__assign({}, buildDatePointApiWithContext(initialHit.dateSpan, context)), { dayEl: initialHit.dayEl, jsEvent: ev.origEvent, view: context.viewApi || context.calendarApi.view });
+ context.emitter.trigger('dateClick', arg);
+ }
+ }
+ };
+ // we DO want to watch pointer moves because otherwise finalHit won't get populated
+ _this.dragging = new FeaturefulElementDragging(settings.el);
+ _this.dragging.autoScroller.isEnabled = false;
+ var hitDragging = _this.hitDragging = new HitDragging(_this.dragging, interactionSettingsToStore(settings));
+ hitDragging.emitter.on('pointerdown', _this.handlePointerDown);
+ hitDragging.emitter.on('dragend', _this.handleDragEnd);
+ return _this;
+ }
+ DateClicking.prototype.destroy = function () {
+ this.dragging.destroy();
+ };
+ return DateClicking;
+ }(Interaction));
+
+ /*
+ Tracks when the user selects a portion of time of a component,
+ constituted by a drag over date cells, with a possible delay at the beginning of the drag.
+ */
+ var DateSelecting = /** @class */ (function (_super) {
+ __extends(DateSelecting, _super);
+ function DateSelecting(settings) {
+ var _this = _super.call(this, settings) || this;
+ _this.dragSelection = null;
+ _this.handlePointerDown = function (ev) {
+ var _a = _this, component = _a.component, dragging = _a.dragging;
+ var options = component.context.options;
+ var canSelect = options.selectable &&
+ component.isValidDateDownEl(ev.origEvent.target);
+ // don't bother to watch expensive moves if component won't do selection
+ dragging.setIgnoreMove(!canSelect);
+ // if touch, require user to hold down
+ dragging.delay = ev.isTouch ? getComponentTouchDelay$1(component) : null;
+ };
+ _this.handleDragStart = function (ev) {
+ _this.component.context.calendarApi.unselect(ev); // unselect previous selections
+ };
+ _this.handleHitUpdate = function (hit, isFinal) {
+ var context = _this.component.context;
+ var dragSelection = null;
+ var isInvalid = false;
+ if (hit) {
+ var initialHit = _this.hitDragging.initialHit;
+ var disallowed = hit.componentId === initialHit.componentId
+ && _this.isHitComboAllowed
+ && !_this.isHitComboAllowed(initialHit, hit);
+ if (!disallowed) {
+ dragSelection = joinHitsIntoSelection(initialHit, hit, context.pluginHooks.dateSelectionTransformers);
+ }
+ if (!dragSelection || !isDateSelectionValid(dragSelection, hit.dateProfile, context)) {
+ isInvalid = true;
+ dragSelection = null;
+ }
+ }
+ if (dragSelection) {
+ context.dispatch({ type: 'SELECT_DATES', selection: dragSelection });
+ }
+ else if (!isFinal) { // only unselect if moved away while dragging
+ context.dispatch({ type: 'UNSELECT_DATES' });
+ }
+ if (!isInvalid) {
+ enableCursor();
+ }
+ else {
+ disableCursor();
+ }
+ if (!isFinal) {
+ _this.dragSelection = dragSelection; // only clear if moved away from all hits while dragging
+ }
+ };
+ _this.handlePointerUp = function (pev) {
+ if (_this.dragSelection) {
+ // selection is already rendered, so just need to report selection
+ triggerDateSelect(_this.dragSelection, pev, _this.component.context);
+ _this.dragSelection = null;
+ }
+ };
+ var component = settings.component;
+ var options = component.context.options;
+ var dragging = _this.dragging = new FeaturefulElementDragging(settings.el);
+ dragging.touchScrollAllowed = false;
+ dragging.minDistance = options.selectMinDistance || 0;
+ dragging.autoScroller.isEnabled = options.dragScroll;
+ var hitDragging = _this.hitDragging = new HitDragging(_this.dragging, interactionSettingsToStore(settings));
+ hitDragging.emitter.on('pointerdown', _this.handlePointerDown);
+ hitDragging.emitter.on('dragstart', _this.handleDragStart);
+ hitDragging.emitter.on('hitupdate', _this.handleHitUpdate);
+ hitDragging.emitter.on('pointerup', _this.handlePointerUp);
+ return _this;
+ }
+ DateSelecting.prototype.destroy = function () {
+ this.dragging.destroy();
+ };
+ return DateSelecting;
+ }(Interaction));
+ function getComponentTouchDelay$1(component) {
+ var options = component.context.options;
+ var delay = options.selectLongPressDelay;
+ if (delay == null) {
+ delay = options.longPressDelay;
+ }
+ return delay;
+ }
+ function joinHitsIntoSelection(hit0, hit1, dateSelectionTransformers) {
+ var dateSpan0 = hit0.dateSpan;
+ var dateSpan1 = hit1.dateSpan;
+ var ms = [
+ dateSpan0.range.start,
+ dateSpan0.range.end,
+ dateSpan1.range.start,
+ dateSpan1.range.end,
+ ];
+ ms.sort(compareNumbers);
+ var props = {};
+ for (var _i = 0, dateSelectionTransformers_1 = dateSelectionTransformers; _i < dateSelectionTransformers_1.length; _i++) {
+ var transformer = dateSelectionTransformers_1[_i];
+ var res = transformer(hit0, hit1);
+ if (res === false) {
+ return null;
+ }
+ if (res) {
+ __assign(props, res);
+ }
+ }
+ props.range = { start: ms[0], end: ms[3] };
+ props.allDay = dateSpan0.allDay;
+ return props;
+ }
+
+ var EventDragging = /** @class */ (function (_super) {
+ __extends(EventDragging, _super);
+ function EventDragging(settings) {
+ var _this = _super.call(this, settings) || this;
+ // internal state
+ _this.subjectEl = null;
+ _this.subjectSeg = null; // the seg being selected/dragged
+ _this.isDragging = false;
+ _this.eventRange = null;
+ _this.relevantEvents = null; // the events being dragged
+ _this.receivingContext = null;
+ _this.validMutation = null;
+ _this.mutatedRelevantEvents = null;
+ _this.handlePointerDown = function (ev) {
+ var origTarget = ev.origEvent.target;
+ var _a = _this, component = _a.component, dragging = _a.dragging;
+ var mirror = dragging.mirror;
+ var options = component.context.options;
+ var initialContext = component.context;
+ _this.subjectEl = ev.subjectEl;
+ var subjectSeg = _this.subjectSeg = getElSeg(ev.subjectEl);
+ var eventRange = _this.eventRange = subjectSeg.eventRange;
+ var eventInstanceId = eventRange.instance.instanceId;
+ _this.relevantEvents = getRelevantEvents(initialContext.getCurrentData().eventStore, eventInstanceId);
+ dragging.minDistance = ev.isTouch ? 0 : options.eventDragMinDistance;
+ dragging.delay =
+ // only do a touch delay if touch and this event hasn't been selected yet
+ (ev.isTouch && eventInstanceId !== component.props.eventSelection) ?
+ getComponentTouchDelay(component) :
+ null;
+ if (options.fixedMirrorParent) {
+ mirror.parentNode = options.fixedMirrorParent;
+ }
+ else {
+ mirror.parentNode = elementClosest(origTarget, '.fc');
+ }
+ mirror.revertDuration = options.dragRevertDuration;
+ var isValid = component.isValidSegDownEl(origTarget) &&
+ !elementClosest(origTarget, '.fc-event-resizer'); // NOT on a resizer
+ dragging.setIgnoreMove(!isValid);
+ // disable dragging for elements that are resizable (ie, selectable)
+ // but are not draggable
+ _this.isDragging = isValid &&
+ ev.subjectEl.classList.contains('fc-event-draggable');
+ };
+ _this.handleDragStart = function (ev) {
+ var initialContext = _this.component.context;
+ var eventRange = _this.eventRange;
+ var eventInstanceId = eventRange.instance.instanceId;
+ if (ev.isTouch) {
+ // need to select a different event?
+ if (eventInstanceId !== _this.component.props.eventSelection) {
+ initialContext.dispatch({ type: 'SELECT_EVENT', eventInstanceId: eventInstanceId });
+ }
+ }
+ else {
+ // if now using mouse, but was previous touch interaction, clear selected event
+ initialContext.dispatch({ type: 'UNSELECT_EVENT' });
+ }
+ if (_this.isDragging) {
+ initialContext.calendarApi.unselect(ev); // unselect *date* selection
+ initialContext.emitter.trigger('eventDragStart', {
+ el: _this.subjectEl,
+ event: new EventApi(initialContext, eventRange.def, eventRange.instance),
+ jsEvent: ev.origEvent,
+ view: initialContext.viewApi,
+ });
+ }
+ };
+ _this.handleHitUpdate = function (hit, isFinal) {
+ if (!_this.isDragging) {
+ return;
+ }
+ var relevantEvents = _this.relevantEvents;
+ var initialHit = _this.hitDragging.initialHit;
+ var initialContext = _this.component.context;
+ // states based on new hit
+ var receivingContext = null;
+ var mutation = null;
+ var mutatedRelevantEvents = null;
+ var isInvalid = false;
+ var interaction = {
+ affectedEvents: relevantEvents,
+ mutatedEvents: createEmptyEventStore(),
+ isEvent: true,
+ };
+ if (hit) {
+ receivingContext = hit.context;
+ var receivingOptions = receivingContext.options;
+ if (initialContext === receivingContext ||
+ (receivingOptions.editable && receivingOptions.droppable)) {
+ mutation = computeEventMutation(initialHit, hit, receivingContext.getCurrentData().pluginHooks.eventDragMutationMassagers);
+ if (mutation) {
+ mutatedRelevantEvents = applyMutationToEventStore(relevantEvents, receivingContext.getCurrentData().eventUiBases, mutation, receivingContext);
+ interaction.mutatedEvents = mutatedRelevantEvents;
+ if (!isInteractionValid(interaction, hit.dateProfile, receivingContext)) {
+ isInvalid = true;
+ mutation = null;
+ mutatedRelevantEvents = null;
+ interaction.mutatedEvents = createEmptyEventStore();
+ }
+ }
+ }
+ else {
+ receivingContext = null;
+ }
+ }
+ _this.displayDrag(receivingContext, interaction);
+ if (!isInvalid) {
+ enableCursor();
+ }
+ else {
+ disableCursor();
+ }
+ if (!isFinal) {
+ if (initialContext === receivingContext && // TODO: write test for this
+ isHitsEqual(initialHit, hit)) {
+ mutation = null;
+ }
+ _this.dragging.setMirrorNeedsRevert(!mutation);
+ // render the mirror if no already-rendered mirror
+ // TODO: wish we could somehow wait for dispatch to guarantee render
+ _this.dragging.setMirrorIsVisible(!hit || !getElRoot(_this.subjectEl).querySelector('.fc-event-mirror'));
+ // assign states based on new hit
+ _this.receivingContext = receivingContext;
+ _this.validMutation = mutation;
+ _this.mutatedRelevantEvents = mutatedRelevantEvents;
+ }
+ };
+ _this.handlePointerUp = function () {
+ if (!_this.isDragging) {
+ _this.cleanup(); // because handleDragEnd won't fire
+ }
+ };
+ _this.handleDragEnd = function (ev) {
+ if (_this.isDragging) {
+ var initialContext_1 = _this.component.context;
+ var initialView = initialContext_1.viewApi;
+ var _a = _this, receivingContext_1 = _a.receivingContext, validMutation = _a.validMutation;
+ var eventDef = _this.eventRange.def;
+ var eventInstance = _this.eventRange.instance;
+ var eventApi = new EventApi(initialContext_1, eventDef, eventInstance);
+ var relevantEvents_1 = _this.relevantEvents;
+ var mutatedRelevantEvents_1 = _this.mutatedRelevantEvents;
+ var finalHit = _this.hitDragging.finalHit;
+ _this.clearDrag(); // must happen after revert animation
+ initialContext_1.emitter.trigger('eventDragStop', {
+ el: _this.subjectEl,
+ event: eventApi,
+ jsEvent: ev.origEvent,
+ view: initialView,
+ });
+ if (validMutation) {
+ // dropped within same calendar
+ if (receivingContext_1 === initialContext_1) {
+ var updatedEventApi = new EventApi(initialContext_1, mutatedRelevantEvents_1.defs[eventDef.defId], eventInstance ? mutatedRelevantEvents_1.instances[eventInstance.instanceId] : null);
+ initialContext_1.dispatch({
+ type: 'MERGE_EVENTS',
+ eventStore: mutatedRelevantEvents_1,
+ });
+ var eventChangeArg = {
+ oldEvent: eventApi,
+ event: updatedEventApi,
+ relatedEvents: buildEventApis(mutatedRelevantEvents_1, initialContext_1, eventInstance),
+ revert: function () {
+ initialContext_1.dispatch({
+ type: 'MERGE_EVENTS',
+ eventStore: relevantEvents_1, // the pre-change data
+ });
+ },
+ };
+ var transformed = {};
+ for (var _i = 0, _b = initialContext_1.getCurrentData().pluginHooks.eventDropTransformers; _i < _b.length; _i++) {
+ var transformer = _b[_i];
+ __assign(transformed, transformer(validMutation, initialContext_1));
+ }
+ initialContext_1.emitter.trigger('eventDrop', __assign(__assign(__assign({}, eventChangeArg), transformed), { el: ev.subjectEl, delta: validMutation.datesDelta, jsEvent: ev.origEvent, view: initialView }));
+ initialContext_1.emitter.trigger('eventChange', eventChangeArg);
+ // dropped in different calendar
+ }
+ else if (receivingContext_1) {
+ var eventRemoveArg = {
+ event: eventApi,
+ relatedEvents: buildEventApis(relevantEvents_1, initialContext_1, eventInstance),
+ revert: function () {
+ initialContext_1.dispatch({
+ type: 'MERGE_EVENTS',
+ eventStore: relevantEvents_1,
+ });
+ },
+ };
+ initialContext_1.emitter.trigger('eventLeave', __assign(__assign({}, eventRemoveArg), { draggedEl: ev.subjectEl, view: initialView }));
+ initialContext_1.dispatch({
+ type: 'REMOVE_EVENTS',
+ eventStore: relevantEvents_1,
+ });
+ initialContext_1.emitter.trigger('eventRemove', eventRemoveArg);
+ var addedEventDef = mutatedRelevantEvents_1.defs[eventDef.defId];
+ var addedEventInstance = mutatedRelevantEvents_1.instances[eventInstance.instanceId];
+ var addedEventApi = new EventApi(receivingContext_1, addedEventDef, addedEventInstance);
+ receivingContext_1.dispatch({
+ type: 'MERGE_EVENTS',
+ eventStore: mutatedRelevantEvents_1,
+ });
+ var eventAddArg = {
+ event: addedEventApi,
+ relatedEvents: buildEventApis(mutatedRelevantEvents_1, receivingContext_1, addedEventInstance),
+ revert: function () {
+ receivingContext_1.dispatch({
+ type: 'REMOVE_EVENTS',
+ eventStore: mutatedRelevantEvents_1,
+ });
+ },
+ };
+ receivingContext_1.emitter.trigger('eventAdd', eventAddArg);
+ if (ev.isTouch) {
+ receivingContext_1.dispatch({
+ type: 'SELECT_EVENT',
+ eventInstanceId: eventInstance.instanceId,
+ });
+ }
+ receivingContext_1.emitter.trigger('drop', __assign(__assign({}, buildDatePointApiWithContext(finalHit.dateSpan, receivingContext_1)), { draggedEl: ev.subjectEl, jsEvent: ev.origEvent, view: finalHit.context.viewApi }));
+ receivingContext_1.emitter.trigger('eventReceive', __assign(__assign({}, eventAddArg), { draggedEl: ev.subjectEl, view: finalHit.context.viewApi }));
+ }
+ }
+ else {
+ initialContext_1.emitter.trigger('_noEventDrop');
+ }
+ }
+ _this.cleanup();
+ };
+ var component = _this.component;
+ var options = component.context.options;
+ var dragging = _this.dragging = new FeaturefulElementDragging(settings.el);
+ dragging.pointer.selector = EventDragging.SELECTOR;
+ dragging.touchScrollAllowed = false;
+ dragging.autoScroller.isEnabled = options.dragScroll;
+ var hitDragging = _this.hitDragging = new HitDragging(_this.dragging, interactionSettingsStore);
+ hitDragging.useSubjectCenter = settings.useEventCenter;
+ hitDragging.emitter.on('pointerdown', _this.handlePointerDown);
+ hitDragging.emitter.on('dragstart', _this.handleDragStart);
+ hitDragging.emitter.on('hitupdate', _this.handleHitUpdate);
+ hitDragging.emitter.on('pointerup', _this.handlePointerUp);
+ hitDragging.emitter.on('dragend', _this.handleDragEnd);
+ return _this;
+ }
+ EventDragging.prototype.destroy = function () {
+ this.dragging.destroy();
+ };
+ // render a drag state on the next receivingCalendar
+ EventDragging.prototype.displayDrag = function (nextContext, state) {
+ var initialContext = this.component.context;
+ var prevContext = this.receivingContext;
+ // does the previous calendar need to be cleared?
+ if (prevContext && prevContext !== nextContext) {
+ // does the initial calendar need to be cleared?
+ // if so, don't clear all the way. we still need to to hide the affectedEvents
+ if (prevContext === initialContext) {
+ prevContext.dispatch({
+ type: 'SET_EVENT_DRAG',
+ state: {
+ affectedEvents: state.affectedEvents,
+ mutatedEvents: createEmptyEventStore(),
+ isEvent: true,
+ },
+ });
+ // completely clear the old calendar if it wasn't the initial
+ }
+ else {
+ prevContext.dispatch({ type: 'UNSET_EVENT_DRAG' });
+ }
+ }
+ if (nextContext) {
+ nextContext.dispatch({ type: 'SET_EVENT_DRAG', state: state });
+ }
+ };
+ EventDragging.prototype.clearDrag = function () {
+ var initialCalendar = this.component.context;
+ var receivingContext = this.receivingContext;
+ if (receivingContext) {
+ receivingContext.dispatch({ type: 'UNSET_EVENT_DRAG' });
+ }
+ // the initial calendar might have an dummy drag state from displayDrag
+ if (initialCalendar !== receivingContext) {
+ initialCalendar.dispatch({ type: 'UNSET_EVENT_DRAG' });
+ }
+ };
+ EventDragging.prototype.cleanup = function () {
+ this.subjectSeg = null;
+ this.isDragging = false;
+ this.eventRange = null;
+ this.relevantEvents = null;
+ this.receivingContext = null;
+ this.validMutation = null;
+ this.mutatedRelevantEvents = null;
+ };
+ // TODO: test this in IE11
+ // QUESTION: why do we need it on the resizable???
+ EventDragging.SELECTOR = '.fc-event-draggable, .fc-event-resizable';
+ return EventDragging;
+ }(Interaction));
+ function computeEventMutation(hit0, hit1, massagers) {
+ var dateSpan0 = hit0.dateSpan;
+ var dateSpan1 = hit1.dateSpan;
+ var date0 = dateSpan0.range.start;
+ var date1 = dateSpan1.range.start;
+ var standardProps = {};
+ if (dateSpan0.allDay !== dateSpan1.allDay) {
+ standardProps.allDay = dateSpan1.allDay;
+ standardProps.hasEnd = hit1.context.options.allDayMaintainDuration;
+ if (dateSpan1.allDay) {
+ // means date1 is already start-of-day,
+ // but date0 needs to be converted
+ date0 = startOfDay(date0);
+ }
+ }
+ var delta = diffDates(date0, date1, hit0.context.dateEnv, hit0.componentId === hit1.componentId ?
+ hit0.largeUnit :
+ null);
+ if (delta.milliseconds) { // has hours/minutes/seconds
+ standardProps.allDay = false;
+ }
+ var mutation = {
+ datesDelta: delta,
+ standardProps: standardProps,
+ };
+ for (var _i = 0, massagers_1 = massagers; _i < massagers_1.length; _i++) {
+ var massager = massagers_1[_i];
+ massager(mutation, hit0, hit1);
+ }
+ return mutation;
+ }
+ function getComponentTouchDelay(component) {
+ var options = component.context.options;
+ var delay = options.eventLongPressDelay;
+ if (delay == null) {
+ delay = options.longPressDelay;
+ }
+ return delay;
+ }
+
+ var EventResizing = /** @class */ (function (_super) {
+ __extends(EventResizing, _super);
+ function EventResizing(settings) {
+ var _this = _super.call(this, settings) || this;
+ // internal state
+ _this.draggingSegEl = null;
+ _this.draggingSeg = null; // TODO: rename to resizingSeg? subjectSeg?
+ _this.eventRange = null;
+ _this.relevantEvents = null;
+ _this.validMutation = null;
+ _this.mutatedRelevantEvents = null;
+ _this.handlePointerDown = function (ev) {
+ var component = _this.component;
+ var segEl = _this.querySegEl(ev);
+ var seg = getElSeg(segEl);
+ var eventRange = _this.eventRange = seg.eventRange;
+ _this.dragging.minDistance = component.context.options.eventDragMinDistance;
+ // if touch, need to be working with a selected event
+ _this.dragging.setIgnoreMove(!_this.component.isValidSegDownEl(ev.origEvent.target) ||
+ (ev.isTouch && _this.component.props.eventSelection !== eventRange.instance.instanceId));
+ };
+ _this.handleDragStart = function (ev) {
+ var context = _this.component.context;
+ var eventRange = _this.eventRange;
+ _this.relevantEvents = getRelevantEvents(context.getCurrentData().eventStore, _this.eventRange.instance.instanceId);
+ var segEl = _this.querySegEl(ev);
+ _this.draggingSegEl = segEl;
+ _this.draggingSeg = getElSeg(segEl);
+ context.calendarApi.unselect();
+ context.emitter.trigger('eventResizeStart', {
+ el: segEl,
+ event: new EventApi(context, eventRange.def, eventRange.instance),
+ jsEvent: ev.origEvent,
+ view: context.viewApi,
+ });
+ };
+ _this.handleHitUpdate = function (hit, isFinal, ev) {
+ var context = _this.component.context;
+ var relevantEvents = _this.relevantEvents;
+ var initialHit = _this.hitDragging.initialHit;
+ var eventInstance = _this.eventRange.instance;
+ var mutation = null;
+ var mutatedRelevantEvents = null;
+ var isInvalid = false;
+ var interaction = {
+ affectedEvents: relevantEvents,
+ mutatedEvents: createEmptyEventStore(),
+ isEvent: true,
+ };
+ if (hit) {
+ var disallowed = hit.componentId === initialHit.componentId
+ && _this.isHitComboAllowed
+ && !_this.isHitComboAllowed(initialHit, hit);
+ if (!disallowed) {
+ mutation = computeMutation(initialHit, hit, ev.subjectEl.classList.contains('fc-event-resizer-start'), eventInstance.range);
+ }
+ }
+ if (mutation) {
+ mutatedRelevantEvents = applyMutationToEventStore(relevantEvents, context.getCurrentData().eventUiBases, mutation, context);
+ interaction.mutatedEvents = mutatedRelevantEvents;
+ if (!isInteractionValid(interaction, hit.dateProfile, context)) {
+ isInvalid = true;
+ mutation = null;
+ mutatedRelevantEvents = null;
+ interaction.mutatedEvents = null;
+ }
+ }
+ if (mutatedRelevantEvents) {
+ context.dispatch({
+ type: 'SET_EVENT_RESIZE',
+ state: interaction,
+ });
+ }
+ else {
+ context.dispatch({ type: 'UNSET_EVENT_RESIZE' });
+ }
+ if (!isInvalid) {
+ enableCursor();
+ }
+ else {
+ disableCursor();
+ }
+ if (!isFinal) {
+ if (mutation && isHitsEqual(initialHit, hit)) {
+ mutation = null;
+ }
+ _this.validMutation = mutation;
+ _this.mutatedRelevantEvents = mutatedRelevantEvents;
+ }
+ };
+ _this.handleDragEnd = function (ev) {
+ var context = _this.component.context;
+ var eventDef = _this.eventRange.def;
+ var eventInstance = _this.eventRange.instance;
+ var eventApi = new EventApi(context, eventDef, eventInstance);
+ var relevantEvents = _this.relevantEvents;
+ var mutatedRelevantEvents = _this.mutatedRelevantEvents;
+ context.emitter.trigger('eventResizeStop', {
+ el: _this.draggingSegEl,
+ event: eventApi,
+ jsEvent: ev.origEvent,
+ view: context.viewApi,
+ });
+ if (_this.validMutation) {
+ var updatedEventApi = new EventApi(context, mutatedRelevantEvents.defs[eventDef.defId], eventInstance ? mutatedRelevantEvents.instances[eventInstance.instanceId] : null);
+ context.dispatch({
+ type: 'MERGE_EVENTS',
+ eventStore: mutatedRelevantEvents,
+ });
+ var eventChangeArg = {
+ oldEvent: eventApi,
+ event: updatedEventApi,
+ relatedEvents: buildEventApis(mutatedRelevantEvents, context, eventInstance),
+ revert: function () {
+ context.dispatch({
+ type: 'MERGE_EVENTS',
+ eventStore: relevantEvents, // the pre-change events
+ });
+ },
+ };
+ context.emitter.trigger('eventResize', __assign(__assign({}, eventChangeArg), { el: _this.draggingSegEl, startDelta: _this.validMutation.startDelta || createDuration(0), endDelta: _this.validMutation.endDelta || createDuration(0), jsEvent: ev.origEvent, view: context.viewApi }));
+ context.emitter.trigger('eventChange', eventChangeArg);
+ }
+ else {
+ context.emitter.trigger('_noEventResize');
+ }
+ // reset all internal state
+ _this.draggingSeg = null;
+ _this.relevantEvents = null;
+ _this.validMutation = null;
+ // okay to keep eventInstance around. useful to set it in handlePointerDown
+ };
+ var component = settings.component;
+ var dragging = _this.dragging = new FeaturefulElementDragging(settings.el);
+ dragging.pointer.selector = '.fc-event-resizer';
+ dragging.touchScrollAllowed = false;
+ dragging.autoScroller.isEnabled = component.context.options.dragScroll;
+ var hitDragging = _this.hitDragging = new HitDragging(_this.dragging, interactionSettingsToStore(settings));
+ hitDragging.emitter.on('pointerdown', _this.handlePointerDown);
+ hitDragging.emitter.on('dragstart', _this.handleDragStart);
+ hitDragging.emitter.on('hitupdate', _this.handleHitUpdate);
+ hitDragging.emitter.on('dragend', _this.handleDragEnd);
+ return _this;
+ }
+ EventResizing.prototype.destroy = function () {
+ this.dragging.destroy();
+ };
+ EventResizing.prototype.querySegEl = function (ev) {
+ return elementClosest(ev.subjectEl, '.fc-event');
+ };
+ return EventResizing;
+ }(Interaction));
+ function computeMutation(hit0, hit1, isFromStart, instanceRange) {
+ var dateEnv = hit0.context.dateEnv;
+ var date0 = hit0.dateSpan.range.start;
+ var date1 = hit1.dateSpan.range.start;
+ var delta = diffDates(date0, date1, dateEnv, hit0.largeUnit);
+ if (isFromStart) {
+ if (dateEnv.add(instanceRange.start, delta) < instanceRange.end) {
+ return { startDelta: delta };
+ }
+ }
+ else if (dateEnv.add(instanceRange.end, delta) > instanceRange.start) {
+ return { endDelta: delta };
+ }
+ return null;
+ }
+
+ var UnselectAuto = /** @class */ (function () {
+ function UnselectAuto(context) {
+ var _this = this;
+ this.context = context;
+ this.isRecentPointerDateSelect = false; // wish we could use a selector to detect date selection, but uses hit system
+ this.matchesCancel = false;
+ this.matchesEvent = false;
+ this.onSelect = function (selectInfo) {
+ if (selectInfo.jsEvent) {
+ _this.isRecentPointerDateSelect = true;
+ }
+ };
+ this.onDocumentPointerDown = function (pev) {
+ var unselectCancel = _this.context.options.unselectCancel;
+ var downEl = getEventTargetViaRoot(pev.origEvent);
+ _this.matchesCancel = !!elementClosest(downEl, unselectCancel);
+ _this.matchesEvent = !!elementClosest(downEl, EventDragging.SELECTOR); // interaction started on an event?
+ };
+ this.onDocumentPointerUp = function (pev) {
+ var context = _this.context;
+ var documentPointer = _this.documentPointer;
+ var calendarState = context.getCurrentData();
+ // touch-scrolling should never unfocus any type of selection
+ if (!documentPointer.wasTouchScroll) {
+ if (calendarState.dateSelection && // an existing date selection?
+ !_this.isRecentPointerDateSelect // a new pointer-initiated date selection since last onDocumentPointerUp?
+ ) {
+ var unselectAuto = context.options.unselectAuto;
+ if (unselectAuto && (!unselectAuto || !_this.matchesCancel)) {
+ context.calendarApi.unselect(pev);
+ }
+ }
+ if (calendarState.eventSelection && // an existing event selected?
+ !_this.matchesEvent // interaction DIDN'T start on an event
+ ) {
+ context.dispatch({ type: 'UNSELECT_EVENT' });
+ }
+ }
+ _this.isRecentPointerDateSelect = false;
+ };
+ var documentPointer = this.documentPointer = new PointerDragging(document);
+ documentPointer.shouldIgnoreMove = true;
+ documentPointer.shouldWatchScroll = false;
+ documentPointer.emitter.on('pointerdown', this.onDocumentPointerDown);
+ documentPointer.emitter.on('pointerup', this.onDocumentPointerUp);
+ /*
+ TODO: better way to know about whether there was a selection with the pointer
+ */
+ context.emitter.on('select', this.onSelect);
+ }
+ UnselectAuto.prototype.destroy = function () {
+ this.context.emitter.off('select', this.onSelect);
+ this.documentPointer.destroy();
+ };
+ return UnselectAuto;
+ }());
+
+ var OPTION_REFINERS$5 = {
+ fixedMirrorParent: identity,
+ };
+ var LISTENER_REFINERS$1 = {
+ dateClick: identity,
+ eventDragStart: identity,
+ eventDragStop: identity,
+ eventDrop: identity,
+ eventResizeStart: identity,
+ eventResizeStop: identity,
+ eventResize: identity,
+ drop: identity,
+ eventReceive: identity,
+ eventLeave: identity,
+ };
+
+ /*
+ Given an already instantiated draggable object for one-or-more elements,
+ Interprets any dragging as an attempt to drag an events that lives outside
+ of a calendar onto a calendar.
+ */
+ var ExternalElementDragging = /** @class */ (function () {
+ function ExternalElementDragging(dragging, suppliedDragMeta) {
+ var _this = this;
+ this.receivingContext = null;
+ this.droppableEvent = null; // will exist for all drags, even if create:false
+ this.suppliedDragMeta = null;
+ this.dragMeta = null;
+ this.handleDragStart = function (ev) {
+ _this.dragMeta = _this.buildDragMeta(ev.subjectEl);
+ };
+ this.handleHitUpdate = function (hit, isFinal, ev) {
+ var dragging = _this.hitDragging.dragging;
+ var receivingContext = null;
+ var droppableEvent = null;
+ var isInvalid = false;
+ var interaction = {
+ affectedEvents: createEmptyEventStore(),
+ mutatedEvents: createEmptyEventStore(),
+ isEvent: _this.dragMeta.create,
+ };
+ if (hit) {
+ receivingContext = hit.context;
+ if (_this.canDropElOnCalendar(ev.subjectEl, receivingContext)) {
+ droppableEvent = computeEventForDateSpan(hit.dateSpan, _this.dragMeta, receivingContext);
+ interaction.mutatedEvents = eventTupleToStore(droppableEvent);
+ isInvalid = !isInteractionValid(interaction, hit.dateProfile, receivingContext);
+ if (isInvalid) {
+ interaction.mutatedEvents = createEmptyEventStore();
+ droppableEvent = null;
+ }
+ }
+ }
+ _this.displayDrag(receivingContext, interaction);
+ // show mirror if no already-rendered mirror element OR if we are shutting down the mirror (?)
+ // TODO: wish we could somehow wait for dispatch to guarantee render
+ dragging.setMirrorIsVisible(isFinal || !droppableEvent || !document.querySelector('.fc-event-mirror'));
+ if (!isInvalid) {
+ enableCursor();
+ }
+ else {
+ disableCursor();
+ }
+ if (!isFinal) {
+ dragging.setMirrorNeedsRevert(!droppableEvent);
+ _this.receivingContext = receivingContext;
+ _this.droppableEvent = droppableEvent;
+ }
+ };
+ this.handleDragEnd = function (pev) {
+ var _a = _this, receivingContext = _a.receivingContext, droppableEvent = _a.droppableEvent;
+ _this.clearDrag();
+ if (receivingContext && droppableEvent) {
+ var finalHit = _this.hitDragging.finalHit;
+ var finalView = finalHit.context.viewApi;
+ var dragMeta = _this.dragMeta;
+ receivingContext.emitter.trigger('drop', __assign(__assign({}, buildDatePointApiWithContext(finalHit.dateSpan, receivingContext)), { draggedEl: pev.subjectEl, jsEvent: pev.origEvent, view: finalView }));
+ if (dragMeta.create) {
+ var addingEvents_1 = eventTupleToStore(droppableEvent);
+ receivingContext.dispatch({
+ type: 'MERGE_EVENTS',
+ eventStore: addingEvents_1,
+ });
+ if (pev.isTouch) {
+ receivingContext.dispatch({
+ type: 'SELECT_EVENT',
+ eventInstanceId: droppableEvent.instance.instanceId,
+ });
+ }
+ // signal that an external event landed
+ receivingContext.emitter.trigger('eventReceive', {
+ event: new EventApi(receivingContext, droppableEvent.def, droppableEvent.instance),
+ relatedEvents: [],
+ revert: function () {
+ receivingContext.dispatch({
+ type: 'REMOVE_EVENTS',
+ eventStore: addingEvents_1,
+ });
+ },
+ draggedEl: pev.subjectEl,
+ view: finalView,
+ });
+ }
+ }
+ _this.receivingContext = null;
+ _this.droppableEvent = null;
+ };
+ var hitDragging = this.hitDragging = new HitDragging(dragging, interactionSettingsStore);
+ hitDragging.requireInitial = false; // will start outside of a component
+ hitDragging.emitter.on('dragstart', this.handleDragStart);
+ hitDragging.emitter.on('hitupdate', this.handleHitUpdate);
+ hitDragging.emitter.on('dragend', this.handleDragEnd);
+ this.suppliedDragMeta = suppliedDragMeta;
+ }
+ ExternalElementDragging.prototype.buildDragMeta = function (subjectEl) {
+ if (typeof this.suppliedDragMeta === 'object') {
+ return parseDragMeta(this.suppliedDragMeta);
+ }
+ if (typeof this.suppliedDragMeta === 'function') {
+ return parseDragMeta(this.suppliedDragMeta(subjectEl));
+ }
+ return getDragMetaFromEl(subjectEl);
+ };
+ ExternalElementDragging.prototype.displayDrag = function (nextContext, state) {
+ var prevContext = this.receivingContext;
+ if (prevContext && prevContext !== nextContext) {
+ prevContext.dispatch({ type: 'UNSET_EVENT_DRAG' });
+ }
+ if (nextContext) {
+ nextContext.dispatch({ type: 'SET_EVENT_DRAG', state: state });
+ }
+ };
+ ExternalElementDragging.prototype.clearDrag = function () {
+ if (this.receivingContext) {
+ this.receivingContext.dispatch({ type: 'UNSET_EVENT_DRAG' });
+ }
+ };
+ ExternalElementDragging.prototype.canDropElOnCalendar = function (el, receivingContext) {
+ var dropAccept = receivingContext.options.dropAccept;
+ if (typeof dropAccept === 'function') {
+ return dropAccept.call(receivingContext.calendarApi, el);
+ }
+ if (typeof dropAccept === 'string' && dropAccept) {
+ return Boolean(elementMatches(el, dropAccept));
+ }
+ return true;
+ };
+ return ExternalElementDragging;
+ }());
+ // Utils for computing event store from the DragMeta
+ // ----------------------------------------------------------------------------------------------------
+ function computeEventForDateSpan(dateSpan, dragMeta, context) {
+ var defProps = __assign({}, dragMeta.leftoverProps);
+ for (var _i = 0, _a = context.pluginHooks.externalDefTransforms; _i < _a.length; _i++) {
+ var transform = _a[_i];
+ __assign(defProps, transform(dateSpan, dragMeta));
+ }
+ var _b = refineEventDef(defProps, context), refined = _b.refined, extra = _b.extra;
+ var def = parseEventDef(refined, extra, dragMeta.sourceId, dateSpan.allDay, context.options.forceEventDuration || Boolean(dragMeta.duration), // hasEnd
+ context);
+ var start = dateSpan.range.start;
+ // only rely on time info if drop zone is all-day,
+ // otherwise, we already know the time
+ if (dateSpan.allDay && dragMeta.startTime) {
+ start = context.dateEnv.add(start, dragMeta.startTime);
+ }
+ var end = dragMeta.duration ?
+ context.dateEnv.add(start, dragMeta.duration) :
+ getDefaultEventEnd(dateSpan.allDay, start, context);
+ var instance = createEventInstance(def.defId, { start: start, end: end });
+ return { def: def, instance: instance };
+ }
+ // Utils for extracting data from element
+ // ----------------------------------------------------------------------------------------------------
+ function getDragMetaFromEl(el) {
+ var str = getEmbeddedElData(el, 'event');
+ var obj = str ?
+ JSON.parse(str) :
+ { create: false }; // if no embedded data, assume no event creation
+ return parseDragMeta(obj);
+ }
+ config.dataAttrPrefix = '';
+ function getEmbeddedElData(el, name) {
+ var prefix = config.dataAttrPrefix;
+ var prefixedName = (prefix ? prefix + '-' : '') + name;
+ return el.getAttribute('data-' + prefixedName) || '';
+ }
+
+ /*
+ Makes an element (that is *external* to any calendar) draggable.
+ Can pass in data that determines how an event will be created when dropped onto a calendar.
+ Leverages FullCalendar's internal drag-n-drop functionality WITHOUT a third-party drag system.
+ */
+ var ExternalDraggable = /** @class */ (function () {
+ function ExternalDraggable(el, settings) {
+ var _this = this;
+ if (settings === void 0) { settings = {}; }
+ this.handlePointerDown = function (ev) {
+ var dragging = _this.dragging;
+ var _a = _this.settings, minDistance = _a.minDistance, longPressDelay = _a.longPressDelay;
+ dragging.minDistance =
+ minDistance != null ?
+ minDistance :
+ (ev.isTouch ? 0 : BASE_OPTION_DEFAULTS.eventDragMinDistance);
+ dragging.delay =
+ ev.isTouch ? // TODO: eventually read eventLongPressDelay instead vvv
+ (longPressDelay != null ? longPressDelay : BASE_OPTION_DEFAULTS.longPressDelay) :
+ 0;
+ };
+ this.handleDragStart = function (ev) {
+ if (ev.isTouch &&
+ _this.dragging.delay &&
+ ev.subjectEl.classList.contains('fc-event')) {
+ _this.dragging.mirror.getMirrorEl().classList.add('fc-event-selected');
+ }
+ };
+ this.settings = settings;
+ var dragging = this.dragging = new FeaturefulElementDragging(el);
+ dragging.touchScrollAllowed = false;
+ if (settings.itemSelector != null) {
+ dragging.pointer.selector = settings.itemSelector;
+ }
+ if (settings.appendTo != null) {
+ dragging.mirror.parentNode = settings.appendTo; // TODO: write tests
+ }
+ dragging.emitter.on('pointerdown', this.handlePointerDown);
+ dragging.emitter.on('dragstart', this.handleDragStart);
+ new ExternalElementDragging(dragging, settings.eventData); // eslint-disable-line no-new
+ }
+ ExternalDraggable.prototype.destroy = function () {
+ this.dragging.destroy();
+ };
+ return ExternalDraggable;
+ }());
+
+ /*
+ Detects when a *THIRD-PARTY* drag-n-drop system interacts with elements.
+ The third-party system is responsible for drawing the visuals effects of the drag.
+ This class simply monitors for pointer movements and fires events.
+ It also has the ability to hide the moving element (the "mirror") during the drag.
+ */
+ var InferredElementDragging = /** @class */ (function (_super) {
+ __extends(InferredElementDragging, _super);
+ function InferredElementDragging(containerEl) {
+ var _this = _super.call(this, containerEl) || this;
+ _this.shouldIgnoreMove = false;
+ _this.mirrorSelector = '';
+ _this.currentMirrorEl = null;
+ _this.handlePointerDown = function (ev) {
+ _this.emitter.trigger('pointerdown', ev);
+ if (!_this.shouldIgnoreMove) {
+ // fire dragstart right away. does not support delay or min-distance
+ _this.emitter.trigger('dragstart', ev);
+ }
+ };
+ _this.handlePointerMove = function (ev) {
+ if (!_this.shouldIgnoreMove) {
+ _this.emitter.trigger('dragmove', ev);
+ }
+ };
+ _this.handlePointerUp = function (ev) {
+ _this.emitter.trigger('pointerup', ev);
+ if (!_this.shouldIgnoreMove) {
+ // fire dragend right away. does not support a revert animation
+ _this.emitter.trigger('dragend', ev);
+ }
+ };
+ var pointer = _this.pointer = new PointerDragging(containerEl);
+ pointer.emitter.on('pointerdown', _this.handlePointerDown);
+ pointer.emitter.on('pointermove', _this.handlePointerMove);
+ pointer.emitter.on('pointerup', _this.handlePointerUp);
+ return _this;
+ }
+ InferredElementDragging.prototype.destroy = function () {
+ this.pointer.destroy();
+ };
+ InferredElementDragging.prototype.setIgnoreMove = function (bool) {
+ this.shouldIgnoreMove = bool;
+ };
+ InferredElementDragging.prototype.setMirrorIsVisible = function (bool) {
+ if (bool) {
+ // restore a previously hidden element.
+ // use the reference in case the selector class has already been removed.
+ if (this.currentMirrorEl) {
+ this.currentMirrorEl.style.visibility = '';
+ this.currentMirrorEl = null;
+ }
+ }
+ else {
+ var mirrorEl = this.mirrorSelector
+ // TODO: somehow query FullCalendars WITHIN shadow-roots
+ ? document.querySelector(this.mirrorSelector)
+ : null;
+ if (mirrorEl) {
+ this.currentMirrorEl = mirrorEl;
+ mirrorEl.style.visibility = 'hidden';
+ }
+ }
+ };
+ return InferredElementDragging;
+ }(ElementDragging));
+
+ /*
+ Bridges third-party drag-n-drop systems with FullCalendar.
+ Must be instantiated and destroyed by caller.
+ */
+ var ThirdPartyDraggable = /** @class */ (function () {
+ function ThirdPartyDraggable(containerOrSettings, settings) {
+ var containerEl = document;
+ if (
+ // wish we could just test instanceof EventTarget, but doesn't work in IE11
+ containerOrSettings === document ||
+ containerOrSettings instanceof Element) {
+ containerEl = containerOrSettings;
+ settings = settings || {};
+ }
+ else {
+ settings = (containerOrSettings || {});
+ }
+ var dragging = this.dragging = new InferredElementDragging(containerEl);
+ if (typeof settings.itemSelector === 'string') {
+ dragging.pointer.selector = settings.itemSelector;
+ }
+ else if (containerEl === document) {
+ dragging.pointer.selector = '[data-event]';
+ }
+ if (typeof settings.mirrorSelector === 'string') {
+ dragging.mirrorSelector = settings.mirrorSelector;
+ }
+ new ExternalElementDragging(dragging, settings.eventData); // eslint-disable-line no-new
+ }
+ ThirdPartyDraggable.prototype.destroy = function () {
+ this.dragging.destroy();
+ };
+ return ThirdPartyDraggable;
+ }());
+
+ var interactionPlugin = createPlugin({
+ componentInteractions: [DateClicking, DateSelecting, EventDragging, EventResizing],
+ calendarInteractions: [UnselectAuto],
+ elementDraggingImpl: FeaturefulElementDragging,
+ optionRefiners: OPTION_REFINERS$5,
+ listenerRefiners: LISTENER_REFINERS$1,
+ });
+
+ /* An abstract class for the daygrid views, as well as month view. Renders one or more rows of day cells.
+ ----------------------------------------------------------------------------------------------------------------------*/
+ // It is a manager for a Table subcomponent, which does most of the heavy lifting.
+ // It is responsible for managing width/height.
+ var TableView = /** @class */ (function (_super) {
+ __extends(TableView, _super);
+ function TableView() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.headerElRef = createRef();
+ return _this;
+ }
+ TableView.prototype.renderSimpleLayout = function (headerRowContent, bodyContent) {
+ var _a = this, props = _a.props, context = _a.context;
+ var sections = [];
+ var stickyHeaderDates = getStickyHeaderDates(context.options);
+ if (headerRowContent) {
+ sections.push({
+ type: 'header',
+ key: 'header',
+ isSticky: stickyHeaderDates,
+ chunk: {
+ elRef: this.headerElRef,
+ tableClassName: 'fc-col-header',
+ rowContent: headerRowContent,
+ },
+ });
+ }
+ sections.push({
+ type: 'body',
+ key: 'body',
+ liquid: true,
+ chunk: { content: bodyContent },
+ });
+ return (createElement(ViewRoot, { viewSpec: context.viewSpec }, function (rootElRef, classNames) { return (createElement("div", { ref: rootElRef, className: ['fc-daygrid'].concat(classNames).join(' ') },
+ createElement(SimpleScrollGrid, { liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: props.forPrint, cols: [] /* TODO: make optional? */, sections: sections }))); }));
+ };
+ TableView.prototype.renderHScrollLayout = function (headerRowContent, bodyContent, colCnt, dayMinWidth) {
+ var ScrollGrid = this.context.pluginHooks.scrollGridImpl;
+ if (!ScrollGrid) {
+ throw new Error('No ScrollGrid implementation');
+ }
+ var _a = this, props = _a.props, context = _a.context;
+ var stickyHeaderDates = !props.forPrint && getStickyHeaderDates(context.options);
+ var stickyFooterScrollbar = !props.forPrint && getStickyFooterScrollbar(context.options);
+ var sections = [];
+ if (headerRowContent) {
+ sections.push({
+ type: 'header',
+ key: 'header',
+ isSticky: stickyHeaderDates,
+ chunks: [{
+ key: 'main',
+ elRef: this.headerElRef,
+ tableClassName: 'fc-col-header',
+ rowContent: headerRowContent,
+ }],
+ });
+ }
+ sections.push({
+ type: 'body',
+ key: 'body',
+ liquid: true,
+ chunks: [{
+ key: 'main',
+ content: bodyContent,
+ }],
+ });
+ if (stickyFooterScrollbar) {
+ sections.push({
+ type: 'footer',
+ key: 'footer',
+ isSticky: true,
+ chunks: [{
+ key: 'main',
+ content: renderScrollShim,
+ }],
+ });
+ }
+ return (createElement(ViewRoot, { viewSpec: context.viewSpec }, function (rootElRef, classNames) { return (createElement("div", { ref: rootElRef, className: ['fc-daygrid'].concat(classNames).join(' ') },
+ createElement(ScrollGrid, { liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: props.forPrint, colGroups: [{ cols: [{ span: colCnt, minWidth: dayMinWidth }] }], sections: sections }))); }));
+ };
+ return TableView;
+ }(DateComponent));
+
+ function splitSegsByRow(segs, rowCnt) {
+ var byRow = [];
+ for (var i = 0; i < rowCnt; i += 1) {
+ byRow[i] = [];
+ }
+ for (var _i = 0, segs_1 = segs; _i < segs_1.length; _i++) {
+ var seg = segs_1[_i];
+ byRow[seg.row].push(seg);
+ }
+ return byRow;
+ }
+ function splitSegsByFirstCol(segs, colCnt) {
+ var byCol = [];
+ for (var i = 0; i < colCnt; i += 1) {
+ byCol[i] = [];
+ }
+ for (var _i = 0, segs_2 = segs; _i < segs_2.length; _i++) {
+ var seg = segs_2[_i];
+ byCol[seg.firstCol].push(seg);
+ }
+ return byCol;
+ }
+ function splitInteractionByRow(ui, rowCnt) {
+ var byRow = [];
+ if (!ui) {
+ for (var i = 0; i < rowCnt; i += 1) {
+ byRow[i] = null;
+ }
+ }
+ else {
+ for (var i = 0; i < rowCnt; i += 1) {
+ byRow[i] = {
+ affectedInstances: ui.affectedInstances,
+ isEvent: ui.isEvent,
+ segs: [],
+ };
+ }
+ for (var _i = 0, _a = ui.segs; _i < _a.length; _i++) {
+ var seg = _a[_i];
+ byRow[seg.row].segs.push(seg);
+ }
+ }
+ return byRow;
+ }
+
+ var TableCellTop = /** @class */ (function (_super) {
+ __extends(TableCellTop, _super);
+ function TableCellTop() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TableCellTop.prototype.render = function () {
+ var props = this.props;
+ var navLinkAttrs = buildNavLinkAttrs(this.context, props.date);
+ return (createElement(DayCellContent, { date: props.date, dateProfile: props.dateProfile, todayRange: props.todayRange, showDayNumber: props.showDayNumber, extraHookProps: props.extraHookProps, defaultContent: renderTopInner }, function (innerElRef, innerContent) { return ((innerContent || props.forceDayTop) && (createElement("div", { className: "fc-daygrid-day-top", ref: innerElRef },
+ createElement("a", __assign({ id: props.dayNumberId, className: "fc-daygrid-day-number" }, navLinkAttrs), innerContent || createElement(Fragment, null, "\u00A0"))))); }));
+ };
+ return TableCellTop;
+ }(BaseComponent));
+ function renderTopInner(props) {
+ return props.dayNumberText;
+ }
+
+ var DEFAULT_TABLE_EVENT_TIME_FORMAT = createFormatter({
+ hour: 'numeric',
+ minute: '2-digit',
+ omitZeroMinute: true,
+ meridiem: 'narrow',
+ });
+ function hasListItemDisplay(seg) {
+ var display = seg.eventRange.ui.display;
+ return display === 'list-item' || (display === 'auto' &&
+ !seg.eventRange.def.allDay &&
+ seg.firstCol === seg.lastCol && // can't be multi-day
+ seg.isStart && // "
+ seg.isEnd // "
+ );
+ }
+
+ var TableBlockEvent = /** @class */ (function (_super) {
+ __extends(TableBlockEvent, _super);
+ function TableBlockEvent() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TableBlockEvent.prototype.render = function () {
+ var props = this.props;
+ return (createElement(StandardEvent, __assign({}, props, { extraClassNames: ['fc-daygrid-event', 'fc-daygrid-block-event', 'fc-h-event'], defaultTimeFormat: DEFAULT_TABLE_EVENT_TIME_FORMAT, defaultDisplayEventEnd: props.defaultDisplayEventEnd, disableResizing: !props.seg.eventRange.def.allDay })));
+ };
+ return TableBlockEvent;
+ }(BaseComponent));
+
+ var TableListItemEvent = /** @class */ (function (_super) {
+ __extends(TableListItemEvent, _super);
+ function TableListItemEvent() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TableListItemEvent.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var timeFormat = context.options.eventTimeFormat || DEFAULT_TABLE_EVENT_TIME_FORMAT;
+ var timeText = buildSegTimeText(props.seg, timeFormat, context, true, props.defaultDisplayEventEnd);
+ return (createElement(EventRoot, { seg: props.seg, timeText: timeText, defaultContent: renderInnerContent$4, isDragging: props.isDragging, isResizing: false, isDateSelecting: false, isSelected: props.isSelected, isPast: props.isPast, isFuture: props.isFuture, isToday: props.isToday }, function (rootElRef, classNames, innerElRef, innerContent) { return ( // we don't use styles!
+ createElement("a", __assign({ className: ['fc-daygrid-event', 'fc-daygrid-dot-event'].concat(classNames).join(' '), ref: rootElRef }, getSegAnchorAttrs(props.seg, context)), innerContent)); }));
+ };
+ return TableListItemEvent;
+ }(BaseComponent));
+ function renderInnerContent$4(innerProps) {
+ return (createElement(Fragment, null,
+ createElement("div", { className: "fc-daygrid-event-dot", style: { borderColor: innerProps.borderColor || innerProps.backgroundColor } }),
+ innerProps.timeText && (createElement("div", { className: "fc-event-time" }, innerProps.timeText)),
+ createElement("div", { className: "fc-event-title" }, innerProps.event.title || createElement(Fragment, null, "\u00A0"))));
+ }
+
+ var TableCellMoreLink = /** @class */ (function (_super) {
+ __extends(TableCellMoreLink, _super);
+ function TableCellMoreLink() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.compileSegs = memoize(compileSegs);
+ return _this;
+ }
+ TableCellMoreLink.prototype.render = function () {
+ var props = this.props;
+ var _a = this.compileSegs(props.singlePlacements), allSegs = _a.allSegs, invisibleSegs = _a.invisibleSegs;
+ return (createElement(MoreLinkRoot, { dateProfile: props.dateProfile, todayRange: props.todayRange, allDayDate: props.allDayDate, moreCnt: props.moreCnt, allSegs: allSegs, hiddenSegs: invisibleSegs, alignmentElRef: props.alignmentElRef, alignGridTop: props.alignGridTop, extraDateSpan: props.extraDateSpan, popoverContent: function () {
+ var isForcedInvisible = (props.eventDrag ? props.eventDrag.affectedInstances : null) ||
+ (props.eventResize ? props.eventResize.affectedInstances : null) ||
+ {};
+ return (createElement(Fragment, null, allSegs.map(function (seg) {
+ var instanceId = seg.eventRange.instance.instanceId;
+ return (createElement("div", { className: "fc-daygrid-event-harness", key: instanceId, style: {
+ visibility: isForcedInvisible[instanceId] ? 'hidden' : '',
+ } }, hasListItemDisplay(seg) ? (createElement(TableListItemEvent, __assign({ seg: seg, isDragging: false, isSelected: instanceId === props.eventSelection, defaultDisplayEventEnd: false }, getSegMeta(seg, props.todayRange)))) : (createElement(TableBlockEvent, __assign({ seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: instanceId === props.eventSelection, defaultDisplayEventEnd: false }, getSegMeta(seg, props.todayRange))))));
+ })));
+ } }, function (rootElRef, classNames, innerElRef, innerContent, handleClick, title, isExpanded, popoverId) { return (createElement("a", __assign({ ref: rootElRef, className: ['fc-daygrid-more-link'].concat(classNames).join(' '), title: title, "aria-expanded": isExpanded, "aria-controls": popoverId }, createAriaClickAttrs(handleClick)), innerContent)); }));
+ };
+ return TableCellMoreLink;
+ }(BaseComponent));
+ function compileSegs(singlePlacements) {
+ var allSegs = [];
+ var invisibleSegs = [];
+ for (var _i = 0, singlePlacements_1 = singlePlacements; _i < singlePlacements_1.length; _i++) {
+ var placement = singlePlacements_1[_i];
+ allSegs.push(placement.seg);
+ if (!placement.isVisible) {
+ invisibleSegs.push(placement.seg);
+ }
+ }
+ return { allSegs: allSegs, invisibleSegs: invisibleSegs };
+ }
+
+ var DEFAULT_WEEK_NUM_FORMAT$1 = createFormatter({ week: 'narrow' });
+ var TableCell = /** @class */ (function (_super) {
+ __extends(TableCell, _super);
+ function TableCell() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.rootElRef = createRef();
+ _this.state = {
+ dayNumberId: getUniqueDomId(),
+ };
+ _this.handleRootEl = function (el) {
+ setRef(_this.rootElRef, el);
+ setRef(_this.props.elRef, el);
+ };
+ return _this;
+ }
+ TableCell.prototype.render = function () {
+ var _a = this, context = _a.context, props = _a.props, state = _a.state, rootElRef = _a.rootElRef;
+ var date = props.date, dateProfile = props.dateProfile;
+ var navLinkAttrs = buildNavLinkAttrs(context, date, 'week');
+ return (createElement(DayCellRoot, { date: date, dateProfile: dateProfile, todayRange: props.todayRange, showDayNumber: props.showDayNumber, extraHookProps: props.extraHookProps, elRef: this.handleRootEl }, function (dayElRef, dayClassNames, rootDataAttrs, isDisabled) { return (createElement("td", __assign({ ref: dayElRef, role: "gridcell", className: ['fc-daygrid-day'].concat(dayClassNames, props.extraClassNames || []).join(' ') }, rootDataAttrs, props.extraDataAttrs, (props.showDayNumber ? { 'aria-labelledby': state.dayNumberId } : {})),
+ createElement("div", { className: "fc-daygrid-day-frame fc-scrollgrid-sync-inner", ref: props.innerElRef /* different from hook system! RENAME */ },
+ props.showWeekNumber && (createElement(WeekNumberRoot, { date: date, defaultFormat: DEFAULT_WEEK_NUM_FORMAT$1 }, function (weekElRef, weekClassNames, innerElRef, innerContent) { return (createElement("a", __assign({ ref: weekElRef, className: ['fc-daygrid-week-number'].concat(weekClassNames).join(' ') }, navLinkAttrs), innerContent)); })),
+ !isDisabled && (createElement(TableCellTop, { date: date, dateProfile: dateProfile, showDayNumber: props.showDayNumber, dayNumberId: state.dayNumberId, forceDayTop: props.forceDayTop, todayRange: props.todayRange, extraHookProps: props.extraHookProps })),
+ createElement("div", { className: "fc-daygrid-day-events", ref: props.fgContentElRef },
+ props.fgContent,
+ createElement("div", { className: "fc-daygrid-day-bottom", style: { marginTop: props.moreMarginTop } },
+ createElement(TableCellMoreLink, { allDayDate: date, singlePlacements: props.singlePlacements, moreCnt: props.moreCnt, alignmentElRef: rootElRef, alignGridTop: !props.showDayNumber, extraDateSpan: props.extraDateSpan, dateProfile: props.dateProfile, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, todayRange: props.todayRange }))),
+ createElement("div", { className: "fc-daygrid-day-bg" }, props.bgContent)))); }));
+ };
+ return TableCell;
+ }(DateComponent));
+
+ function computeFgSegPlacement(segs, // assumed already sorted
+ dayMaxEvents, dayMaxEventRows, strictOrder, eventInstanceHeights, maxContentHeight, cells) {
+ var hierarchy = new DayGridSegHierarchy();
+ hierarchy.allowReslicing = true;
+ hierarchy.strictOrder = strictOrder;
+ if (dayMaxEvents === true || dayMaxEventRows === true) {
+ hierarchy.maxCoord = maxContentHeight;
+ hierarchy.hiddenConsumes = true;
+ }
+ else if (typeof dayMaxEvents === 'number') {
+ hierarchy.maxStackCnt = dayMaxEvents;
+ }
+ else if (typeof dayMaxEventRows === 'number') {
+ hierarchy.maxStackCnt = dayMaxEventRows;
+ hierarchy.hiddenConsumes = true;
+ }
+ // create segInputs only for segs with known heights
+ var segInputs = [];
+ var unknownHeightSegs = [];
+ for (var i = 0; i < segs.length; i += 1) {
+ var seg = segs[i];
+ var instanceId = seg.eventRange.instance.instanceId;
+ var eventHeight = eventInstanceHeights[instanceId];
+ if (eventHeight != null) {
+ segInputs.push({
+ index: i,
+ thickness: eventHeight,
+ span: {
+ start: seg.firstCol,
+ end: seg.lastCol + 1,
+ },
+ });
+ }
+ else {
+ unknownHeightSegs.push(seg);
+ }
+ }
+ var hiddenEntries = hierarchy.addSegs(segInputs);
+ var segRects = hierarchy.toRects();
+ var _a = placeRects(segRects, segs, cells), singleColPlacements = _a.singleColPlacements, multiColPlacements = _a.multiColPlacements, leftoverMargins = _a.leftoverMargins;
+ var moreCnts = [];
+ var moreMarginTops = [];
+ // add segs with unknown heights
+ for (var _i = 0, unknownHeightSegs_1 = unknownHeightSegs; _i < unknownHeightSegs_1.length; _i++) {
+ var seg = unknownHeightSegs_1[_i];
+ multiColPlacements[seg.firstCol].push({
+ seg: seg,
+ isVisible: false,
+ isAbsolute: true,
+ absoluteTop: 0,
+ marginTop: 0,
+ });
+ for (var col = seg.firstCol; col <= seg.lastCol; col += 1) {
+ singleColPlacements[col].push({
+ seg: resliceSeg(seg, col, col + 1, cells),
+ isVisible: false,
+ isAbsolute: false,
+ absoluteTop: 0,
+ marginTop: 0,
+ });
+ }
+ }
+ // add the hidden entries
+ for (var col = 0; col < cells.length; col += 1) {
+ moreCnts.push(0);
+ }
+ for (var _b = 0, hiddenEntries_1 = hiddenEntries; _b < hiddenEntries_1.length; _b++) {
+ var hiddenEntry = hiddenEntries_1[_b];
+ var seg = segs[hiddenEntry.index];
+ var hiddenSpan = hiddenEntry.span;
+ multiColPlacements[hiddenSpan.start].push({
+ seg: resliceSeg(seg, hiddenSpan.start, hiddenSpan.end, cells),
+ isVisible: false,
+ isAbsolute: true,
+ absoluteTop: 0,
+ marginTop: 0,
+ });
+ for (var col = hiddenSpan.start; col < hiddenSpan.end; col += 1) {
+ moreCnts[col] += 1;
+ singleColPlacements[col].push({
+ seg: resliceSeg(seg, col, col + 1, cells),
+ isVisible: false,
+ isAbsolute: false,
+ absoluteTop: 0,
+ marginTop: 0,
+ });
+ }
+ }
+ // deal with leftover margins
+ for (var col = 0; col < cells.length; col += 1) {
+ moreMarginTops.push(leftoverMargins[col]);
+ }
+ return { singleColPlacements: singleColPlacements, multiColPlacements: multiColPlacements, moreCnts: moreCnts, moreMarginTops: moreMarginTops };
+ }
+ // rects ordered by top coord, then left
+ function placeRects(allRects, segs, cells) {
+ var rectsByEachCol = groupRectsByEachCol(allRects, cells.length);
+ var singleColPlacements = [];
+ var multiColPlacements = [];
+ var leftoverMargins = [];
+ for (var col = 0; col < cells.length; col += 1) {
+ var rects = rectsByEachCol[col];
+ // compute all static segs in singlePlacements
+ var singlePlacements = [];
+ var currentHeight = 0;
+ var currentMarginTop = 0;
+ for (var _i = 0, rects_1 = rects; _i < rects_1.length; _i++) {
+ var rect = rects_1[_i];
+ var seg = segs[rect.index];
+ singlePlacements.push({
+ seg: resliceSeg(seg, col, col + 1, cells),
+ isVisible: true,
+ isAbsolute: false,
+ absoluteTop: rect.levelCoord,
+ marginTop: rect.levelCoord - currentHeight,
+ });
+ currentHeight = rect.levelCoord + rect.thickness;
+ }
+ // compute mixed static/absolute segs in multiPlacements
+ var multiPlacements = [];
+ currentHeight = 0;
+ currentMarginTop = 0;
+ for (var _a = 0, rects_2 = rects; _a < rects_2.length; _a++) {
+ var rect = rects_2[_a];
+ var seg = segs[rect.index];
+ var isAbsolute = rect.span.end - rect.span.start > 1; // multi-column?
+ var isFirstCol = rect.span.start === col;
+ currentMarginTop += rect.levelCoord - currentHeight; // amount of space since bottom of previous seg
+ currentHeight = rect.levelCoord + rect.thickness; // height will now be bottom of current seg
+ if (isAbsolute) {
+ currentMarginTop += rect.thickness;
+ if (isFirstCol) {
+ multiPlacements.push({
+ seg: resliceSeg(seg, rect.span.start, rect.span.end, cells),
+ isVisible: true,
+ isAbsolute: true,
+ absoluteTop: rect.levelCoord,
+ marginTop: 0,
+ });
+ }
+ }
+ else if (isFirstCol) {
+ multiPlacements.push({
+ seg: resliceSeg(seg, rect.span.start, rect.span.end, cells),
+ isVisible: true,
+ isAbsolute: false,
+ absoluteTop: rect.levelCoord,
+ marginTop: currentMarginTop, // claim the margin
+ });
+ currentMarginTop = 0;
+ }
+ }
+ singleColPlacements.push(singlePlacements);
+ multiColPlacements.push(multiPlacements);
+ leftoverMargins.push(currentMarginTop);
+ }
+ return { singleColPlacements: singleColPlacements, multiColPlacements: multiColPlacements, leftoverMargins: leftoverMargins };
+ }
+ function groupRectsByEachCol(rects, colCnt) {
+ var rectsByEachCol = [];
+ for (var col = 0; col < colCnt; col += 1) {
+ rectsByEachCol.push([]);
+ }
+ for (var _i = 0, rects_3 = rects; _i < rects_3.length; _i++) {
+ var rect = rects_3[_i];
+ for (var col = rect.span.start; col < rect.span.end; col += 1) {
+ rectsByEachCol[col].push(rect);
+ }
+ }
+ return rectsByEachCol;
+ }
+ function resliceSeg(seg, spanStart, spanEnd, cells) {
+ if (seg.firstCol === spanStart && seg.lastCol === spanEnd - 1) {
+ return seg;
+ }
+ var eventRange = seg.eventRange;
+ var origRange = eventRange.range;
+ var slicedRange = intersectRanges(origRange, {
+ start: cells[spanStart].date,
+ end: addDays(cells[spanEnd - 1].date, 1),
+ });
+ return __assign(__assign({}, seg), { firstCol: spanStart, lastCol: spanEnd - 1, eventRange: {
+ def: eventRange.def,
+ ui: __assign(__assign({}, eventRange.ui), { durationEditable: false }),
+ instance: eventRange.instance,
+ range: slicedRange,
+ }, isStart: seg.isStart && slicedRange.start.valueOf() === origRange.start.valueOf(), isEnd: seg.isEnd && slicedRange.end.valueOf() === origRange.end.valueOf() });
+ }
+ var DayGridSegHierarchy = /** @class */ (function (_super) {
+ __extends(DayGridSegHierarchy, _super);
+ function DayGridSegHierarchy() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ // config
+ _this.hiddenConsumes = false;
+ // allows us to keep hidden entries in the hierarchy so they take up space
+ _this.forceHidden = {};
+ return _this;
+ }
+ DayGridSegHierarchy.prototype.addSegs = function (segInputs) {
+ var _this = this;
+ var hiddenSegs = _super.prototype.addSegs.call(this, segInputs);
+ var entriesByLevel = this.entriesByLevel;
+ var excludeHidden = function (entry) { return !_this.forceHidden[buildEntryKey(entry)]; };
+ // remove the forced-hidden segs
+ for (var level = 0; level < entriesByLevel.length; level += 1) {
+ entriesByLevel[level] = entriesByLevel[level].filter(excludeHidden);
+ }
+ return hiddenSegs;
+ };
+ DayGridSegHierarchy.prototype.handleInvalidInsertion = function (insertion, entry, hiddenEntries) {
+ var _a = this, entriesByLevel = _a.entriesByLevel, forceHidden = _a.forceHidden;
+ var touchingEntry = insertion.touchingEntry, touchingLevel = insertion.touchingLevel, touchingLateral = insertion.touchingLateral;
+ if (this.hiddenConsumes && touchingEntry) {
+ var touchingEntryId = buildEntryKey(touchingEntry);
+ // if not already hidden
+ if (!forceHidden[touchingEntryId]) {
+ if (this.allowReslicing) {
+ var placeholderEntry = __assign(__assign({}, touchingEntry), { span: intersectSpans(touchingEntry.span, entry.span) });
+ var placeholderEntryId = buildEntryKey(placeholderEntry);
+ forceHidden[placeholderEntryId] = true;
+ entriesByLevel[touchingLevel][touchingLateral] = placeholderEntry; // replace touchingEntry with our placeholder
+ this.splitEntry(touchingEntry, entry, hiddenEntries); // split up the touchingEntry, reinsert it
+ }
+ else {
+ forceHidden[touchingEntryId] = true;
+ hiddenEntries.push(touchingEntry);
+ }
+ }
+ }
+ return _super.prototype.handleInvalidInsertion.call(this, insertion, entry, hiddenEntries);
+ };
+ return DayGridSegHierarchy;
+ }(SegHierarchy));
+
+ var TableRow = /** @class */ (function (_super) {
+ __extends(TableRow, _super);
+ function TableRow() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.cellElRefs = new RefMap(); // the |
+ _this.frameElRefs = new RefMap(); // the fc-daygrid-day-frame
+ _this.fgElRefs = new RefMap(); // the fc-daygrid-day-events
+ _this.segHarnessRefs = new RefMap(); // indexed by "instanceId:firstCol"
+ _this.rootElRef = createRef();
+ _this.state = {
+ framePositions: null,
+ maxContentHeight: null,
+ eventInstanceHeights: {},
+ };
+ return _this;
+ }
+ TableRow.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ var options = context.options;
+ var colCnt = props.cells.length;
+ var businessHoursByCol = splitSegsByFirstCol(props.businessHourSegs, colCnt);
+ var bgEventSegsByCol = splitSegsByFirstCol(props.bgEventSegs, colCnt);
+ var highlightSegsByCol = splitSegsByFirstCol(this.getHighlightSegs(), colCnt);
+ var mirrorSegsByCol = splitSegsByFirstCol(this.getMirrorSegs(), colCnt);
+ var _b = computeFgSegPlacement(sortEventSegs(props.fgEventSegs, options.eventOrder), props.dayMaxEvents, props.dayMaxEventRows, options.eventOrderStrict, state.eventInstanceHeights, state.maxContentHeight, props.cells), singleColPlacements = _b.singleColPlacements, multiColPlacements = _b.multiColPlacements, moreCnts = _b.moreCnts, moreMarginTops = _b.moreMarginTops;
+ var isForcedInvisible = // TODO: messy way to compute this
+ (props.eventDrag && props.eventDrag.affectedInstances) ||
+ (props.eventResize && props.eventResize.affectedInstances) ||
+ {};
+ return (createElement("tr", { ref: this.rootElRef, role: "row" },
+ props.renderIntro && props.renderIntro(),
+ props.cells.map(function (cell, col) {
+ var normalFgNodes = _this.renderFgSegs(col, props.forPrint ? singleColPlacements[col] : multiColPlacements[col], props.todayRange, isForcedInvisible);
+ var mirrorFgNodes = _this.renderFgSegs(col, buildMirrorPlacements$1(mirrorSegsByCol[col], multiColPlacements), props.todayRange, {}, Boolean(props.eventDrag), Boolean(props.eventResize), false);
+ return (createElement(TableCell, { key: cell.key, elRef: _this.cellElRefs.createRef(cell.key), innerElRef: _this.frameElRefs.createRef(cell.key) /* FF | problem, but okay to use for left/right. TODO: rename prop */, dateProfile: props.dateProfile, date: cell.date, showDayNumber: props.showDayNumbers, showWeekNumber: props.showWeekNumbers && col === 0, forceDayTop: props.showWeekNumbers /* even displaying weeknum for row, not necessarily day */, todayRange: props.todayRange, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, extraHookProps: cell.extraHookProps, extraDataAttrs: cell.extraDataAttrs, extraClassNames: cell.extraClassNames, extraDateSpan: cell.extraDateSpan, moreCnt: moreCnts[col], moreMarginTop: moreMarginTops[col], singlePlacements: singleColPlacements[col], fgContentElRef: _this.fgElRefs.createRef(cell.key), fgContent: ( // Fragment scopes the keys
+ createElement(Fragment, null,
+ createElement(Fragment, null, normalFgNodes),
+ createElement(Fragment, null, mirrorFgNodes))), bgContent: ( // Fragment scopes the keys
+ createElement(Fragment, null,
+ _this.renderFillSegs(highlightSegsByCol[col], 'highlight'),
+ _this.renderFillSegs(businessHoursByCol[col], 'non-business'),
+ _this.renderFillSegs(bgEventSegsByCol[col], 'bg-event'))) }));
+ })));
+ };
+ TableRow.prototype.componentDidMount = function () {
+ this.updateSizing(true);
+ };
+ TableRow.prototype.componentDidUpdate = function (prevProps, prevState) {
+ var currentProps = this.props;
+ this.updateSizing(!isPropsEqual(prevProps, currentProps));
+ };
+ TableRow.prototype.getHighlightSegs = function () {
+ var props = this.props;
+ if (props.eventDrag && props.eventDrag.segs.length) { // messy check
+ return props.eventDrag.segs;
+ }
+ if (props.eventResize && props.eventResize.segs.length) { // messy check
+ return props.eventResize.segs;
+ }
+ return props.dateSelectionSegs;
+ };
+ TableRow.prototype.getMirrorSegs = function () {
+ var props = this.props;
+ if (props.eventResize && props.eventResize.segs.length) { // messy check
+ return props.eventResize.segs;
+ }
+ return [];
+ };
+ TableRow.prototype.renderFgSegs = function (col, segPlacements, todayRange, isForcedInvisible, isDragging, isResizing, isDateSelecting) {
+ var context = this.context;
+ var eventSelection = this.props.eventSelection;
+ var framePositions = this.state.framePositions;
+ var defaultDisplayEventEnd = this.props.cells.length === 1; // colCnt === 1
+ var isMirror = isDragging || isResizing || isDateSelecting;
+ var nodes = [];
+ if (framePositions) {
+ for (var _i = 0, segPlacements_1 = segPlacements; _i < segPlacements_1.length; _i++) {
+ var placement = segPlacements_1[_i];
+ var seg = placement.seg;
+ var instanceId = seg.eventRange.instance.instanceId;
+ var key = instanceId + ':' + col;
+ var isVisible = placement.isVisible && !isForcedInvisible[instanceId];
+ var isAbsolute = placement.isAbsolute;
+ var left = '';
+ var right = '';
+ if (isAbsolute) {
+ if (context.isRtl) {
+ right = 0;
+ left = framePositions.lefts[seg.lastCol] - framePositions.lefts[seg.firstCol];
+ }
+ else {
+ left = 0;
+ right = framePositions.rights[seg.firstCol] - framePositions.rights[seg.lastCol];
+ }
+ }
+ /*
+ known bug: events that are force to be list-item but span multiple days still take up space in later columns
+ todo: in print view, for multi-day events, don't display title within non-start/end segs
+ */
+ nodes.push(createElement("div", { className: 'fc-daygrid-event-harness' + (isAbsolute ? ' fc-daygrid-event-harness-abs' : ''), key: key, ref: isMirror ? null : this.segHarnessRefs.createRef(key), style: {
+ visibility: isVisible ? '' : 'hidden',
+ marginTop: isAbsolute ? '' : placement.marginTop,
+ top: isAbsolute ? placement.absoluteTop : '',
+ left: left,
+ right: right,
+ } }, hasListItemDisplay(seg) ? (createElement(TableListItemEvent, __assign({ seg: seg, isDragging: isDragging, isSelected: instanceId === eventSelection, defaultDisplayEventEnd: defaultDisplayEventEnd }, getSegMeta(seg, todayRange)))) : (createElement(TableBlockEvent, __assign({ seg: seg, isDragging: isDragging, isResizing: isResizing, isDateSelecting: isDateSelecting, isSelected: instanceId === eventSelection, defaultDisplayEventEnd: defaultDisplayEventEnd }, getSegMeta(seg, todayRange))))));
+ }
+ }
+ return nodes;
+ };
+ TableRow.prototype.renderFillSegs = function (segs, fillType) {
+ var isRtl = this.context.isRtl;
+ var todayRange = this.props.todayRange;
+ var framePositions = this.state.framePositions;
+ var nodes = [];
+ if (framePositions) {
+ for (var _i = 0, segs_1 = segs; _i < segs_1.length; _i++) {
+ var seg = segs_1[_i];
+ var leftRightCss = isRtl ? {
+ right: 0,
+ left: framePositions.lefts[seg.lastCol] - framePositions.lefts[seg.firstCol],
+ } : {
+ left: 0,
+ right: framePositions.rights[seg.firstCol] - framePositions.rights[seg.lastCol],
+ };
+ nodes.push(createElement("div", { key: buildEventRangeKey(seg.eventRange), className: "fc-daygrid-bg-harness", style: leftRightCss }, fillType === 'bg-event' ?
+ createElement(BgEvent, __assign({ seg: seg }, getSegMeta(seg, todayRange))) :
+ renderFill(fillType)));
+ }
+ }
+ return createElement.apply(void 0, __spreadArray([Fragment, {}], nodes));
+ };
+ TableRow.prototype.updateSizing = function (isExternalSizingChange) {
+ var _a = this, props = _a.props, frameElRefs = _a.frameElRefs;
+ if (!props.forPrint &&
+ props.clientWidth !== null // positioning ready?
+ ) {
+ if (isExternalSizingChange) {
+ var frameEls = props.cells.map(function (cell) { return frameElRefs.currentMap[cell.key]; });
+ if (frameEls.length) {
+ var originEl = this.rootElRef.current;
+ this.setState({
+ framePositions: new PositionCache(originEl, frameEls, true, // isHorizontal
+ false),
+ });
+ }
+ }
+ var oldInstanceHeights = this.state.eventInstanceHeights;
+ var newInstanceHeights = this.queryEventInstanceHeights();
+ var limitByContentHeight = props.dayMaxEvents === true || props.dayMaxEventRows === true;
+ this.setState({
+ // HACK to prevent oscillations of events being shown/hidden from max-event-rows
+ // Essentially, once you compute an element's height, never null-out.
+ // TODO: always display all events, as visibility:hidden?
+ eventInstanceHeights: __assign(__assign({}, oldInstanceHeights), newInstanceHeights),
+ maxContentHeight: limitByContentHeight ? this.computeMaxContentHeight() : null,
+ });
+ }
+ };
+ TableRow.prototype.queryEventInstanceHeights = function () {
+ var segElMap = this.segHarnessRefs.currentMap;
+ var eventInstanceHeights = {};
+ // get the max height amongst instance segs
+ for (var key in segElMap) {
+ var height = Math.round(segElMap[key].getBoundingClientRect().height);
+ var instanceId = key.split(':')[0]; // deconstruct how renderFgSegs makes the key
+ eventInstanceHeights[instanceId] = Math.max(eventInstanceHeights[instanceId] || 0, height);
+ }
+ return eventInstanceHeights;
+ };
+ TableRow.prototype.computeMaxContentHeight = function () {
+ var firstKey = this.props.cells[0].key;
+ var cellEl = this.cellElRefs.currentMap[firstKey];
+ var fcContainerEl = this.fgElRefs.currentMap[firstKey];
+ return cellEl.getBoundingClientRect().bottom - fcContainerEl.getBoundingClientRect().top;
+ };
+ TableRow.prototype.getCellEls = function () {
+ var elMap = this.cellElRefs.currentMap;
+ return this.props.cells.map(function (cell) { return elMap[cell.key]; });
+ };
+ return TableRow;
+ }(DateComponent));
+ TableRow.addStateEquality({
+ eventInstanceHeights: isPropsEqual,
+ });
+ function buildMirrorPlacements$1(mirrorSegs, colPlacements) {
+ if (!mirrorSegs.length) {
+ return [];
+ }
+ var topsByInstanceId = buildAbsoluteTopHash$1(colPlacements); // TODO: cache this at first render?
+ return mirrorSegs.map(function (seg) { return ({
+ seg: seg,
+ isVisible: true,
+ isAbsolute: true,
+ absoluteTop: topsByInstanceId[seg.eventRange.instance.instanceId],
+ marginTop: 0,
+ }); });
+ }
+ function buildAbsoluteTopHash$1(colPlacements) {
+ var topsByInstanceId = {};
+ for (var _i = 0, colPlacements_1 = colPlacements; _i < colPlacements_1.length; _i++) {
+ var placements = colPlacements_1[_i];
+ for (var _a = 0, placements_1 = placements; _a < placements_1.length; _a++) {
+ var placement = placements_1[_a];
+ topsByInstanceId[placement.seg.eventRange.instance.instanceId] = placement.absoluteTop;
+ }
+ }
+ return topsByInstanceId;
+ }
+
+ var Table = /** @class */ (function (_super) {
+ __extends(Table, _super);
+ function Table() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.splitBusinessHourSegs = memoize(splitSegsByRow);
+ _this.splitBgEventSegs = memoize(splitSegsByRow);
+ _this.splitFgEventSegs = memoize(splitSegsByRow);
+ _this.splitDateSelectionSegs = memoize(splitSegsByRow);
+ _this.splitEventDrag = memoize(splitInteractionByRow);
+ _this.splitEventResize = memoize(splitInteractionByRow);
+ _this.rowRefs = new RefMap();
+ _this.handleRootEl = function (rootEl) {
+ _this.rootEl = rootEl;
+ if (rootEl) {
+ _this.context.registerInteractiveComponent(_this, {
+ el: rootEl,
+ isHitComboAllowed: _this.props.isHitComboAllowed,
+ });
+ }
+ else {
+ _this.context.unregisterInteractiveComponent(_this);
+ }
+ };
+ return _this;
+ }
+ Table.prototype.render = function () {
+ var _this = this;
+ var props = this.props;
+ var dateProfile = props.dateProfile, dayMaxEventRows = props.dayMaxEventRows, dayMaxEvents = props.dayMaxEvents, expandRows = props.expandRows;
+ var rowCnt = props.cells.length;
+ var businessHourSegsByRow = this.splitBusinessHourSegs(props.businessHourSegs, rowCnt);
+ var bgEventSegsByRow = this.splitBgEventSegs(props.bgEventSegs, rowCnt);
+ var fgEventSegsByRow = this.splitFgEventSegs(props.fgEventSegs, rowCnt);
+ var dateSelectionSegsByRow = this.splitDateSelectionSegs(props.dateSelectionSegs, rowCnt);
+ var eventDragByRow = this.splitEventDrag(props.eventDrag, rowCnt);
+ var eventResizeByRow = this.splitEventResize(props.eventResize, rowCnt);
+ var limitViaBalanced = dayMaxEvents === true || dayMaxEventRows === true;
+ // if rows can't expand to fill fixed height, can't do balanced-height event limit
+ // TODO: best place to normalize these options?
+ if (limitViaBalanced && !expandRows) {
+ limitViaBalanced = false;
+ dayMaxEventRows = null;
+ dayMaxEvents = null;
+ }
+ var classNames = [
+ 'fc-daygrid-body',
+ limitViaBalanced ? 'fc-daygrid-body-balanced' : 'fc-daygrid-body-unbalanced',
+ expandRows ? '' : 'fc-daygrid-body-natural', // will height of one row depend on the others?
+ ];
+ return (createElement("div", { className: classNames.join(' '), ref: this.handleRootEl, style: {
+ // these props are important to give this wrapper correct dimensions for interactions
+ // TODO: if we set it here, can we avoid giving to inner tables?
+ width: props.clientWidth,
+ minWidth: props.tableMinWidth,
+ } },
+ createElement(NowTimer, { unit: "day" }, function (nowDate, todayRange) { return (createElement(Fragment, null,
+ createElement("table", { role: "presentation", className: "fc-scrollgrid-sync-table", style: {
+ width: props.clientWidth,
+ minWidth: props.tableMinWidth,
+ height: expandRows ? props.clientHeight : '',
+ } },
+ props.colGroupNode,
+ createElement("tbody", { role: "presentation" }, props.cells.map(function (cells, row) { return (createElement(TableRow, { ref: _this.rowRefs.createRef(row), key: cells.length
+ ? cells[0].date.toISOString() /* best? or put key on cell? or use diff formatter? */
+ : row // in case there are no cells (like when resource view is loading)
+ , showDayNumbers: rowCnt > 1, showWeekNumbers: props.showWeekNumbers, todayRange: todayRange, dateProfile: dateProfile, cells: cells, renderIntro: props.renderRowIntro, businessHourSegs: businessHourSegsByRow[row], eventSelection: props.eventSelection, bgEventSegs: bgEventSegsByRow[row].filter(isSegAllDay) /* hack */, fgEventSegs: fgEventSegsByRow[row], dateSelectionSegs: dateSelectionSegsByRow[row], eventDrag: eventDragByRow[row], eventResize: eventResizeByRow[row], dayMaxEvents: dayMaxEvents, dayMaxEventRows: dayMaxEventRows, clientWidth: props.clientWidth, clientHeight: props.clientHeight, forPrint: props.forPrint })); }))))); })));
+ };
+ // Hit System
+ // ----------------------------------------------------------------------------------------------------
+ Table.prototype.prepareHits = function () {
+ this.rowPositions = new PositionCache(this.rootEl, this.rowRefs.collect().map(function (rowObj) { return rowObj.getCellEls()[0]; }), // first cell el in each row. TODO: not optimal
+ false, true);
+ this.colPositions = new PositionCache(this.rootEl, this.rowRefs.currentMap[0].getCellEls(), // cell els in first row
+ true, // horizontal
+ false);
+ };
+ Table.prototype.queryHit = function (positionLeft, positionTop) {
+ var _a = this, colPositions = _a.colPositions, rowPositions = _a.rowPositions;
+ var col = colPositions.leftToIndex(positionLeft);
+ var row = rowPositions.topToIndex(positionTop);
+ if (row != null && col != null) {
+ var cell = this.props.cells[row][col];
+ return {
+ dateProfile: this.props.dateProfile,
+ dateSpan: __assign({ range: this.getCellRange(row, col), allDay: true }, cell.extraDateSpan),
+ dayEl: this.getCellEl(row, col),
+ rect: {
+ left: colPositions.lefts[col],
+ right: colPositions.rights[col],
+ top: rowPositions.tops[row],
+ bottom: rowPositions.bottoms[row],
+ },
+ layer: 0,
+ };
+ }
+ return null;
+ };
+ Table.prototype.getCellEl = function (row, col) {
+ return this.rowRefs.currentMap[row].getCellEls()[col]; // TODO: not optimal
+ };
+ Table.prototype.getCellRange = function (row, col) {
+ var start = this.props.cells[row][col].date;
+ var end = addDays(start, 1);
+ return { start: start, end: end };
+ };
+ return Table;
+ }(DateComponent));
+ function isSegAllDay(seg) {
+ return seg.eventRange.def.allDay;
+ }
+
+ var DayTableSlicer = /** @class */ (function (_super) {
+ __extends(DayTableSlicer, _super);
+ function DayTableSlicer() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.forceDayIfListItem = true;
+ return _this;
+ }
+ DayTableSlicer.prototype.sliceRange = function (dateRange, dayTableModel) {
+ return dayTableModel.sliceRange(dateRange);
+ };
+ return DayTableSlicer;
+ }(Slicer));
+
+ var DayTable = /** @class */ (function (_super) {
+ __extends(DayTable, _super);
+ function DayTable() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.slicer = new DayTableSlicer();
+ _this.tableRef = createRef();
+ return _this;
+ }
+ DayTable.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ return (createElement(Table, __assign({ ref: this.tableRef }, this.slicer.sliceProps(props, props.dateProfile, props.nextDayThreshold, context, props.dayTableModel), { dateProfile: props.dateProfile, cells: props.dayTableModel.cells, colGroupNode: props.colGroupNode, tableMinWidth: props.tableMinWidth, renderRowIntro: props.renderRowIntro, dayMaxEvents: props.dayMaxEvents, dayMaxEventRows: props.dayMaxEventRows, showWeekNumbers: props.showWeekNumbers, expandRows: props.expandRows, headerAlignElRef: props.headerAlignElRef, clientWidth: props.clientWidth, clientHeight: props.clientHeight, forPrint: props.forPrint })));
+ };
+ return DayTable;
+ }(DateComponent));
+
+ var DayTableView = /** @class */ (function (_super) {
+ __extends(DayTableView, _super);
+ function DayTableView() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.buildDayTableModel = memoize(buildDayTableModel);
+ _this.headerRef = createRef();
+ _this.tableRef = createRef();
+ return _this;
+ }
+ DayTableView.prototype.render = function () {
+ var _this = this;
+ var _a = this.context, options = _a.options, dateProfileGenerator = _a.dateProfileGenerator;
+ var props = this.props;
+ var dayTableModel = this.buildDayTableModel(props.dateProfile, dateProfileGenerator);
+ var headerContent = options.dayHeaders && (createElement(DayHeader, { ref: this.headerRef, dateProfile: props.dateProfile, dates: dayTableModel.headerDates, datesRepDistinctDays: dayTableModel.rowCnt === 1 }));
+ var bodyContent = function (contentArg) { return (createElement(DayTable, { ref: _this.tableRef, dateProfile: props.dateProfile, dayTableModel: dayTableModel, businessHours: props.businessHours, dateSelection: props.dateSelection, eventStore: props.eventStore, eventUiBases: props.eventUiBases, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, nextDayThreshold: options.nextDayThreshold, colGroupNode: contentArg.tableColGroupNode, tableMinWidth: contentArg.tableMinWidth, dayMaxEvents: options.dayMaxEvents, dayMaxEventRows: options.dayMaxEventRows, showWeekNumbers: options.weekNumbers, expandRows: !props.isHeightAuto, headerAlignElRef: _this.headerElRef, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, forPrint: props.forPrint })); };
+ return options.dayMinWidth
+ ? this.renderHScrollLayout(headerContent, bodyContent, dayTableModel.colCnt, options.dayMinWidth)
+ : this.renderSimpleLayout(headerContent, bodyContent);
+ };
+ return DayTableView;
+ }(TableView));
+ function buildDayTableModel(dateProfile, dateProfileGenerator) {
+ var daySeries = new DaySeriesModel(dateProfile.renderRange, dateProfileGenerator);
+ return new DayTableModel(daySeries, /year|month|week/.test(dateProfile.currentRangeUnit));
+ }
+
+ var TableDateProfileGenerator = /** @class */ (function (_super) {
+ __extends(TableDateProfileGenerator, _super);
+ function TableDateProfileGenerator() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ // Computes the date range that will be rendered.
+ TableDateProfileGenerator.prototype.buildRenderRange = function (currentRange, currentRangeUnit, isRangeAllDay) {
+ var dateEnv = this.props.dateEnv;
+ var renderRange = _super.prototype.buildRenderRange.call(this, currentRange, currentRangeUnit, isRangeAllDay);
+ var start = renderRange.start;
+ var end = renderRange.end;
+ var endOfWeek;
+ // year and month views should be aligned with weeks. this is already done for week
+ if (/^(year|month)$/.test(currentRangeUnit)) {
+ start = dateEnv.startOfWeek(start);
+ // make end-of-week if not already
+ endOfWeek = dateEnv.startOfWeek(end);
+ if (endOfWeek.valueOf() !== end.valueOf()) {
+ end = addWeeks(endOfWeek, 1);
+ }
+ }
+ // ensure 6 weeks
+ if (this.props.monthMode &&
+ this.props.fixedWeekCount) {
+ var rowCnt = Math.ceil(// could be partial weeks due to hiddenDays
+ diffWeeks(start, end));
+ end = addWeeks(end, 6 - rowCnt);
+ }
+ return { start: start, end: end };
+ };
+ return TableDateProfileGenerator;
+ }(DateProfileGenerator));
+
+ var dayGridPlugin = createPlugin({
+ initialView: 'dayGridMonth',
+ views: {
+ dayGrid: {
+ component: DayTableView,
+ dateProfileGeneratorClass: TableDateProfileGenerator,
+ },
+ dayGridDay: {
+ type: 'dayGrid',
+ duration: { days: 1 },
+ },
+ dayGridWeek: {
+ type: 'dayGrid',
+ duration: { weeks: 1 },
+ },
+ dayGridMonth: {
+ type: 'dayGrid',
+ duration: { months: 1 },
+ monthMode: true,
+ fixedWeekCount: true,
+ },
+ },
+ });
+
+ var AllDaySplitter = /** @class */ (function (_super) {
+ __extends(AllDaySplitter, _super);
+ function AllDaySplitter() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ AllDaySplitter.prototype.getKeyInfo = function () {
+ return {
+ allDay: {},
+ timed: {},
+ };
+ };
+ AllDaySplitter.prototype.getKeysForDateSpan = function (dateSpan) {
+ if (dateSpan.allDay) {
+ return ['allDay'];
+ }
+ return ['timed'];
+ };
+ AllDaySplitter.prototype.getKeysForEventDef = function (eventDef) {
+ if (!eventDef.allDay) {
+ return ['timed'];
+ }
+ if (hasBgRendering(eventDef)) {
+ return ['timed', 'allDay'];
+ }
+ return ['allDay'];
+ };
+ return AllDaySplitter;
+ }(Splitter));
+
+ var DEFAULT_SLAT_LABEL_FORMAT = createFormatter({
+ hour: 'numeric',
+ minute: '2-digit',
+ omitZeroMinute: true,
+ meridiem: 'short',
+ });
+ function TimeColsAxisCell(props) {
+ var classNames = [
+ 'fc-timegrid-slot',
+ 'fc-timegrid-slot-label',
+ props.isLabeled ? 'fc-scrollgrid-shrink' : 'fc-timegrid-slot-minor',
+ ];
+ return (createElement(ViewContextType.Consumer, null, function (context) {
+ if (!props.isLabeled) {
+ return (createElement("td", { className: classNames.join(' '), "data-time": props.isoTimeStr }));
+ }
+ var dateEnv = context.dateEnv, options = context.options, viewApi = context.viewApi;
+ var labelFormat = // TODO: fully pre-parse
+ options.slotLabelFormat == null ? DEFAULT_SLAT_LABEL_FORMAT :
+ Array.isArray(options.slotLabelFormat) ? createFormatter(options.slotLabelFormat[0]) :
+ createFormatter(options.slotLabelFormat);
+ var hookProps = {
+ level: 0,
+ time: props.time,
+ date: dateEnv.toDate(props.date),
+ view: viewApi,
+ text: dateEnv.format(props.date, labelFormat),
+ };
+ return (createElement(RenderHook, { hookProps: hookProps, classNames: options.slotLabelClassNames, content: options.slotLabelContent, defaultContent: renderInnerContent$3, didMount: options.slotLabelDidMount, willUnmount: options.slotLabelWillUnmount }, function (rootElRef, customClassNames, innerElRef, innerContent) { return (createElement("td", { ref: rootElRef, className: classNames.concat(customClassNames).join(' '), "data-time": props.isoTimeStr },
+ createElement("div", { className: "fc-timegrid-slot-label-frame fc-scrollgrid-shrink-frame" },
+ createElement("div", { className: "fc-timegrid-slot-label-cushion fc-scrollgrid-shrink-cushion", ref: innerElRef }, innerContent)))); }));
+ }));
+ }
+ function renderInnerContent$3(props) {
+ return props.text;
+ }
+
+ var TimeBodyAxis = /** @class */ (function (_super) {
+ __extends(TimeBodyAxis, _super);
+ function TimeBodyAxis() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimeBodyAxis.prototype.render = function () {
+ return this.props.slatMetas.map(function (slatMeta) { return (createElement("tr", { key: slatMeta.key },
+ createElement(TimeColsAxisCell, __assign({}, slatMeta)))); });
+ };
+ return TimeBodyAxis;
+ }(BaseComponent));
+
+ var DEFAULT_WEEK_NUM_FORMAT = createFormatter({ week: 'short' });
+ var AUTO_ALL_DAY_MAX_EVENT_ROWS = 5;
+ var TimeColsView = /** @class */ (function (_super) {
+ __extends(TimeColsView, _super);
+ function TimeColsView() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.allDaySplitter = new AllDaySplitter(); // for use by subclasses
+ _this.headerElRef = createRef();
+ _this.rootElRef = createRef();
+ _this.scrollerElRef = createRef();
+ _this.state = {
+ slatCoords: null,
+ };
+ _this.handleScrollTopRequest = function (scrollTop) {
+ var scrollerEl = _this.scrollerElRef.current;
+ if (scrollerEl) { // TODO: not sure how this could ever be null. weirdness with the reducer
+ scrollerEl.scrollTop = scrollTop;
+ }
+ };
+ /* Header Render Methods
+ ------------------------------------------------------------------------------------------------------------------*/
+ _this.renderHeadAxis = function (rowKey, frameHeight) {
+ if (frameHeight === void 0) { frameHeight = ''; }
+ var options = _this.context.options;
+ var dateProfile = _this.props.dateProfile;
+ var range = dateProfile.renderRange;
+ var dayCnt = diffDays(range.start, range.end);
+ var navLinkAttrs = (dayCnt === 1) // only do in day views (to avoid doing in week views that dont need it)
+ ? buildNavLinkAttrs(_this.context, range.start, 'week')
+ : {};
+ if (options.weekNumbers && rowKey === 'day') {
+ return (createElement(WeekNumberRoot, { date: range.start, defaultFormat: DEFAULT_WEEK_NUM_FORMAT }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("th", { ref: rootElRef, "aria-hidden": true, className: [
+ 'fc-timegrid-axis',
+ 'fc-scrollgrid-shrink',
+ ].concat(classNames).join(' ') },
+ createElement("div", { className: "fc-timegrid-axis-frame fc-scrollgrid-shrink-frame fc-timegrid-axis-frame-liquid", style: { height: frameHeight } },
+ createElement("a", __assign({ ref: innerElRef, className: "fc-timegrid-axis-cushion fc-scrollgrid-shrink-cushion fc-scrollgrid-sync-inner" }, navLinkAttrs), innerContent)))); }));
+ }
+ return (createElement("th", { "aria-hidden": true, className: "fc-timegrid-axis" },
+ createElement("div", { className: "fc-timegrid-axis-frame", style: { height: frameHeight } })));
+ };
+ /* Table Component Render Methods
+ ------------------------------------------------------------------------------------------------------------------*/
+ // only a one-way height sync. we don't send the axis inner-content height to the DayGrid,
+ // but DayGrid still needs to have classNames on inner elements in order to measure.
+ _this.renderTableRowAxis = function (rowHeight) {
+ var _a = _this.context, options = _a.options, viewApi = _a.viewApi;
+ var hookProps = {
+ text: options.allDayText,
+ view: viewApi,
+ };
+ return (
+ // TODO: make reusable hook. used in list view too
+ createElement(RenderHook, { hookProps: hookProps, classNames: options.allDayClassNames, content: options.allDayContent, defaultContent: renderAllDayInner$1, didMount: options.allDayDidMount, willUnmount: options.allDayWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("td", { ref: rootElRef, "aria-hidden": true, className: [
+ 'fc-timegrid-axis',
+ 'fc-scrollgrid-shrink',
+ ].concat(classNames).join(' ') },
+ createElement("div", { className: 'fc-timegrid-axis-frame fc-scrollgrid-shrink-frame' + (rowHeight == null ? ' fc-timegrid-axis-frame-liquid' : ''), style: { height: rowHeight } },
+ createElement("span", { className: "fc-timegrid-axis-cushion fc-scrollgrid-shrink-cushion fc-scrollgrid-sync-inner", ref: innerElRef }, innerContent)))); }));
+ };
+ _this.handleSlatCoords = function (slatCoords) {
+ _this.setState({ slatCoords: slatCoords });
+ };
+ return _this;
+ }
+ // rendering
+ // ----------------------------------------------------------------------------------------------------
+ TimeColsView.prototype.renderSimpleLayout = function (headerRowContent, allDayContent, timeContent) {
+ var _a = this, context = _a.context, props = _a.props;
+ var sections = [];
+ var stickyHeaderDates = getStickyHeaderDates(context.options);
+ if (headerRowContent) {
+ sections.push({
+ type: 'header',
+ key: 'header',
+ isSticky: stickyHeaderDates,
+ chunk: {
+ elRef: this.headerElRef,
+ tableClassName: 'fc-col-header',
+ rowContent: headerRowContent,
+ },
+ });
+ }
+ if (allDayContent) {
+ sections.push({
+ type: 'body',
+ key: 'all-day',
+ chunk: { content: allDayContent },
+ });
+ sections.push({
+ type: 'body',
+ key: 'all-day-divider',
+ outerContent: ( // TODO: rename to cellContent so don't need to define | ?
+ createElement("tr", { role: "presentation", className: "fc-scrollgrid-section" },
+ createElement("td", { className: 'fc-timegrid-divider ' + context.theme.getClass('tableCellShaded') }))),
+ });
+ }
+ sections.push({
+ type: 'body',
+ key: 'body',
+ liquid: true,
+ expandRows: Boolean(context.options.expandRows),
+ chunk: {
+ scrollerElRef: this.scrollerElRef,
+ content: timeContent,
+ },
+ });
+ return (createElement(ViewRoot, { viewSpec: context.viewSpec, elRef: this.rootElRef }, function (rootElRef, classNames) { return (createElement("div", { className: ['fc-timegrid'].concat(classNames).join(' '), ref: rootElRef },
+ createElement(SimpleScrollGrid, { liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: props.forPrint, cols: [{ width: 'shrink' }], sections: sections }))); }));
+ };
+ TimeColsView.prototype.renderHScrollLayout = function (headerRowContent, allDayContent, timeContent, colCnt, dayMinWidth, slatMetas, slatCoords) {
+ var _this = this;
+ var ScrollGrid = this.context.pluginHooks.scrollGridImpl;
+ if (!ScrollGrid) {
+ throw new Error('No ScrollGrid implementation');
+ }
+ var _a = this, context = _a.context, props = _a.props;
+ var stickyHeaderDates = !props.forPrint && getStickyHeaderDates(context.options);
+ var stickyFooterScrollbar = !props.forPrint && getStickyFooterScrollbar(context.options);
+ var sections = [];
+ if (headerRowContent) {
+ sections.push({
+ type: 'header',
+ key: 'header',
+ isSticky: stickyHeaderDates,
+ syncRowHeights: true,
+ chunks: [
+ {
+ key: 'axis',
+ rowContent: function (arg) { return (createElement("tr", { role: "presentation" }, _this.renderHeadAxis('day', arg.rowSyncHeights[0]))); },
+ },
+ {
+ key: 'cols',
+ elRef: this.headerElRef,
+ tableClassName: 'fc-col-header',
+ rowContent: headerRowContent,
+ },
+ ],
+ });
+ }
+ if (allDayContent) {
+ sections.push({
+ type: 'body',
+ key: 'all-day',
+ syncRowHeights: true,
+ chunks: [
+ {
+ key: 'axis',
+ rowContent: function (contentArg) { return (createElement("tr", { role: "presentation" }, _this.renderTableRowAxis(contentArg.rowSyncHeights[0]))); },
+ },
+ {
+ key: 'cols',
+ content: allDayContent,
+ },
+ ],
+ });
+ sections.push({
+ key: 'all-day-divider',
+ type: 'body',
+ outerContent: ( // TODO: rename to cellContent so don't need to define
?
+ createElement("tr", { role: "presentation", className: "fc-scrollgrid-section" },
+ createElement("td", { colSpan: 2, className: 'fc-timegrid-divider ' + context.theme.getClass('tableCellShaded') }))),
+ });
+ }
+ var isNowIndicator = context.options.nowIndicator;
+ sections.push({
+ type: 'body',
+ key: 'body',
+ liquid: true,
+ expandRows: Boolean(context.options.expandRows),
+ chunks: [
+ {
+ key: 'axis',
+ content: function (arg) { return (
+ // TODO: make this now-indicator arrow more DRY with TimeColsContent
+ createElement("div", { className: "fc-timegrid-axis-chunk" },
+ createElement("table", { "aria-hidden": true, style: { height: arg.expandRows ? arg.clientHeight : '' } },
+ arg.tableColGroupNode,
+ createElement("tbody", null,
+ createElement(TimeBodyAxis, { slatMetas: slatMetas }))),
+ createElement("div", { className: "fc-timegrid-now-indicator-container" },
+ createElement(NowTimer, { unit: isNowIndicator ? 'minute' : 'day' /* hacky */ }, function (nowDate) {
+ var nowIndicatorTop = isNowIndicator &&
+ slatCoords &&
+ slatCoords.safeComputeTop(nowDate); // might return void
+ if (typeof nowIndicatorTop === 'number') {
+ return (createElement(NowIndicatorRoot, { isAxis: true, date: nowDate }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("div", { ref: rootElRef, className: ['fc-timegrid-now-indicator-arrow'].concat(classNames).join(' '), style: { top: nowIndicatorTop } }, innerContent)); }));
+ }
+ return null;
+ })))); },
+ },
+ {
+ key: 'cols',
+ scrollerElRef: this.scrollerElRef,
+ content: timeContent,
+ },
+ ],
+ });
+ if (stickyFooterScrollbar) {
+ sections.push({
+ key: 'footer',
+ type: 'footer',
+ isSticky: true,
+ chunks: [
+ {
+ key: 'axis',
+ content: renderScrollShim,
+ },
+ {
+ key: 'cols',
+ content: renderScrollShim,
+ },
+ ],
+ });
+ }
+ return (createElement(ViewRoot, { viewSpec: context.viewSpec, elRef: this.rootElRef }, function (rootElRef, classNames) { return (createElement("div", { className: ['fc-timegrid'].concat(classNames).join(' '), ref: rootElRef },
+ createElement(ScrollGrid, { liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: false, colGroups: [
+ { width: 'shrink', cols: [{ width: 'shrink' }] },
+ { cols: [{ span: colCnt, minWidth: dayMinWidth }] },
+ ], sections: sections }))); }));
+ };
+ /* Dimensions
+ ------------------------------------------------------------------------------------------------------------------*/
+ TimeColsView.prototype.getAllDayMaxEventProps = function () {
+ var _a = this.context.options, dayMaxEvents = _a.dayMaxEvents, dayMaxEventRows = _a.dayMaxEventRows;
+ if (dayMaxEvents === true || dayMaxEventRows === true) { // is auto?
+ dayMaxEvents = undefined;
+ dayMaxEventRows = AUTO_ALL_DAY_MAX_EVENT_ROWS; // make sure "auto" goes to a real number
+ }
+ return { dayMaxEvents: dayMaxEvents, dayMaxEventRows: dayMaxEventRows };
+ };
+ return TimeColsView;
+ }(DateComponent));
+ function renderAllDayInner$1(hookProps) {
+ return hookProps.text;
+ }
+
+ var TimeColsSlatsCoords = /** @class */ (function () {
+ function TimeColsSlatsCoords(positions, dateProfile, slotDuration) {
+ this.positions = positions;
+ this.dateProfile = dateProfile;
+ this.slotDuration = slotDuration;
+ }
+ TimeColsSlatsCoords.prototype.safeComputeTop = function (date) {
+ var dateProfile = this.dateProfile;
+ if (rangeContainsMarker(dateProfile.currentRange, date)) {
+ var startOfDayDate = startOfDay(date);
+ var timeMs = date.valueOf() - startOfDayDate.valueOf();
+ if (timeMs >= asRoughMs(dateProfile.slotMinTime) &&
+ timeMs < asRoughMs(dateProfile.slotMaxTime)) {
+ return this.computeTimeTop(createDuration(timeMs));
+ }
+ }
+ return null;
+ };
+ // Computes the top coordinate, relative to the bounds of the grid, of the given date.
+ // A `startOfDayDate` must be given for avoiding ambiguity over how to treat midnight.
+ TimeColsSlatsCoords.prototype.computeDateTop = function (when, startOfDayDate) {
+ if (!startOfDayDate) {
+ startOfDayDate = startOfDay(when);
+ }
+ return this.computeTimeTop(createDuration(when.valueOf() - startOfDayDate.valueOf()));
+ };
+ // Computes the top coordinate, relative to the bounds of the grid, of the given time (a Duration).
+ // This is a makeshify way to compute the time-top. Assumes all slatMetas dates are uniform.
+ // Eventually allow computation with arbirary slat dates.
+ TimeColsSlatsCoords.prototype.computeTimeTop = function (duration) {
+ var _a = this, positions = _a.positions, dateProfile = _a.dateProfile;
+ var len = positions.els.length;
+ // floating-point value of # of slots covered
+ var slatCoverage = (duration.milliseconds - asRoughMs(dateProfile.slotMinTime)) / asRoughMs(this.slotDuration);
+ var slatIndex;
+ var slatRemainder;
+ // compute a floating-point number for how many slats should be progressed through.
+ // from 0 to number of slats (inclusive)
+ // constrained because slotMinTime/slotMaxTime might be customized.
+ slatCoverage = Math.max(0, slatCoverage);
+ slatCoverage = Math.min(len, slatCoverage);
+ // an integer index of the furthest whole slat
+ // from 0 to number slats (*exclusive*, so len-1)
+ slatIndex = Math.floor(slatCoverage);
+ slatIndex = Math.min(slatIndex, len - 1);
+ // how much further through the slatIndex slat (from 0.0-1.0) must be covered in addition.
+ // could be 1.0 if slatCoverage is covering *all* the slots
+ slatRemainder = slatCoverage - slatIndex;
+ return positions.tops[slatIndex] +
+ positions.getHeight(slatIndex) * slatRemainder;
+ };
+ return TimeColsSlatsCoords;
+ }());
+
+ var TimeColsSlatsBody = /** @class */ (function (_super) {
+ __extends(TimeColsSlatsBody, _super);
+ function TimeColsSlatsBody() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimeColsSlatsBody.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var options = context.options;
+ var slatElRefs = props.slatElRefs;
+ return (createElement("tbody", null, props.slatMetas.map(function (slatMeta, i) {
+ var hookProps = {
+ time: slatMeta.time,
+ date: context.dateEnv.toDate(slatMeta.date),
+ view: context.viewApi,
+ };
+ var classNames = [
+ 'fc-timegrid-slot',
+ 'fc-timegrid-slot-lane',
+ slatMeta.isLabeled ? '' : 'fc-timegrid-slot-minor',
+ ];
+ return (createElement("tr", { key: slatMeta.key, ref: slatElRefs.createRef(slatMeta.key) },
+ props.axis && (createElement(TimeColsAxisCell, __assign({}, slatMeta))),
+ createElement(RenderHook, { hookProps: hookProps, classNames: options.slotLaneClassNames, content: options.slotLaneContent, didMount: options.slotLaneDidMount, willUnmount: options.slotLaneWillUnmount }, function (rootElRef, customClassNames, innerElRef, innerContent) { return (createElement("td", { ref: rootElRef, className: classNames.concat(customClassNames).join(' '), "data-time": slatMeta.isoTimeStr }, innerContent)); })));
+ })));
+ };
+ return TimeColsSlatsBody;
+ }(BaseComponent));
+
+ /*
+ for the horizontal "slats" that run width-wise. Has a time axis on a side. Depends on RTL.
+ */
+ var TimeColsSlats = /** @class */ (function (_super) {
+ __extends(TimeColsSlats, _super);
+ function TimeColsSlats() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.rootElRef = createRef();
+ _this.slatElRefs = new RefMap();
+ return _this;
+ }
+ TimeColsSlats.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ return (createElement("div", { ref: this.rootElRef, className: "fc-timegrid-slots" },
+ createElement("table", { "aria-hidden": true, className: context.theme.getClass('table'), style: {
+ minWidth: props.tableMinWidth,
+ width: props.clientWidth,
+ height: props.minHeight,
+ } },
+ props.tableColGroupNode /* relies on there only being a single for the axis */,
+ createElement(TimeColsSlatsBody, { slatElRefs: this.slatElRefs, axis: props.axis, slatMetas: props.slatMetas }))));
+ };
+ TimeColsSlats.prototype.componentDidMount = function () {
+ this.updateSizing();
+ };
+ TimeColsSlats.prototype.componentDidUpdate = function () {
+ this.updateSizing();
+ };
+ TimeColsSlats.prototype.componentWillUnmount = function () {
+ if (this.props.onCoords) {
+ this.props.onCoords(null);
+ }
+ };
+ TimeColsSlats.prototype.updateSizing = function () {
+ var _a = this, context = _a.context, props = _a.props;
+ if (props.onCoords &&
+ props.clientWidth !== null // means sizing has stabilized
+ ) {
+ var rootEl = this.rootElRef.current;
+ if (rootEl.offsetHeight) { // not hidden by css
+ props.onCoords(new TimeColsSlatsCoords(new PositionCache(this.rootElRef.current, collectSlatEls(this.slatElRefs.currentMap, props.slatMetas), false, true), this.props.dateProfile, context.options.slotDuration));
+ }
+ }
+ };
+ return TimeColsSlats;
+ }(BaseComponent));
+ function collectSlatEls(elMap, slatMetas) {
+ return slatMetas.map(function (slatMeta) { return elMap[slatMeta.key]; });
+ }
+
+ function splitSegsByCol(segs, colCnt) {
+ var segsByCol = [];
+ var i;
+ for (i = 0; i < colCnt; i += 1) {
+ segsByCol.push([]);
+ }
+ if (segs) {
+ for (i = 0; i < segs.length; i += 1) {
+ segsByCol[segs[i].col].push(segs[i]);
+ }
+ }
+ return segsByCol;
+ }
+ function splitInteractionByCol(ui, colCnt) {
+ var byRow = [];
+ if (!ui) {
+ for (var i = 0; i < colCnt; i += 1) {
+ byRow[i] = null;
+ }
+ }
+ else {
+ for (var i = 0; i < colCnt; i += 1) {
+ byRow[i] = {
+ affectedInstances: ui.affectedInstances,
+ isEvent: ui.isEvent,
+ segs: [],
+ };
+ }
+ for (var _i = 0, _a = ui.segs; _i < _a.length; _i++) {
+ var seg = _a[_i];
+ byRow[seg.col].segs.push(seg);
+ }
+ }
+ return byRow;
+ }
+
+ var TimeColMoreLink = /** @class */ (function (_super) {
+ __extends(TimeColMoreLink, _super);
+ function TimeColMoreLink() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.rootElRef = createRef();
+ return _this;
+ }
+ TimeColMoreLink.prototype.render = function () {
+ var _this = this;
+ var props = this.props;
+ return (createElement(MoreLinkRoot, { allDayDate: null, moreCnt: props.hiddenSegs.length, allSegs: props.hiddenSegs, hiddenSegs: props.hiddenSegs, alignmentElRef: this.rootElRef, defaultContent: renderMoreLinkInner, extraDateSpan: props.extraDateSpan, dateProfile: props.dateProfile, todayRange: props.todayRange, popoverContent: function () { return renderPlainFgSegs(props.hiddenSegs, props); } }, function (rootElRef, classNames, innerElRef, innerContent, handleClick, title, isExpanded, popoverId) { return (createElement("a", { ref: function (el) {
+ setRef(rootElRef, el);
+ setRef(_this.rootElRef, el);
+ }, className: ['fc-timegrid-more-link'].concat(classNames).join(' '), style: { top: props.top, bottom: props.bottom }, onClick: handleClick, title: title, "aria-expanded": isExpanded, "aria-controls": popoverId },
+ createElement("div", { ref: innerElRef, className: "fc-timegrid-more-link-inner fc-sticky" }, innerContent))); }));
+ };
+ return TimeColMoreLink;
+ }(BaseComponent));
+ function renderMoreLinkInner(props) {
+ return props.shortText;
+ }
+
+ // segInputs assumed sorted
+ function buildPositioning(segInputs, strictOrder, maxStackCnt) {
+ var hierarchy = new SegHierarchy();
+ if (strictOrder != null) {
+ hierarchy.strictOrder = strictOrder;
+ }
+ if (maxStackCnt != null) {
+ hierarchy.maxStackCnt = maxStackCnt;
+ }
+ var hiddenEntries = hierarchy.addSegs(segInputs);
+ var hiddenGroups = groupIntersectingEntries(hiddenEntries);
+ var web = buildWeb(hierarchy);
+ web = stretchWeb(web, 1); // all levelCoords/thickness will have 0.0-1.0
+ var segRects = webToRects(web);
+ return { segRects: segRects, hiddenGroups: hiddenGroups };
+ }
+ function buildWeb(hierarchy) {
+ var entriesByLevel = hierarchy.entriesByLevel;
+ var buildNode = cacheable(function (level, lateral) { return level + ':' + lateral; }, function (level, lateral) {
+ var siblingRange = findNextLevelSegs(hierarchy, level, lateral);
+ var nextLevelRes = buildNodes(siblingRange, buildNode);
+ var entry = entriesByLevel[level][lateral];
+ return [
+ __assign(__assign({}, entry), { nextLevelNodes: nextLevelRes[0] }),
+ entry.thickness + nextLevelRes[1], // the pressure builds
+ ];
+ });
+ return buildNodes(entriesByLevel.length
+ ? { level: 0, lateralStart: 0, lateralEnd: entriesByLevel[0].length }
+ : null, buildNode)[0];
+ }
+ function buildNodes(siblingRange, buildNode) {
+ if (!siblingRange) {
+ return [[], 0];
+ }
+ var level = siblingRange.level, lateralStart = siblingRange.lateralStart, lateralEnd = siblingRange.lateralEnd;
+ var lateral = lateralStart;
+ var pairs = [];
+ while (lateral < lateralEnd) {
+ pairs.push(buildNode(level, lateral));
+ lateral += 1;
+ }
+ pairs.sort(cmpDescPressures);
+ return [
+ pairs.map(extractNode),
+ pairs[0][1], // first item's pressure
+ ];
+ }
+ function cmpDescPressures(a, b) {
+ return b[1] - a[1];
+ }
+ function extractNode(a) {
+ return a[0];
+ }
+ function findNextLevelSegs(hierarchy, subjectLevel, subjectLateral) {
+ var levelCoords = hierarchy.levelCoords, entriesByLevel = hierarchy.entriesByLevel;
+ var subjectEntry = entriesByLevel[subjectLevel][subjectLateral];
+ var afterSubject = levelCoords[subjectLevel] + subjectEntry.thickness;
+ var levelCnt = levelCoords.length;
+ var level = subjectLevel;
+ // skip past levels that are too high up
+ for (; level < levelCnt && levelCoords[level] < afterSubject; level += 1)
+ ; // do nothing
+ for (; level < levelCnt; level += 1) {
+ var entries = entriesByLevel[level];
+ var entry = void 0;
+ var searchIndex = binarySearch(entries, subjectEntry.span.start, getEntrySpanEnd);
+ var lateralStart = searchIndex[0] + searchIndex[1]; // if exact match (which doesn't collide), go to next one
+ var lateralEnd = lateralStart;
+ while ( // loop through entries that horizontally intersect
+ (entry = entries[lateralEnd]) && // but not past the whole seg list
+ entry.span.start < subjectEntry.span.end) {
+ lateralEnd += 1;
+ }
+ if (lateralStart < lateralEnd) {
+ return { level: level, lateralStart: lateralStart, lateralEnd: lateralEnd };
+ }
+ }
+ return null;
+ }
+ function stretchWeb(topLevelNodes, totalThickness) {
+ var stretchNode = cacheable(function (node, startCoord, prevThickness) { return buildEntryKey(node); }, function (node, startCoord, prevThickness) {
+ var nextLevelNodes = node.nextLevelNodes, thickness = node.thickness;
+ var allThickness = thickness + prevThickness;
+ var thicknessFraction = thickness / allThickness;
+ var endCoord;
+ var newChildren = [];
+ if (!nextLevelNodes.length) {
+ endCoord = totalThickness;
+ }
+ else {
+ for (var _i = 0, nextLevelNodes_1 = nextLevelNodes; _i < nextLevelNodes_1.length; _i++) {
+ var childNode = nextLevelNodes_1[_i];
+ if (endCoord === undefined) {
+ var res = stretchNode(childNode, startCoord, allThickness);
+ endCoord = res[0];
+ newChildren.push(res[1]);
+ }
+ else {
+ var res = stretchNode(childNode, endCoord, 0);
+ newChildren.push(res[1]);
+ }
+ }
+ }
+ var newThickness = (endCoord - startCoord) * thicknessFraction;
+ return [endCoord - newThickness, __assign(__assign({}, node), { thickness: newThickness, nextLevelNodes: newChildren })];
+ });
+ return topLevelNodes.map(function (node) { return stretchNode(node, 0, 0)[1]; });
+ }
+ // not sorted in any particular order
+ function webToRects(topLevelNodes) {
+ var rects = [];
+ var processNode = cacheable(function (node, levelCoord, stackDepth) { return buildEntryKey(node); }, function (node, levelCoord, stackDepth) {
+ var rect = __assign(__assign({}, node), { levelCoord: levelCoord,
+ stackDepth: stackDepth, stackForward: 0 });
+ rects.push(rect);
+ return (rect.stackForward = processNodes(node.nextLevelNodes, levelCoord + node.thickness, stackDepth + 1) + 1);
+ });
+ function processNodes(nodes, levelCoord, stackDepth) {
+ var stackForward = 0;
+ for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+ var node = nodes_1[_i];
+ stackForward = Math.max(processNode(node, levelCoord, stackDepth), stackForward);
+ }
+ return stackForward;
+ }
+ processNodes(topLevelNodes, 0, 0);
+ return rects; // TODO: sort rects by levelCoord to be consistent with toRects?
+ }
+ // TODO: move to general util
+ function cacheable(keyFunc, workFunc) {
+ var cache = {};
+ return function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var key = keyFunc.apply(void 0, args);
+ return (key in cache)
+ ? cache[key]
+ : (cache[key] = workFunc.apply(void 0, args));
+ };
+ }
+
+ function computeSegVCoords(segs, colDate, slatCoords, eventMinHeight) {
+ if (slatCoords === void 0) { slatCoords = null; }
+ if (eventMinHeight === void 0) { eventMinHeight = 0; }
+ var vcoords = [];
+ if (slatCoords) {
+ for (var i = 0; i < segs.length; i += 1) {
+ var seg = segs[i];
+ var spanStart = slatCoords.computeDateTop(seg.start, colDate);
+ var spanEnd = Math.max(spanStart + (eventMinHeight || 0), // :(
+ slatCoords.computeDateTop(seg.end, colDate));
+ vcoords.push({
+ start: Math.round(spanStart),
+ end: Math.round(spanEnd), //
+ });
+ }
+ }
+ return vcoords;
+ }
+ function computeFgSegPlacements$1(segs, segVCoords, // might not have for every seg
+ eventOrderStrict, eventMaxStack) {
+ var segInputs = [];
+ var dumbSegs = []; // segs without coords
+ for (var i = 0; i < segs.length; i += 1) {
+ var vcoords = segVCoords[i];
+ if (vcoords) {
+ segInputs.push({
+ index: i,
+ thickness: 1,
+ span: vcoords,
+ });
+ }
+ else {
+ dumbSegs.push(segs[i]);
+ }
+ }
+ var _a = buildPositioning(segInputs, eventOrderStrict, eventMaxStack), segRects = _a.segRects, hiddenGroups = _a.hiddenGroups;
+ var segPlacements = [];
+ for (var _i = 0, segRects_1 = segRects; _i < segRects_1.length; _i++) {
+ var segRect = segRects_1[_i];
+ segPlacements.push({
+ seg: segs[segRect.index],
+ rect: segRect,
+ });
+ }
+ for (var _b = 0, dumbSegs_1 = dumbSegs; _b < dumbSegs_1.length; _b++) {
+ var dumbSeg = dumbSegs_1[_b];
+ segPlacements.push({ seg: dumbSeg, rect: null });
+ }
+ return { segPlacements: segPlacements, hiddenGroups: hiddenGroups };
+ }
+
+ var DEFAULT_TIME_FORMAT$2 = createFormatter({
+ hour: 'numeric',
+ minute: '2-digit',
+ meridiem: false,
+ });
+ var TimeColEvent = /** @class */ (function (_super) {
+ __extends(TimeColEvent, _super);
+ function TimeColEvent() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimeColEvent.prototype.render = function () {
+ var classNames = [
+ 'fc-timegrid-event',
+ 'fc-v-event',
+ ];
+ if (this.props.isShort) {
+ classNames.push('fc-timegrid-event-short');
+ }
+ return (createElement(StandardEvent, __assign({}, this.props, { defaultTimeFormat: DEFAULT_TIME_FORMAT$2, extraClassNames: classNames })));
+ };
+ return TimeColEvent;
+ }(BaseComponent));
+
+ var TimeColMisc = /** @class */ (function (_super) {
+ __extends(TimeColMisc, _super);
+ function TimeColMisc() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimeColMisc.prototype.render = function () {
+ var props = this.props;
+ return (createElement(DayCellContent, { date: props.date, dateProfile: props.dateProfile, todayRange: props.todayRange, extraHookProps: props.extraHookProps }, function (innerElRef, innerContent) { return (innerContent &&
+ createElement("div", { className: "fc-timegrid-col-misc", ref: innerElRef }, innerContent)); }));
+ };
+ return TimeColMisc;
+ }(BaseComponent));
+
+ var TimeCol = /** @class */ (function (_super) {
+ __extends(TimeCol, _super);
+ function TimeCol() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.sortEventSegs = memoize(sortEventSegs);
+ return _this;
+ }
+ // TODO: memoize event-placement?
+ TimeCol.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var isSelectMirror = context.options.selectMirror;
+ var mirrorSegs = (props.eventDrag && props.eventDrag.segs) ||
+ (props.eventResize && props.eventResize.segs) ||
+ (isSelectMirror && props.dateSelectionSegs) ||
+ [];
+ var interactionAffectedInstances = // TODO: messy way to compute this
+ (props.eventDrag && props.eventDrag.affectedInstances) ||
+ (props.eventResize && props.eventResize.affectedInstances) ||
+ {};
+ var sortedFgSegs = this.sortEventSegs(props.fgEventSegs, context.options.eventOrder);
+ return (createElement(DayCellRoot, { elRef: props.elRef, date: props.date, dateProfile: props.dateProfile, todayRange: props.todayRange, extraHookProps: props.extraHookProps }, function (rootElRef, classNames, dataAttrs) { return (createElement("td", __assign({ ref: rootElRef, role: "gridcell", className: ['fc-timegrid-col'].concat(classNames, props.extraClassNames || []).join(' ') }, dataAttrs, props.extraDataAttrs),
+ createElement("div", { className: "fc-timegrid-col-frame" },
+ createElement("div", { className: "fc-timegrid-col-bg" },
+ _this.renderFillSegs(props.businessHourSegs, 'non-business'),
+ _this.renderFillSegs(props.bgEventSegs, 'bg-event'),
+ _this.renderFillSegs(props.dateSelectionSegs, 'highlight')),
+ createElement("div", { className: "fc-timegrid-col-events" }, _this.renderFgSegs(sortedFgSegs, interactionAffectedInstances, false, false, false)),
+ createElement("div", { className: "fc-timegrid-col-events" }, _this.renderFgSegs(mirrorSegs, {}, Boolean(props.eventDrag), Boolean(props.eventResize), Boolean(isSelectMirror))),
+ createElement("div", { className: "fc-timegrid-now-indicator-container" }, _this.renderNowIndicator(props.nowIndicatorSegs)),
+ createElement(TimeColMisc, { date: props.date, dateProfile: props.dateProfile, todayRange: props.todayRange, extraHookProps: props.extraHookProps })))); }));
+ };
+ TimeCol.prototype.renderFgSegs = function (sortedFgSegs, segIsInvisible, isDragging, isResizing, isDateSelecting) {
+ var props = this.props;
+ if (props.forPrint) {
+ return renderPlainFgSegs(sortedFgSegs, props);
+ }
+ return this.renderPositionedFgSegs(sortedFgSegs, segIsInvisible, isDragging, isResizing, isDateSelecting);
+ };
+ TimeCol.prototype.renderPositionedFgSegs = function (segs, // if not mirror, needs to be sorted
+ segIsInvisible, isDragging, isResizing, isDateSelecting) {
+ var _this = this;
+ var _a = this.context.options, eventMaxStack = _a.eventMaxStack, eventShortHeight = _a.eventShortHeight, eventOrderStrict = _a.eventOrderStrict, eventMinHeight = _a.eventMinHeight;
+ var _b = this.props, date = _b.date, slatCoords = _b.slatCoords, eventSelection = _b.eventSelection, todayRange = _b.todayRange, nowDate = _b.nowDate;
+ var isMirror = isDragging || isResizing || isDateSelecting;
+ var segVCoords = computeSegVCoords(segs, date, slatCoords, eventMinHeight);
+ var _c = computeFgSegPlacements$1(segs, segVCoords, eventOrderStrict, eventMaxStack), segPlacements = _c.segPlacements, hiddenGroups = _c.hiddenGroups;
+ return (createElement(Fragment, null,
+ this.renderHiddenGroups(hiddenGroups, segs),
+ segPlacements.map(function (segPlacement) {
+ var seg = segPlacement.seg, rect = segPlacement.rect;
+ var instanceId = seg.eventRange.instance.instanceId;
+ var isVisible = isMirror || Boolean(!segIsInvisible[instanceId] && rect);
+ var vStyle = computeSegVStyle(rect && rect.span);
+ var hStyle = (!isMirror && rect) ? _this.computeSegHStyle(rect) : { left: 0, right: 0 };
+ var isInset = Boolean(rect) && rect.stackForward > 0;
+ var isShort = Boolean(rect) && (rect.span.end - rect.span.start) < eventShortHeight; // look at other places for this problem
+ return (createElement("div", { className: 'fc-timegrid-event-harness' +
+ (isInset ? ' fc-timegrid-event-harness-inset' : ''), key: instanceId, style: __assign(__assign({ visibility: isVisible ? '' : 'hidden' }, vStyle), hStyle) },
+ createElement(TimeColEvent, __assign({ seg: seg, isDragging: isDragging, isResizing: isResizing, isDateSelecting: isDateSelecting, isSelected: instanceId === eventSelection, isShort: isShort }, getSegMeta(seg, todayRange, nowDate)))));
+ })));
+ };
+ // will already have eventMinHeight applied because segInputs already had it
+ TimeCol.prototype.renderHiddenGroups = function (hiddenGroups, segs) {
+ var _a = this.props, extraDateSpan = _a.extraDateSpan, dateProfile = _a.dateProfile, todayRange = _a.todayRange, nowDate = _a.nowDate, eventSelection = _a.eventSelection, eventDrag = _a.eventDrag, eventResize = _a.eventResize;
+ return (createElement(Fragment, null, hiddenGroups.map(function (hiddenGroup) {
+ var positionCss = computeSegVStyle(hiddenGroup.span);
+ var hiddenSegs = compileSegsFromEntries(hiddenGroup.entries, segs);
+ return (createElement(TimeColMoreLink, { key: buildIsoString(computeEarliestSegStart(hiddenSegs)), hiddenSegs: hiddenSegs, top: positionCss.top, bottom: positionCss.bottom, extraDateSpan: extraDateSpan, dateProfile: dateProfile, todayRange: todayRange, nowDate: nowDate, eventSelection: eventSelection, eventDrag: eventDrag, eventResize: eventResize }));
+ })));
+ };
+ TimeCol.prototype.renderFillSegs = function (segs, fillType) {
+ var _a = this, props = _a.props, context = _a.context;
+ var segVCoords = computeSegVCoords(segs, props.date, props.slatCoords, context.options.eventMinHeight); // don't assume all populated
+ var children = segVCoords.map(function (vcoords, i) {
+ var seg = segs[i];
+ return (createElement("div", { key: buildEventRangeKey(seg.eventRange), className: "fc-timegrid-bg-harness", style: computeSegVStyle(vcoords) }, fillType === 'bg-event' ?
+ createElement(BgEvent, __assign({ seg: seg }, getSegMeta(seg, props.todayRange, props.nowDate))) :
+ renderFill(fillType)));
+ });
+ return createElement(Fragment, null, children);
+ };
+ TimeCol.prototype.renderNowIndicator = function (segs) {
+ var _a = this.props, slatCoords = _a.slatCoords, date = _a.date;
+ if (!slatCoords) {
+ return null;
+ }
+ return segs.map(function (seg, i) { return (createElement(NowIndicatorRoot, { isAxis: false, date: date,
+ // key doesn't matter. will only ever be one
+ key: i }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("div", { ref: rootElRef, className: ['fc-timegrid-now-indicator-line'].concat(classNames).join(' '), style: { top: slatCoords.computeDateTop(seg.start, date) } }, innerContent)); })); });
+ };
+ TimeCol.prototype.computeSegHStyle = function (segHCoords) {
+ var _a = this.context, isRtl = _a.isRtl, options = _a.options;
+ var shouldOverlap = options.slotEventOverlap;
+ var nearCoord = segHCoords.levelCoord; // the left side if LTR. the right side if RTL. floating-point
+ var farCoord = segHCoords.levelCoord + segHCoords.thickness; // the right side if LTR. the left side if RTL. floating-point
+ var left; // amount of space from left edge, a fraction of the total width
+ var right; // amount of space from right edge, a fraction of the total width
+ if (shouldOverlap) {
+ // double the width, but don't go beyond the maximum forward coordinate (1.0)
+ farCoord = Math.min(1, nearCoord + (farCoord - nearCoord) * 2);
+ }
+ if (isRtl) {
+ left = 1 - farCoord;
+ right = nearCoord;
+ }
+ else {
+ left = nearCoord;
+ right = 1 - farCoord;
+ }
+ var props = {
+ zIndex: segHCoords.stackDepth + 1,
+ left: left * 100 + '%',
+ right: right * 100 + '%',
+ };
+ if (shouldOverlap && !segHCoords.stackForward) {
+ // add padding to the edge so that forward stacked events don't cover the resizer's icon
+ props[isRtl ? 'marginLeft' : 'marginRight'] = 10 * 2; // 10 is a guesstimate of the icon's width
+ }
+ return props;
+ };
+ return TimeCol;
+ }(BaseComponent));
+ function renderPlainFgSegs(sortedFgSegs, _a) {
+ var todayRange = _a.todayRange, nowDate = _a.nowDate, eventSelection = _a.eventSelection, eventDrag = _a.eventDrag, eventResize = _a.eventResize;
+ var hiddenInstances = (eventDrag ? eventDrag.affectedInstances : null) ||
+ (eventResize ? eventResize.affectedInstances : null) ||
+ {};
+ return (createElement(Fragment, null, sortedFgSegs.map(function (seg) {
+ var instanceId = seg.eventRange.instance.instanceId;
+ return (createElement("div", { key: instanceId, style: { visibility: hiddenInstances[instanceId] ? 'hidden' : '' } },
+ createElement(TimeColEvent, __assign({ seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: instanceId === eventSelection, isShort: false }, getSegMeta(seg, todayRange, nowDate)))));
+ })));
+ }
+ function computeSegVStyle(segVCoords) {
+ if (!segVCoords) {
+ return { top: '', bottom: '' };
+ }
+ return {
+ top: segVCoords.start,
+ bottom: -segVCoords.end,
+ };
+ }
+ function compileSegsFromEntries(segEntries, allSegs) {
+ return segEntries.map(function (segEntry) { return allSegs[segEntry.index]; });
+ }
+
+ var TimeColsContent = /** @class */ (function (_super) {
+ __extends(TimeColsContent, _super);
+ function TimeColsContent() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.splitFgEventSegs = memoize(splitSegsByCol);
+ _this.splitBgEventSegs = memoize(splitSegsByCol);
+ _this.splitBusinessHourSegs = memoize(splitSegsByCol);
+ _this.splitNowIndicatorSegs = memoize(splitSegsByCol);
+ _this.splitDateSelectionSegs = memoize(splitSegsByCol);
+ _this.splitEventDrag = memoize(splitInteractionByCol);
+ _this.splitEventResize = memoize(splitInteractionByCol);
+ _this.rootElRef = createRef();
+ _this.cellElRefs = new RefMap();
+ return _this;
+ }
+ TimeColsContent.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var nowIndicatorTop = context.options.nowIndicator &&
+ props.slatCoords &&
+ props.slatCoords.safeComputeTop(props.nowDate); // might return void
+ var colCnt = props.cells.length;
+ var fgEventSegsByRow = this.splitFgEventSegs(props.fgEventSegs, colCnt);
+ var bgEventSegsByRow = this.splitBgEventSegs(props.bgEventSegs, colCnt);
+ var businessHourSegsByRow = this.splitBusinessHourSegs(props.businessHourSegs, colCnt);
+ var nowIndicatorSegsByRow = this.splitNowIndicatorSegs(props.nowIndicatorSegs, colCnt);
+ var dateSelectionSegsByRow = this.splitDateSelectionSegs(props.dateSelectionSegs, colCnt);
+ var eventDragByRow = this.splitEventDrag(props.eventDrag, colCnt);
+ var eventResizeByRow = this.splitEventResize(props.eventResize, colCnt);
+ return (createElement("div", { className: "fc-timegrid-cols", ref: this.rootElRef },
+ createElement("table", { role: "presentation", style: {
+ minWidth: props.tableMinWidth,
+ width: props.clientWidth,
+ } },
+ props.tableColGroupNode,
+ createElement("tbody", { role: "presentation" },
+ createElement("tr", { role: "row" },
+ props.axis && (createElement("td", { "aria-hidden": true, className: "fc-timegrid-col fc-timegrid-axis" },
+ createElement("div", { className: "fc-timegrid-col-frame" },
+ createElement("div", { className: "fc-timegrid-now-indicator-container" }, typeof nowIndicatorTop === 'number' && (createElement(NowIndicatorRoot, { isAxis: true, date: props.nowDate }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("div", { ref: rootElRef, className: ['fc-timegrid-now-indicator-arrow'].concat(classNames).join(' '), style: { top: nowIndicatorTop } }, innerContent)); })))))),
+ props.cells.map(function (cell, i) { return (createElement(TimeCol, { key: cell.key, elRef: _this.cellElRefs.createRef(cell.key), dateProfile: props.dateProfile, date: cell.date, nowDate: props.nowDate, todayRange: props.todayRange, extraHookProps: cell.extraHookProps, extraDataAttrs: cell.extraDataAttrs, extraClassNames: cell.extraClassNames, extraDateSpan: cell.extraDateSpan, fgEventSegs: fgEventSegsByRow[i], bgEventSegs: bgEventSegsByRow[i], businessHourSegs: businessHourSegsByRow[i], nowIndicatorSegs: nowIndicatorSegsByRow[i], dateSelectionSegs: dateSelectionSegsByRow[i], eventDrag: eventDragByRow[i], eventResize: eventResizeByRow[i], slatCoords: props.slatCoords, eventSelection: props.eventSelection, forPrint: props.forPrint })); }))))));
+ };
+ TimeColsContent.prototype.componentDidMount = function () {
+ this.updateCoords();
+ };
+ TimeColsContent.prototype.componentDidUpdate = function () {
+ this.updateCoords();
+ };
+ TimeColsContent.prototype.updateCoords = function () {
+ var props = this.props;
+ if (props.onColCoords &&
+ props.clientWidth !== null // means sizing has stabilized
+ ) {
+ props.onColCoords(new PositionCache(this.rootElRef.current, collectCellEls$1(this.cellElRefs.currentMap, props.cells), true, // horizontal
+ false));
+ }
+ };
+ return TimeColsContent;
+ }(BaseComponent));
+ function collectCellEls$1(elMap, cells) {
+ return cells.map(function (cell) { return elMap[cell.key]; });
+ }
+
+ /* A component that renders one or more columns of vertical time slots
+ ----------------------------------------------------------------------------------------------------------------------*/
+ var TimeCols = /** @class */ (function (_super) {
+ __extends(TimeCols, _super);
+ function TimeCols() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.processSlotOptions = memoize(processSlotOptions);
+ _this.state = {
+ slatCoords: null,
+ };
+ _this.handleRootEl = function (el) {
+ if (el) {
+ _this.context.registerInteractiveComponent(_this, {
+ el: el,
+ isHitComboAllowed: _this.props.isHitComboAllowed,
+ });
+ }
+ else {
+ _this.context.unregisterInteractiveComponent(_this);
+ }
+ };
+ _this.handleScrollRequest = function (request) {
+ var onScrollTopRequest = _this.props.onScrollTopRequest;
+ var slatCoords = _this.state.slatCoords;
+ if (onScrollTopRequest && slatCoords) {
+ if (request.time) {
+ var top_1 = slatCoords.computeTimeTop(request.time);
+ top_1 = Math.ceil(top_1); // zoom can give weird floating-point values. rather scroll a little bit further
+ if (top_1) {
+ top_1 += 1; // to overcome top border that slots beyond the first have. looks better
+ }
+ onScrollTopRequest(top_1);
+ }
+ return true;
+ }
+ return false;
+ };
+ _this.handleColCoords = function (colCoords) {
+ _this.colCoords = colCoords;
+ };
+ _this.handleSlatCoords = function (slatCoords) {
+ _this.setState({ slatCoords: slatCoords });
+ if (_this.props.onSlatCoords) {
+ _this.props.onSlatCoords(slatCoords);
+ }
+ };
+ return _this;
+ }
+ TimeCols.prototype.render = function () {
+ var _a = this, props = _a.props, state = _a.state;
+ return (createElement("div", { className: "fc-timegrid-body", ref: this.handleRootEl, style: {
+ // these props are important to give this wrapper correct dimensions for interactions
+ // TODO: if we set it here, can we avoid giving to inner tables?
+ width: props.clientWidth,
+ minWidth: props.tableMinWidth,
+ } },
+ createElement(TimeColsSlats, { axis: props.axis, dateProfile: props.dateProfile, slatMetas: props.slatMetas, clientWidth: props.clientWidth, minHeight: props.expandRows ? props.clientHeight : '', tableMinWidth: props.tableMinWidth, tableColGroupNode: props.axis ? props.tableColGroupNode : null /* axis depends on the colgroup's shrinking */, onCoords: this.handleSlatCoords }),
+ createElement(TimeColsContent, { cells: props.cells, axis: props.axis, dateProfile: props.dateProfile, businessHourSegs: props.businessHourSegs, bgEventSegs: props.bgEventSegs, fgEventSegs: props.fgEventSegs, dateSelectionSegs: props.dateSelectionSegs, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, todayRange: props.todayRange, nowDate: props.nowDate, nowIndicatorSegs: props.nowIndicatorSegs, clientWidth: props.clientWidth, tableMinWidth: props.tableMinWidth, tableColGroupNode: props.tableColGroupNode, slatCoords: state.slatCoords, onColCoords: this.handleColCoords, forPrint: props.forPrint })));
+ };
+ TimeCols.prototype.componentDidMount = function () {
+ this.scrollResponder = this.context.createScrollResponder(this.handleScrollRequest);
+ };
+ TimeCols.prototype.componentDidUpdate = function (prevProps) {
+ this.scrollResponder.update(prevProps.dateProfile !== this.props.dateProfile);
+ };
+ TimeCols.prototype.componentWillUnmount = function () {
+ this.scrollResponder.detach();
+ };
+ TimeCols.prototype.queryHit = function (positionLeft, positionTop) {
+ var _a = this.context, dateEnv = _a.dateEnv, options = _a.options;
+ var colCoords = this.colCoords;
+ var dateProfile = this.props.dateProfile;
+ var slatCoords = this.state.slatCoords;
+ var _b = this.processSlotOptions(this.props.slotDuration, options.snapDuration), snapDuration = _b.snapDuration, snapsPerSlot = _b.snapsPerSlot;
+ var colIndex = colCoords.leftToIndex(positionLeft);
+ var slatIndex = slatCoords.positions.topToIndex(positionTop);
+ if (colIndex != null && slatIndex != null) {
+ var cell = this.props.cells[colIndex];
+ var slatTop = slatCoords.positions.tops[slatIndex];
+ var slatHeight = slatCoords.positions.getHeight(slatIndex);
+ var partial = (positionTop - slatTop) / slatHeight; // floating point number between 0 and 1
+ var localSnapIndex = Math.floor(partial * snapsPerSlot); // the snap # relative to start of slat
+ var snapIndex = slatIndex * snapsPerSlot + localSnapIndex;
+ var dayDate = this.props.cells[colIndex].date;
+ var time = addDurations(dateProfile.slotMinTime, multiplyDuration(snapDuration, snapIndex));
+ var start = dateEnv.add(dayDate, time);
+ var end = dateEnv.add(start, snapDuration);
+ return {
+ dateProfile: dateProfile,
+ dateSpan: __assign({ range: { start: start, end: end }, allDay: false }, cell.extraDateSpan),
+ dayEl: colCoords.els[colIndex],
+ rect: {
+ left: colCoords.lefts[colIndex],
+ right: colCoords.rights[colIndex],
+ top: slatTop,
+ bottom: slatTop + slatHeight,
+ },
+ layer: 0,
+ };
+ }
+ return null;
+ };
+ return TimeCols;
+ }(DateComponent));
+ function processSlotOptions(slotDuration, snapDurationOverride) {
+ var snapDuration = snapDurationOverride || slotDuration;
+ var snapsPerSlot = wholeDivideDurations(slotDuration, snapDuration);
+ if (snapsPerSlot === null) {
+ snapDuration = slotDuration;
+ snapsPerSlot = 1;
+ // TODO: say warning?
+ }
+ return { snapDuration: snapDuration, snapsPerSlot: snapsPerSlot };
+ }
+
+ var DayTimeColsSlicer = /** @class */ (function (_super) {
+ __extends(DayTimeColsSlicer, _super);
+ function DayTimeColsSlicer() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ DayTimeColsSlicer.prototype.sliceRange = function (range, dayRanges) {
+ var segs = [];
+ for (var col = 0; col < dayRanges.length; col += 1) {
+ var segRange = intersectRanges(range, dayRanges[col]);
+ if (segRange) {
+ segs.push({
+ start: segRange.start,
+ end: segRange.end,
+ isStart: segRange.start.valueOf() === range.start.valueOf(),
+ isEnd: segRange.end.valueOf() === range.end.valueOf(),
+ col: col,
+ });
+ }
+ }
+ return segs;
+ };
+ return DayTimeColsSlicer;
+ }(Slicer));
+
+ var DayTimeCols = /** @class */ (function (_super) {
+ __extends(DayTimeCols, _super);
+ function DayTimeCols() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.buildDayRanges = memoize(buildDayRanges);
+ _this.slicer = new DayTimeColsSlicer();
+ _this.timeColsRef = createRef();
+ return _this;
+ }
+ DayTimeCols.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var dateProfile = props.dateProfile, dayTableModel = props.dayTableModel;
+ var isNowIndicator = context.options.nowIndicator;
+ var dayRanges = this.buildDayRanges(dayTableModel, dateProfile, context.dateEnv);
+ // give it the first row of cells
+ // TODO: would move this further down hierarchy, but sliceNowDate needs it
+ return (createElement(NowTimer, { unit: isNowIndicator ? 'minute' : 'day' }, function (nowDate, todayRange) { return (createElement(TimeCols, __assign({ ref: _this.timeColsRef }, _this.slicer.sliceProps(props, dateProfile, null, context, dayRanges), { forPrint: props.forPrint, axis: props.axis, dateProfile: dateProfile, slatMetas: props.slatMetas, slotDuration: props.slotDuration, cells: dayTableModel.cells[0], tableColGroupNode: props.tableColGroupNode, tableMinWidth: props.tableMinWidth, clientWidth: props.clientWidth, clientHeight: props.clientHeight, expandRows: props.expandRows, nowDate: nowDate, nowIndicatorSegs: isNowIndicator && _this.slicer.sliceNowDate(nowDate, context, dayRanges), todayRange: todayRange, onScrollTopRequest: props.onScrollTopRequest, onSlatCoords: props.onSlatCoords }))); }));
+ };
+ return DayTimeCols;
+ }(DateComponent));
+ function buildDayRanges(dayTableModel, dateProfile, dateEnv) {
+ var ranges = [];
+ for (var _i = 0, _a = dayTableModel.headerDates; _i < _a.length; _i++) {
+ var date = _a[_i];
+ ranges.push({
+ start: dateEnv.add(date, dateProfile.slotMinTime),
+ end: dateEnv.add(date, dateProfile.slotMaxTime),
+ });
+ }
+ return ranges;
+ }
+
+ // potential nice values for the slot-duration and interval-duration
+ // from largest to smallest
+ var STOCK_SUB_DURATIONS$1 = [
+ { hours: 1 },
+ { minutes: 30 },
+ { minutes: 15 },
+ { seconds: 30 },
+ { seconds: 15 },
+ ];
+ function buildSlatMetas(slotMinTime, slotMaxTime, explicitLabelInterval, slotDuration, dateEnv) {
+ var dayStart = new Date(0);
+ var slatTime = slotMinTime;
+ var slatIterator = createDuration(0);
+ var labelInterval = explicitLabelInterval || computeLabelInterval(slotDuration);
+ var metas = [];
+ while (asRoughMs(slatTime) < asRoughMs(slotMaxTime)) {
+ var date = dateEnv.add(dayStart, slatTime);
+ var isLabeled = wholeDivideDurations(slatIterator, labelInterval) !== null;
+ metas.push({
+ date: date,
+ time: slatTime,
+ key: date.toISOString(),
+ isoTimeStr: formatIsoTimeString(date),
+ isLabeled: isLabeled,
+ });
+ slatTime = addDurations(slatTime, slotDuration);
+ slatIterator = addDurations(slatIterator, slotDuration);
+ }
+ return metas;
+ }
+ // Computes an automatic value for slotLabelInterval
+ function computeLabelInterval(slotDuration) {
+ var i;
+ var labelInterval;
+ var slotsPerLabel;
+ // find the smallest stock label interval that results in more than one slots-per-label
+ for (i = STOCK_SUB_DURATIONS$1.length - 1; i >= 0; i -= 1) {
+ labelInterval = createDuration(STOCK_SUB_DURATIONS$1[i]);
+ slotsPerLabel = wholeDivideDurations(labelInterval, slotDuration);
+ if (slotsPerLabel !== null && slotsPerLabel > 1) {
+ return labelInterval;
+ }
+ }
+ return slotDuration; // fall back
+ }
+
+ var DayTimeColsView = /** @class */ (function (_super) {
+ __extends(DayTimeColsView, _super);
+ function DayTimeColsView() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.buildTimeColsModel = memoize(buildTimeColsModel);
+ _this.buildSlatMetas = memoize(buildSlatMetas);
+ return _this;
+ }
+ DayTimeColsView.prototype.render = function () {
+ var _this = this;
+ var _a = this.context, options = _a.options, dateEnv = _a.dateEnv, dateProfileGenerator = _a.dateProfileGenerator;
+ var props = this.props;
+ var dateProfile = props.dateProfile;
+ var dayTableModel = this.buildTimeColsModel(dateProfile, dateProfileGenerator);
+ var splitProps = this.allDaySplitter.splitProps(props);
+ var slatMetas = this.buildSlatMetas(dateProfile.slotMinTime, dateProfile.slotMaxTime, options.slotLabelInterval, options.slotDuration, dateEnv);
+ var dayMinWidth = options.dayMinWidth;
+ var hasAttachedAxis = !dayMinWidth;
+ var hasDetachedAxis = dayMinWidth;
+ var headerContent = options.dayHeaders && (createElement(DayHeader, { dates: dayTableModel.headerDates, dateProfile: dateProfile, datesRepDistinctDays: true, renderIntro: hasAttachedAxis ? this.renderHeadAxis : null }));
+ var allDayContent = (options.allDaySlot !== false) && (function (contentArg) { return (createElement(DayTable, __assign({}, splitProps.allDay, { dateProfile: dateProfile, dayTableModel: dayTableModel, nextDayThreshold: options.nextDayThreshold, tableMinWidth: contentArg.tableMinWidth, colGroupNode: contentArg.tableColGroupNode, renderRowIntro: hasAttachedAxis ? _this.renderTableRowAxis : null, showWeekNumbers: false, expandRows: false, headerAlignElRef: _this.headerElRef, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, forPrint: props.forPrint }, _this.getAllDayMaxEventProps()))); });
+ var timeGridContent = function (contentArg) { return (createElement(DayTimeCols, __assign({}, splitProps.timed, { dayTableModel: dayTableModel, dateProfile: dateProfile, axis: hasAttachedAxis, slotDuration: options.slotDuration, slatMetas: slatMetas, forPrint: props.forPrint, tableColGroupNode: contentArg.tableColGroupNode, tableMinWidth: contentArg.tableMinWidth, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, onSlatCoords: _this.handleSlatCoords, expandRows: contentArg.expandRows, onScrollTopRequest: _this.handleScrollTopRequest }))); };
+ return hasDetachedAxis
+ ? this.renderHScrollLayout(headerContent, allDayContent, timeGridContent, dayTableModel.colCnt, dayMinWidth, slatMetas, this.state.slatCoords)
+ : this.renderSimpleLayout(headerContent, allDayContent, timeGridContent);
+ };
+ return DayTimeColsView;
+ }(TimeColsView));
+ function buildTimeColsModel(dateProfile, dateProfileGenerator) {
+ var daySeries = new DaySeriesModel(dateProfile.renderRange, dateProfileGenerator);
+ return new DayTableModel(daySeries, false);
+ }
+
+ var OPTION_REFINERS$4 = {
+ allDaySlot: Boolean,
+ };
+
+ var timeGridPlugin = createPlugin({
+ initialView: 'timeGridWeek',
+ optionRefiners: OPTION_REFINERS$4,
+ views: {
+ timeGrid: {
+ component: DayTimeColsView,
+ usesMinMaxTime: true,
+ allDaySlot: true,
+ slotDuration: '00:30:00',
+ slotEventOverlap: true, // a bad name. confused with overlap/constraint system
+ },
+ timeGridDay: {
+ type: 'timeGrid',
+ duration: { days: 1 },
+ },
+ timeGridWeek: {
+ type: 'timeGrid',
+ duration: { weeks: 1 },
+ },
+ },
+ });
+
+ var ListViewHeaderRow = /** @class */ (function (_super) {
+ __extends(ListViewHeaderRow, _super);
+ function ListViewHeaderRow() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.state = {
+ textId: getUniqueDomId(),
+ };
+ return _this;
+ }
+ ListViewHeaderRow.prototype.render = function () {
+ var _a = this.context, theme = _a.theme, dateEnv = _a.dateEnv, options = _a.options, viewApi = _a.viewApi;
+ var _b = this.props, cellId = _b.cellId, dayDate = _b.dayDate, todayRange = _b.todayRange;
+ var textId = this.state.textId;
+ var dayMeta = getDateMeta(dayDate, todayRange);
+ // will ever be falsy?
+ var text = options.listDayFormat ? dateEnv.format(dayDate, options.listDayFormat) : '';
+ // will ever be falsy? also, BAD NAME "alt"
+ var sideText = options.listDaySideFormat ? dateEnv.format(dayDate, options.listDaySideFormat) : '';
+ var hookProps = __assign({ date: dateEnv.toDate(dayDate), view: viewApi, textId: textId,
+ text: text,
+ sideText: sideText, navLinkAttrs: buildNavLinkAttrs(this.context, dayDate), sideNavLinkAttrs: buildNavLinkAttrs(this.context, dayDate, 'day', false) }, dayMeta);
+ var classNames = ['fc-list-day'].concat(getDayClassNames(dayMeta, theme));
+ // TODO: make a reusable HOC for dayHeader (used in daygrid/timegrid too)
+ return (createElement(RenderHook, { hookProps: hookProps, classNames: options.dayHeaderClassNames, content: options.dayHeaderContent, defaultContent: renderInnerContent$2, didMount: options.dayHeaderDidMount, willUnmount: options.dayHeaderWillUnmount }, function (rootElRef, customClassNames, innerElRef, innerContent) { return (createElement("tr", { ref: rootElRef, className: classNames.concat(customClassNames).join(' '), "data-date": formatDayString(dayDate) },
+ createElement("th", { scope: "colgroup", colSpan: 3, id: cellId, "aria-labelledby": textId },
+ createElement("div", { className: 'fc-list-day-cushion ' + theme.getClass('tableCellShaded'), ref: innerElRef }, innerContent)))); }));
+ };
+ return ListViewHeaderRow;
+ }(BaseComponent));
+ function renderInnerContent$2(props) {
+ return (createElement(Fragment, null,
+ props.text && (createElement("a", __assign({ id: props.textId, className: "fc-list-day-text" }, props.navLinkAttrs), props.text)),
+ props.sideText && ( /* not keyboard tabbable */createElement("a", __assign({ "aria-hidden": true, className: "fc-list-day-side-text" }, props.sideNavLinkAttrs), props.sideText))));
+ }
+
+ var DEFAULT_TIME_FORMAT$1 = createFormatter({
+ hour: 'numeric',
+ minute: '2-digit',
+ meridiem: 'short',
+ });
+ var ListViewEventRow = /** @class */ (function (_super) {
+ __extends(ListViewEventRow, _super);
+ function ListViewEventRow() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ListViewEventRow.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var seg = props.seg, timeHeaderId = props.timeHeaderId, eventHeaderId = props.eventHeaderId, dateHeaderId = props.dateHeaderId;
+ var timeFormat = context.options.eventTimeFormat || DEFAULT_TIME_FORMAT$1;
+ return (createElement(EventRoot, { seg: seg, timeText: "" // BAD. because of all-day content
+ , disableDragging: true, disableResizing: true, defaultContent: function () { return renderEventInnerContent(seg, context); } /* weird */, isPast: props.isPast, isFuture: props.isFuture, isToday: props.isToday, isSelected: props.isSelected, isDragging: props.isDragging, isResizing: props.isResizing, isDateSelecting: props.isDateSelecting }, function (rootElRef, classNames, innerElRef, innerContent, hookProps) { return (createElement("tr", { className: ['fc-list-event', hookProps.event.url ? 'fc-event-forced-url' : ''].concat(classNames).join(' '), ref: rootElRef },
+ buildTimeContent(seg, timeFormat, context, timeHeaderId, dateHeaderId),
+ createElement("td", { "aria-hidden": true, className: "fc-list-event-graphic" },
+ createElement("span", { className: "fc-list-event-dot", style: { borderColor: hookProps.borderColor || hookProps.backgroundColor } })),
+ createElement("td", { ref: innerElRef, headers: eventHeaderId + " " + dateHeaderId, className: "fc-list-event-title" }, innerContent))); }));
+ };
+ return ListViewEventRow;
+ }(BaseComponent));
+ function renderEventInnerContent(seg, context) {
+ var interactiveAttrs = getSegAnchorAttrs(seg, context);
+ return (createElement("a", __assign({}, interactiveAttrs), seg.eventRange.def.title));
+ }
+ function buildTimeContent(seg, timeFormat, context, timeHeaderId, dateHeaderId) {
+ var options = context.options;
+ if (options.displayEventTime !== false) {
+ var eventDef = seg.eventRange.def;
+ var eventInstance = seg.eventRange.instance;
+ var doAllDay = false;
+ var timeText = void 0;
+ if (eventDef.allDay) {
+ doAllDay = true;
+ }
+ else if (isMultiDayRange(seg.eventRange.range)) { // TODO: use (!isStart || !isEnd) instead?
+ if (seg.isStart) {
+ timeText = buildSegTimeText(seg, timeFormat, context, null, null, eventInstance.range.start, seg.end);
+ }
+ else if (seg.isEnd) {
+ timeText = buildSegTimeText(seg, timeFormat, context, null, null, seg.start, eventInstance.range.end);
+ }
+ else {
+ doAllDay = true;
+ }
+ }
+ else {
+ timeText = buildSegTimeText(seg, timeFormat, context);
+ }
+ if (doAllDay) {
+ var hookProps = {
+ text: context.options.allDayText,
+ view: context.viewApi,
+ };
+ return (createElement(RenderHook, { hookProps: hookProps, classNames: options.allDayClassNames, content: options.allDayContent, defaultContent: renderAllDayInner, didMount: options.allDayDidMount, willUnmount: options.allDayWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("td", { ref: rootElRef, headers: timeHeaderId + " " + dateHeaderId, className: ['fc-list-event-time'].concat(classNames).join(' ') }, innerContent)); }));
+ }
+ return (createElement("td", { className: "fc-list-event-time" }, timeText));
+ }
+ return null;
+ }
+ function renderAllDayInner(hookProps) {
+ return hookProps.text;
+ }
+
+ /*
+ Responsible for the scroller, and forwarding event-related actions into the "grid".
+ */
+ var ListView = /** @class */ (function (_super) {
+ __extends(ListView, _super);
+ function ListView() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.computeDateVars = memoize(computeDateVars);
+ _this.eventStoreToSegs = memoize(_this._eventStoreToSegs);
+ _this.state = {
+ timeHeaderId: getUniqueDomId(),
+ eventHeaderId: getUniqueDomId(),
+ dateHeaderIdRoot: getUniqueDomId(),
+ };
+ _this.setRootEl = function (rootEl) {
+ if (rootEl) {
+ _this.context.registerInteractiveComponent(_this, {
+ el: rootEl,
+ });
+ }
+ else {
+ _this.context.unregisterInteractiveComponent(_this);
+ }
+ };
+ return _this;
+ }
+ ListView.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var extraClassNames = [
+ 'fc-list',
+ context.theme.getClass('table'),
+ context.options.stickyHeaderDates !== false ? 'fc-list-sticky' : '',
+ ];
+ var _b = this.computeDateVars(props.dateProfile), dayDates = _b.dayDates, dayRanges = _b.dayRanges;
+ var eventSegs = this.eventStoreToSegs(props.eventStore, props.eventUiBases, dayRanges);
+ return (createElement(ViewRoot, { viewSpec: context.viewSpec, elRef: this.setRootEl }, function (rootElRef, classNames) { return (createElement("div", { ref: rootElRef, className: extraClassNames.concat(classNames).join(' ') },
+ createElement(Scroller, { liquid: !props.isHeightAuto, overflowX: props.isHeightAuto ? 'visible' : 'hidden', overflowY: props.isHeightAuto ? 'visible' : 'auto' }, eventSegs.length > 0 ?
+ _this.renderSegList(eventSegs, dayDates) :
+ _this.renderEmptyMessage()))); }));
+ };
+ ListView.prototype.renderEmptyMessage = function () {
+ var _a = this.context, options = _a.options, viewApi = _a.viewApi;
+ var hookProps = {
+ text: options.noEventsText,
+ view: viewApi,
+ };
+ return (createElement(RenderHook, { hookProps: hookProps, classNames: options.noEventsClassNames, content: options.noEventsContent, defaultContent: renderNoEventsInner, didMount: options.noEventsDidMount, willUnmount: options.noEventsWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("div", { className: ['fc-list-empty'].concat(classNames).join(' '), ref: rootElRef },
+ createElement("div", { className: "fc-list-empty-cushion", ref: innerElRef }, innerContent))); }));
+ };
+ ListView.prototype.renderSegList = function (allSegs, dayDates) {
+ var _a = this.context, theme = _a.theme, options = _a.options;
+ var _b = this.state, timeHeaderId = _b.timeHeaderId, eventHeaderId = _b.eventHeaderId, dateHeaderIdRoot = _b.dateHeaderIdRoot;
+ var segsByDay = groupSegsByDay(allSegs); // sparse array
+ return (createElement(NowTimer, { unit: "day" }, function (nowDate, todayRange) {
+ var innerNodes = [];
+ for (var dayIndex = 0; dayIndex < segsByDay.length; dayIndex += 1) {
+ var daySegs = segsByDay[dayIndex];
+ if (daySegs) { // sparse array, so might be undefined
+ var dayStr = formatDayString(dayDates[dayIndex]);
+ var dateHeaderId = dateHeaderIdRoot + '-' + dayStr;
+ // append a day header
+ innerNodes.push(createElement(ListViewHeaderRow, { key: dayStr, cellId: dateHeaderId, dayDate: dayDates[dayIndex], todayRange: todayRange }));
+ daySegs = sortEventSegs(daySegs, options.eventOrder);
+ for (var _i = 0, daySegs_1 = daySegs; _i < daySegs_1.length; _i++) {
+ var seg = daySegs_1[_i];
+ innerNodes.push(createElement(ListViewEventRow, __assign({ key: dayStr + ':' + seg.eventRange.instance.instanceId /* are multiple segs for an instanceId */, seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, timeHeaderId: timeHeaderId, eventHeaderId: eventHeaderId, dateHeaderId: dateHeaderId }, getSegMeta(seg, todayRange, nowDate))));
+ }
+ }
+ }
+ return (createElement("table", { className: 'fc-list-table ' + theme.getClass('table') },
+ createElement("thead", null,
+ createElement("tr", null,
+ createElement("th", { scope: "col", id: timeHeaderId }, options.timeHint),
+ createElement("th", { scope: "col", "aria-hidden": true }),
+ createElement("th", { scope: "col", id: eventHeaderId }, options.eventHint))),
+ createElement("tbody", null, innerNodes)));
+ }));
+ };
+ ListView.prototype._eventStoreToSegs = function (eventStore, eventUiBases, dayRanges) {
+ return this.eventRangesToSegs(sliceEventStore(eventStore, eventUiBases, this.props.dateProfile.activeRange, this.context.options.nextDayThreshold).fg, dayRanges);
+ };
+ ListView.prototype.eventRangesToSegs = function (eventRanges, dayRanges) {
+ var segs = [];
+ for (var _i = 0, eventRanges_1 = eventRanges; _i < eventRanges_1.length; _i++) {
+ var eventRange = eventRanges_1[_i];
+ segs.push.apply(segs, this.eventRangeToSegs(eventRange, dayRanges));
+ }
+ return segs;
+ };
+ ListView.prototype.eventRangeToSegs = function (eventRange, dayRanges) {
+ var dateEnv = this.context.dateEnv;
+ var nextDayThreshold = this.context.options.nextDayThreshold;
+ var range = eventRange.range;
+ var allDay = eventRange.def.allDay;
+ var dayIndex;
+ var segRange;
+ var seg;
+ var segs = [];
+ for (dayIndex = 0; dayIndex < dayRanges.length; dayIndex += 1) {
+ segRange = intersectRanges(range, dayRanges[dayIndex]);
+ if (segRange) {
+ seg = {
+ component: this,
+ eventRange: eventRange,
+ start: segRange.start,
+ end: segRange.end,
+ isStart: eventRange.isStart && segRange.start.valueOf() === range.start.valueOf(),
+ isEnd: eventRange.isEnd && segRange.end.valueOf() === range.end.valueOf(),
+ dayIndex: dayIndex,
+ };
+ segs.push(seg);
+ // detect when range won't go fully into the next day,
+ // and mutate the latest seg to the be the end.
+ if (!seg.isEnd && !allDay &&
+ dayIndex + 1 < dayRanges.length &&
+ range.end <
+ dateEnv.add(dayRanges[dayIndex + 1].start, nextDayThreshold)) {
+ seg.end = range.end;
+ seg.isEnd = true;
+ break;
+ }
+ }
+ }
+ return segs;
+ };
+ return ListView;
+ }(DateComponent));
+ function renderNoEventsInner(hookProps) {
+ return hookProps.text;
+ }
+ function computeDateVars(dateProfile) {
+ var dayStart = startOfDay(dateProfile.renderRange.start);
+ var viewEnd = dateProfile.renderRange.end;
+ var dayDates = [];
+ var dayRanges = [];
+ while (dayStart < viewEnd) {
+ dayDates.push(dayStart);
+ dayRanges.push({
+ start: dayStart,
+ end: addDays(dayStart, 1),
+ });
+ dayStart = addDays(dayStart, 1);
+ }
+ return { dayDates: dayDates, dayRanges: dayRanges };
+ }
+ // Returns a sparse array of arrays, segs grouped by their dayIndex
+ function groupSegsByDay(segs) {
+ var segsByDay = []; // sparse array
+ var i;
+ var seg;
+ for (i = 0; i < segs.length; i += 1) {
+ seg = segs[i];
+ (segsByDay[seg.dayIndex] || (segsByDay[seg.dayIndex] = []))
+ .push(seg);
+ }
+ return segsByDay;
+ }
+
+ var OPTION_REFINERS$3 = {
+ listDayFormat: createFalsableFormatter,
+ listDaySideFormat: createFalsableFormatter,
+ noEventsClassNames: identity,
+ noEventsContent: identity,
+ noEventsDidMount: identity,
+ noEventsWillUnmount: identity,
+ // noEventsText is defined in base options
+ };
+ function createFalsableFormatter(input) {
+ return input === false ? null : createFormatter(input);
+ }
+
+ var listPlugin = createPlugin({
+ optionRefiners: OPTION_REFINERS$3,
+ views: {
+ list: {
+ component: ListView,
+ buttonTextKey: 'list',
+ listDayFormat: { month: 'long', day: 'numeric', year: 'numeric' }, // like "January 1, 2016"
+ },
+ listDay: {
+ type: 'list',
+ duration: { days: 1 },
+ listDayFormat: { weekday: 'long' }, // day-of-week is all we need. full date is probably in headerToolbar
+ },
+ listWeek: {
+ type: 'list',
+ duration: { weeks: 1 },
+ listDayFormat: { weekday: 'long' },
+ listDaySideFormat: { month: 'long', day: 'numeric', year: 'numeric' },
+ },
+ listMonth: {
+ type: 'list',
+ duration: { month: 1 },
+ listDaySideFormat: { weekday: 'long' }, // day-of-week is nice-to-have
+ },
+ listYear: {
+ type: 'list',
+ duration: { year: 1 },
+ listDaySideFormat: { weekday: 'long' }, // day-of-week is nice-to-have
+ },
+ },
+ });
+
+ var BootstrapTheme = /** @class */ (function (_super) {
+ __extends(BootstrapTheme, _super);
+ function BootstrapTheme() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ return BootstrapTheme;
+ }(Theme));
+ BootstrapTheme.prototype.classes = {
+ root: 'fc-theme-bootstrap',
+ table: 'table-bordered',
+ tableCellShaded: 'table-active',
+ buttonGroup: 'btn-group',
+ button: 'btn btn-primary',
+ buttonActive: 'active',
+ popover: 'popover',
+ popoverHeader: 'popover-header',
+ popoverContent: 'popover-body',
+ };
+ BootstrapTheme.prototype.baseIconClass = 'fa';
+ BootstrapTheme.prototype.iconClasses = {
+ close: 'fa-times',
+ prev: 'fa-chevron-left',
+ next: 'fa-chevron-right',
+ prevYear: 'fa-angle-double-left',
+ nextYear: 'fa-angle-double-right',
+ };
+ BootstrapTheme.prototype.rtlIconClasses = {
+ prev: 'fa-chevron-right',
+ next: 'fa-chevron-left',
+ prevYear: 'fa-angle-double-right',
+ nextYear: 'fa-angle-double-left',
+ };
+ BootstrapTheme.prototype.iconOverrideOption = 'bootstrapFontAwesome'; // TODO: make TS-friendly. move the option-processing into this plugin
+ BootstrapTheme.prototype.iconOverrideCustomButtonOption = 'bootstrapFontAwesome';
+ BootstrapTheme.prototype.iconOverridePrefix = 'fa-';
+ var plugin = createPlugin({
+ themeClasses: {
+ bootstrap: BootstrapTheme,
+ },
+ });
+
+ // rename this file to options.ts like other packages?
+ var OPTION_REFINERS$2 = {
+ googleCalendarApiKey: String,
+ };
+
+ var EVENT_SOURCE_REFINERS = {
+ googleCalendarApiKey: String,
+ googleCalendarId: String,
+ googleCalendarApiBase: String,
+ extraParams: identity,
+ };
+
+ // TODO: expose somehow
+ var API_BASE = 'https://www.googleapis.com/calendar/v3/calendars';
+ var eventSourceDef = {
+ parseMeta: function (refined) {
+ var googleCalendarId = refined.googleCalendarId;
+ if (!googleCalendarId && refined.url) {
+ googleCalendarId = parseGoogleCalendarId(refined.url);
+ }
+ if (googleCalendarId) {
+ return {
+ googleCalendarId: googleCalendarId,
+ googleCalendarApiKey: refined.googleCalendarApiKey,
+ googleCalendarApiBase: refined.googleCalendarApiBase,
+ extraParams: refined.extraParams,
+ };
+ }
+ return null;
+ },
+ fetch: function (arg, onSuccess, onFailure) {
+ var _a = arg.context, dateEnv = _a.dateEnv, options = _a.options;
+ var meta = arg.eventSource.meta;
+ var apiKey = meta.googleCalendarApiKey || options.googleCalendarApiKey;
+ if (!apiKey) {
+ onFailure({
+ message: 'Specify a googleCalendarApiKey. See http://fullcalendar.io/docs/google_calendar/',
+ });
+ }
+ else {
+ var url = buildUrl(meta);
+ // TODO: make DRY with json-feed-event-source
+ var extraParams = meta.extraParams;
+ var extraParamsObj = typeof extraParams === 'function' ? extraParams() : extraParams;
+ var requestParams_1 = buildRequestParams$1(arg.range, apiKey, extraParamsObj, dateEnv);
+ requestJson('GET', url, requestParams_1, function (body, xhr) {
+ if (body.error) {
+ onFailure({
+ message: 'Google Calendar API: ' + body.error.message,
+ errors: body.error.errors,
+ xhr: xhr,
+ });
+ }
+ else {
+ onSuccess({
+ rawEvents: gcalItemsToRawEventDefs(body.items, requestParams_1.timeZone),
+ xhr: xhr,
+ });
+ }
+ }, function (message, xhr) {
+ onFailure({ message: message, xhr: xhr });
+ });
+ }
+ },
+ };
+ function parseGoogleCalendarId(url) {
+ var match;
+ // detect if the ID was specified as a single string.
+ // will match calendars like "asdf1234@calendar.google.com" in addition to person email calendars.
+ if (/^[^/]+@([^/.]+\.)*(google|googlemail|gmail)\.com$/.test(url)) {
+ return url;
+ }
+ if ((match = /^https:\/\/www.googleapis.com\/calendar\/v3\/calendars\/([^/]*)/.exec(url)) ||
+ (match = /^https?:\/\/www.google.com\/calendar\/feeds\/([^/]*)/.exec(url))) {
+ return decodeURIComponent(match[1]);
+ }
+ return null;
+ }
+ function buildUrl(meta) {
+ var apiBase = meta.googleCalendarApiBase;
+ if (!apiBase) {
+ apiBase = API_BASE;
+ }
+ return apiBase + '/' + encodeURIComponent(meta.googleCalendarId) + '/events';
+ }
+ function buildRequestParams$1(range, apiKey, extraParams, dateEnv) {
+ var params;
+ var startStr;
+ var endStr;
+ if (dateEnv.canComputeOffset) {
+ // strings will naturally have offsets, which GCal needs
+ startStr = dateEnv.formatIso(range.start);
+ endStr = dateEnv.formatIso(range.end);
+ }
+ else {
+ // when timezone isn't known, we don't know what the UTC offset should be, so ask for +/- 1 day
+ // from the UTC day-start to guarantee we're getting all the events
+ // (start/end will be UTC-coerced dates, so toISOString is okay)
+ startStr = addDays(range.start, -1).toISOString();
+ endStr = addDays(range.end, 1).toISOString();
+ }
+ params = __assign(__assign({}, (extraParams || {})), { key: apiKey, timeMin: startStr, timeMax: endStr, singleEvents: true, maxResults: 9999 });
+ if (dateEnv.timeZone !== 'local') {
+ params.timeZone = dateEnv.timeZone;
+ }
+ return params;
+ }
+ function gcalItemsToRawEventDefs(items, gcalTimezone) {
+ return items.map(function (item) { return gcalItemToRawEventDef(item, gcalTimezone); });
+ }
+ function gcalItemToRawEventDef(item, gcalTimezone) {
+ var url = item.htmlLink || null;
+ // make the URLs for each event show times in the correct timezone
+ if (url && gcalTimezone) {
+ url = injectQsComponent(url, 'ctz=' + gcalTimezone);
+ }
+ return {
+ id: item.id,
+ title: item.summary,
+ start: item.start.dateTime || item.start.date,
+ end: item.end.dateTime || item.end.date,
+ url: url,
+ location: item.location,
+ description: item.description,
+ attachments: item.attachments || [],
+ extendedProps: (item.extendedProperties || {}).shared || {},
+ };
+ }
+ // Injects a string like "arg=value" into the querystring of a URL
+ // TODO: move to a general util file?
+ function injectQsComponent(url, component) {
+ // inject it after the querystring but before the fragment
+ return url.replace(/(\?.*?)?(#|$)/, function (whole, qs, hash) { return (qs ? qs + '&' : '?') + component + hash; });
+ }
+ var googleCalendarPlugin = createPlugin({
+ eventSourceDefs: [eventSourceDef],
+ optionRefiners: OPTION_REFINERS$2,
+ eventSourceRefiners: EVENT_SOURCE_REFINERS,
+ });
+
+ var RELEASE_DATE = '2021-11-03'; // for Scheduler
+ var UPGRADE_WINDOW = 365 + 7; // days. 1 week leeway, for tz shift reasons too
+ var INVALID_LICENSE_URL = 'http://fullcalendar.io/docs/schedulerLicenseKey#invalid';
+ var OUTDATED_LICENSE_URL = 'http://fullcalendar.io/docs/schedulerLicenseKey#outdated';
+ var PRESET_LICENSE_KEYS = [
+ 'GPL-My-Project-Is-Open-Source',
+ 'CC-Attribution-NonCommercial-NoDerivatives',
+ ];
+ var CSS = {
+ position: 'absolute',
+ zIndex: 99999,
+ bottom: '1px',
+ left: '1px',
+ background: '#eee',
+ borderColor: '#ddd',
+ borderStyle: 'solid',
+ borderWidth: '1px 1px 0 0',
+ padding: '2px 4px',
+ fontSize: '12px',
+ borderTopRightRadius: '3px',
+ };
+ function buildLicenseWarning(context) {
+ var key = context.options.schedulerLicenseKey;
+ var currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+ if (!isImmuneUrl(currentUrl)) {
+ var status_1 = processLicenseKey(key);
+ if (status_1 !== 'valid') {
+ return (createElement("div", { className: "fc-license-message", style: CSS }, (status_1 === 'outdated') ? (createElement(Fragment, null,
+ 'Your license key is too old to work with this version. ',
+ createElement("a", { href: OUTDATED_LICENSE_URL }, "More Info"))) : (createElement(Fragment, null,
+ 'Your license key is invalid. ',
+ createElement("a", { href: INVALID_LICENSE_URL }, "More Info")))));
+ }
+ }
+ return null;
+ }
+ /*
+ This decryption is not meant to be bulletproof. Just a way to remind about an upgrade.
+ */
+ function processLicenseKey(key) {
+ if (PRESET_LICENSE_KEYS.indexOf(key) !== -1) {
+ return 'valid';
+ }
+ var parts = (key || '').match(/^(\d+)-fcs-(\d+)$/);
+ if (parts && (parts[1].length === 10)) {
+ var purchaseDate = new Date(parseInt(parts[2], 10) * 1000);
+ var releaseDate = new Date(config.mockSchedulerReleaseDate || RELEASE_DATE);
+ if (isValidDate$1(releaseDate)) { // token won't be replaced in dev mode
+ var minPurchaseDate = addDays(releaseDate, -UPGRADE_WINDOW);
+ if (minPurchaseDate < purchaseDate) {
+ return 'valid';
+ }
+ return 'outdated';
+ }
+ }
+ return 'invalid';
+ }
+ function isImmuneUrl(url) {
+ return /\w+:\/\/fullcalendar\.io\/|\/examples\/[\w-]+\.html$/.test(url);
+ }
+
+ var OPTION_REFINERS$1 = {
+ schedulerLicenseKey: String,
+ };
+
+ var premiumCommonPlugin = createPlugin({
+ optionRefiners: OPTION_REFINERS$1,
+ viewContainerAppends: [buildLicenseWarning],
+ });
+
+ var WHEEL_EVENT_NAMES = 'wheel mousewheel DomMouseScroll MozMousePixelScroll'.split(' ');
+ /*
+ ALSO, with the ability to disable touch
+ */
+ var ScrollListener = /** @class */ (function () {
+ function ScrollListener(el) {
+ var _this = this;
+ 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 = function () {
+ _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 = function () {
+ _this.isRecentlyWheeled = true;
+ _this.wheelWaiter.request(500);
+ };
+ // will fire *before* the scroll event is fired (might not cause a scroll)
+ this.handleTouchStart = function () {
+ _this.isTouching = true;
+ };
+ this.handleTouchEnd = function () {
+ _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 (var _i = 0, WHEEL_EVENT_NAMES_1 = WHEEL_EVENT_NAMES; _i < WHEEL_EVENT_NAMES_1.length; _i++) {
+ var eventName = WHEEL_EVENT_NAMES_1[_i];
+ el.addEventListener(eventName, this.handleWheel);
+ }
+ }
+ ScrollListener.prototype.destroy = function () {
+ var el = this.el;
+ el.removeEventListener('scroll', this.handleScroll);
+ el.removeEventListener('touchstart', this.handleTouchStart, { passive: true });
+ el.removeEventListener('touchend', this.handleTouchEnd);
+ for (var _i = 0, WHEEL_EVENT_NAMES_2 = WHEEL_EVENT_NAMES; _i < WHEEL_EVENT_NAMES_2.length; _i++) {
+ var eventName = WHEEL_EVENT_NAMES_2[_i];
+ el.removeEventListener(eventName, this.handleWheel);
+ }
+ };
+ // Start / Stop
+ // ----------------------------------------------------------------------------------------------
+ ScrollListener.prototype.startScroll = function () {
+ if (!this.isScrolling) {
+ this.isScrolling = true;
+ this.emitter.trigger('scrollStart', this.isRecentlyWheeled, this.isTouching);
+ }
+ };
+ ScrollListener.prototype.endScroll = function () {
+ if (this.isScrolling) {
+ this.emitter.trigger('scrollEnd');
+ this.isScrolling = false;
+ this.isRecentlyScrolled = true;
+ this.isRecentlyWheeled = false;
+ this.scrollWaiter.clear();
+ this.wheelWaiter.clear();
+ }
+ };
+ ScrollListener.prototype._handleScrollWaited = function () {
+ 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
+ }
+ };
+ ScrollListener.prototype._handleWheelWaited = function () {
+ this.isRecentlyWheeled = false;
+ };
+ return ScrollListener;
+ }());
+
+ // TODO: assume the el has no borders?
+ function getScrollCanvasOrigin(scrollEl) {
+ var rect = scrollEl.getBoundingClientRect();
+ var edges = computeEdges(scrollEl); // TODO: pass in isRtl?
+ return {
+ left: rect.left + edges.borderLeft + edges.scrollbarLeft - getScrollFromLeftEdge(scrollEl),
+ top: rect.top + edges.borderTop - scrollEl.scrollTop,
+ };
+ }
+ function getScrollFromLeftEdge(el) {
+ var scrollLeft = el.scrollLeft;
+ var computedStyles = window.getComputedStyle(el); // TODO: pass in isRtl instead?
+ if (computedStyles.direction === 'rtl') {
+ switch (getRtlScrollSystem()) {
+ case 'negative':
+ scrollLeft *= -1; // convert to 'reverse'. fall through...
+ case 'reverse': // scrollLeft is distance between scrollframe's right edge scrollcanvas's right edge
+ scrollLeft = el.scrollWidth - scrollLeft - el.clientWidth;
+ }
+ }
+ return scrollLeft;
+ }
+ function setScrollFromLeftEdge(el, scrollLeft) {
+ var computedStyles = window.getComputedStyle(el); // TODO: pass in isRtl instead?
+ if (computedStyles.direction === 'rtl') {
+ switch (getRtlScrollSystem()) {
+ case 'reverse':
+ scrollLeft = el.scrollWidth - scrollLeft;
+ break;
+ case 'negative':
+ scrollLeft = -(el.scrollWidth - scrollLeft);
+ break;
+ }
+ }
+ el.scrollLeft = scrollLeft;
+ }
+ // Horizontal Scroll System Detection
+ // ----------------------------------------------------------------------------------------------
+ var _rtlScrollSystem;
+ function getRtlScrollSystem() {
+ return _rtlScrollSystem || (_rtlScrollSystem = detectRtlScrollSystem());
+ }
+ function detectRtlScrollSystem() {
+ var el = document.createElement('div');
+ el.style.position = 'absolute';
+ el.style.top = '-1000px';
+ el.style.width = '1px';
+ el.style.height = '1px';
+ el.style.overflow = 'scroll';
+ el.style.direction = 'rtl';
+ el.style.fontSize = '100px';
+ el.innerHTML = 'A';
+ document.body.appendChild(el);
+ var system;
+ if (el.scrollLeft > 0) {
+ system = 'positive'; // scroll is a positive number from the left edge
+ }
+ else {
+ el.scrollLeft = 1;
+ if (el.scrollLeft > 0) {
+ system = 'reverse'; // scroll is a positive number from the right edge
+ }
+ else {
+ system = 'negative'; // scroll is a negative number from the right edge
+ }
+ }
+ removeElement(el);
+ return system;
+ }
+
+ var IS_MS_EDGE = typeof navigator !== 'undefined' && /Edge/.test(navigator.userAgent); // TODO: what about Chromeum-based Edge?
+ var STICKY_SELECTOR = '.fc-sticky';
+ /*
+ useful beyond the native position:sticky for these reasons:
+ - support in IE11
+ - nice centering support
+
+ 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.
+
+ TODO: don't query text-align:center. isn't compatible with flexbox centering. instead, check natural X coord within parent container
+ */
+ var StickyScrolling = /** @class */ (function () {
+ function StickyScrolling(scrollEl, isRtl) {
+ var _this = this;
+ this.scrollEl = scrollEl;
+ this.isRtl = isRtl;
+ this.usingRelative = null;
+ this.updateSize = function () {
+ var scrollEl = _this.scrollEl;
+ var els = findElements(scrollEl, STICKY_SELECTOR);
+ var elGeoms = _this.queryElGeoms(els);
+ var viewportWidth = scrollEl.clientWidth;
+ var viewportHeight = scrollEl.clientHeight;
+ if (_this.usingRelative) {
+ var elDestinations = _this.computeElDestinations(elGeoms, viewportWidth); // read before prepPositioning
+ assignRelativePositions(els, elGeoms, elDestinations, viewportWidth, viewportHeight);
+ }
+ else {
+ 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);
+ }
+ }
+ StickyScrolling.prototype.destroy = function () {
+ if (this.listener) {
+ this.listener.destroy();
+ }
+ };
+ StickyScrolling.prototype.queryElGeoms = function (els) {
+ var _a = this, scrollEl = _a.scrollEl, isRtl = _a.isRtl;
+ var canvasOrigin = getScrollCanvasOrigin(scrollEl);
+ var elGeoms = [];
+ for (var _i = 0, els_1 = els; _i < els_1.length; _i++) {
+ var el = els_1[_i];
+ var parentBound = translateRect(computeInnerRect(el.parentNode, true, true), // weird way to call this!!!
+ -canvasOrigin.left, -canvasOrigin.top);
+ var elRect = el.getBoundingClientRect();
+ var computedStyles = window.getComputedStyle(el);
+ var textAlign = window.getComputedStyle(el.parentNode).textAlign; // ask the parent
+ var naturalBound = null;
+ if (textAlign === 'start') {
+ textAlign = isRtl ? 'right' : 'left';
+ }
+ else if (textAlign === 'end') {
+ textAlign = isRtl ? 'left' : 'right';
+ }
+ if (computedStyles.position !== 'sticky') {
+ naturalBound = translateRect(elRect, -canvasOrigin.left - (parseFloat(computedStyles.left) || 0), // could be 'auto'
+ -canvasOrigin.top - (parseFloat(computedStyles.top) || 0));
+ }
+ elGeoms.push({
+ parentBound: parentBound,
+ naturalBound: naturalBound,
+ elWidth: elRect.width,
+ elHeight: elRect.height,
+ textAlign: textAlign,
+ });
+ }
+ return elGeoms;
+ };
+ // only for IE
+ StickyScrolling.prototype.computeElDestinations = function (elGeoms, viewportWidth) {
+ var scrollEl = this.scrollEl;
+ var viewportTop = scrollEl.scrollTop;
+ var viewportLeft = getScrollFromLeftEdge(scrollEl);
+ var viewportRight = viewportLeft + viewportWidth;
+ return elGeoms.map(function (elGeom) {
+ var elWidth = elGeom.elWidth, elHeight = elGeom.elHeight, parentBound = elGeom.parentBound, naturalBound = elGeom.naturalBound;
+ var destLeft; // relative to canvas topleft
+ var 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 };
+ });
+ };
+ return StickyScrolling;
+ }());
+ function assignRelativePositions(els, elGeoms, elDestinations, viewportWidth, viewportHeight) {
+ els.forEach(function (el, i) {
+ var _a = elGeoms[i], naturalBound = _a.naturalBound, parentBound = _a.parentBound;
+ var parentWidth = parentBound.right - parentBound.left;
+ var parentHeight = parentBound.bottom - parentBound.bottom;
+ var left;
+ var 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 = '';
+ }
+ applyStyle(el, {
+ position: 'relative',
+ left: left,
+ right: -left,
+ top: top,
+ });
+ });
+ }
+ function assignStickyPositions(els, elGeoms, viewportWidth) {
+ els.forEach(function (el, i) {
+ var _a = elGeoms[i], textAlign = _a.textAlign, elWidth = _a.elWidth, parentBound = _a.parentBound;
+ var parentWidth = parentBound.right - parentBound.left;
+ var left;
+ if (textAlign === 'center' &&
+ parentWidth > viewportWidth) {
+ left = (viewportWidth - elWidth) / 2;
+ }
+ else { // if parent container can be completely in view, we don't need stickiness
+ left = '';
+ }
+ applyStyle(el, {
+ left: left,
+ right: left,
+ top: 0,
+ });
+ });
+ }
+ var _isStickySupported;
+ function getStickySupported() {
+ if (_isStickySupported == null) {
+ _isStickySupported = computeStickySupported();
+ }
+ return _isStickySupported;
+ }
+ function computeStickySupported() {
+ var el = document.createElement('div');
+ el.style.position = 'sticky';
+ document.body.appendChild(el);
+ var val = window.getComputedStyle(el).position;
+ removeElement(el);
+ return val === 'sticky';
+ }
+
+ var ClippedScroller = /** @class */ (function (_super) {
+ __extends(ClippedScroller, _super);
+ function ClippedScroller() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.elRef = createRef();
+ _this.state = {
+ xScrollbarWidth: 0,
+ yScrollbarWidth: 0,
+ };
+ _this.handleScroller = function (scroller) {
+ _this.scroller = scroller;
+ setRef(_this.props.scrollerRef, scroller);
+ };
+ _this.handleSizing = function () {
+ var props = _this.props;
+ if (props.overflowY === 'scroll-hidden') {
+ _this.setState({ yScrollbarWidth: _this.scroller.getYScrollbarWidth() });
+ }
+ if (props.overflowX === 'scroll-hidden') {
+ _this.setState({ xScrollbarWidth: _this.scroller.getXScrollbarWidth() });
+ }
+ };
+ return _this;
+ }
+ ClippedScroller.prototype.render = function () {
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ var isScrollbarOnLeft = context.isRtl && getIsRtlScrollbarOnLeft();
+ var overcomeLeft = 0;
+ var overcomeRight = 0;
+ var overcomeBottom = 0;
+ if (props.overflowX === 'scroll-hidden') {
+ overcomeBottom = state.xScrollbarWidth;
+ }
+ if (props.overflowY === 'scroll-hidden') {
+ if (state.yScrollbarWidth != null) {
+ if (isScrollbarOnLeft) {
+ overcomeLeft = state.yScrollbarWidth;
+ }
+ else {
+ overcomeRight = state.yScrollbarWidth;
+ }
+ }
+ }
+ return (createElement("div", { ref: this.elRef, className: 'fc-scroller-harness' + (props.liquid ? ' fc-scroller-harness-liquid' : '') },
+ createElement(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)));
+ };
+ ClippedScroller.prototype.componentDidMount = function () {
+ this.handleSizing();
+ this.context.addResizeHandler(this.handleSizing);
+ };
+ ClippedScroller.prototype.componentDidUpdate = function (prevProps) {
+ if (!isPropsEqual(prevProps, this.props)) { // an external change?
+ this.handleSizing();
+ }
+ };
+ ClippedScroller.prototype.componentWillUnmount = function () {
+ this.context.removeResizeHandler(this.handleSizing);
+ };
+ ClippedScroller.prototype.needsXScrolling = function () {
+ return this.scroller.needsXScrolling();
+ };
+ ClippedScroller.prototype.needsYScrolling = function () {
+ return this.scroller.needsYScrolling();
+ };
+ return ClippedScroller;
+ }(BaseComponent));
+
+ var ScrollSyncer = /** @class */ (function () {
+ function ScrollSyncer(isVertical, scrollEls) {
+ var _this = this;
+ this.isVertical = isVertical;
+ this.scrollEls = scrollEls;
+ this.isPaused = false;
+ this.scrollListeners = scrollEls.map(function (el) { return _this.bindScroller(el); });
+ }
+ ScrollSyncer.prototype.destroy = function () {
+ for (var _i = 0, _a = this.scrollListeners; _i < _a.length; _i++) {
+ var scrollListener = _a[_i];
+ scrollListener.destroy();
+ }
+ };
+ ScrollSyncer.prototype.bindScroller = function (el) {
+ var _this = this;
+ var _a = this, scrollEls = _a.scrollEls, isVertical = _a.isVertical;
+ var scrollListener = new ScrollListener(el);
+ var onScroll = function (isWheel, isTouch) {
+ if (!_this.isPaused) {
+ if (!_this.masterEl || (_this.masterEl !== el && (isWheel || isTouch))) {
+ _this.assignMaster(el);
+ }
+ if (_this.masterEl === el) { // dealing with current
+ for (var _i = 0, scrollEls_1 = scrollEls; _i < scrollEls_1.length; _i++) {
+ var otherEl = scrollEls_1[_i];
+ if (otherEl !== el) {
+ if (isVertical) {
+ otherEl.scrollTop = el.scrollTop;
+ }
+ else {
+ otherEl.scrollLeft = el.scrollLeft;
+ }
+ }
+ }
+ }
+ }
+ };
+ var onScrollEnd = function () {
+ if (_this.masterEl === el) {
+ _this.masterEl = null;
+ }
+ };
+ scrollListener.emitter.on('scroll', onScroll);
+ scrollListener.emitter.on('scrollEnd', onScrollEnd);
+ return scrollListener;
+ };
+ ScrollSyncer.prototype.assignMaster = function (el) {
+ this.masterEl = el;
+ for (var _i = 0, _a = this.scrollListeners; _i < _a.length; _i++) {
+ var scrollListener = _a[_i];
+ if (scrollListener.el !== el) {
+ scrollListener.endScroll(); // to prevent residual scrolls from reclaiming master
+ }
+ }
+ };
+ /*
+ will normalize the scrollLeft value
+ */
+ ScrollSyncer.prototype.forceScrollLeft = function (scrollLeft) {
+ this.isPaused = true;
+ for (var _i = 0, _a = this.scrollListeners; _i < _a.length; _i++) {
+ var listener = _a[_i];
+ setScrollFromLeftEdge(listener.el, scrollLeft);
+ }
+ this.isPaused = false;
+ };
+ ScrollSyncer.prototype.forceScrollTop = function (top) {
+ this.isPaused = true;
+ for (var _i = 0, _a = this.scrollListeners; _i < _a.length; _i++) {
+ var listener = _a[_i];
+ listener.el.scrollTop = top;
+ }
+ this.isPaused = false;
+ };
+ return ScrollSyncer;
+ }());
+
+ /*
+ TODO: make subcomponent
+ NOTE: doesn't support collapsibleWidth (which is sortof a hack anyway)
+ */
+ var ScrollGrid = /** @class */ (function (_super) {
+ __extends(ScrollGrid, _super);
+ function ScrollGrid() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.compileColGroupStats = memoizeArraylike(compileColGroupStat, isColGroupStatsEqual);
+ _this.renderMicroColGroups = memoizeArraylike(renderMicroColGroup); // yucky to memoize VNodes, but much more efficient for consumers
+ _this.clippedScrollerRefs = new RefMap();
+ // doesn't hold non-scrolling els used just for padding
+ _this.scrollerElRefs = new RefMap(_this._handleScrollerEl.bind(_this));
+ _this.chunkElRefs = new RefMap(_this._handleChunkEl.bind(_this));
+ _this.getStickyScrolling = memoizeArraylike(initStickyScrolling, null, destroyStickyScrolling);
+ _this.getScrollSyncersBySection = memoizeHashlike(initScrollSyncer.bind(_this, true), null, destroyScrollSyncer);
+ _this.getScrollSyncersByColumn = memoizeHashlike(initScrollSyncer.bind(_this, false), null, destroyScrollSyncer);
+ _this.stickyScrollings = [];
+ _this.scrollSyncersBySection = {};
+ _this.scrollSyncersByColumn = {};
+ // for row-height-syncing
+ _this.rowUnstableMap = new Map(); // no need to groom. always self-cancels
+ _this.rowInnerMaxHeightMap = new Map();
+ _this.anyRowHeightsChanged = false;
+ _this.recentSizingCnt = 0;
+ _this.state = {
+ shrinkWidths: [],
+ forceYScrollbars: false,
+ forceXScrollbars: false,
+ scrollerClientWidths: {},
+ scrollerClientHeights: {},
+ sectionRowMaxHeights: [],
+ };
+ _this.handleSizing = function (isForcedResize, sectionRowMaxHeightsChanged) {
+ if (!_this.allowSizing()) {
+ return;
+ }
+ if (!sectionRowMaxHeightsChanged) { // something else changed, probably external
+ _this.anyRowHeightsChanged = true;
+ }
+ var otherState = {};
+ // if reacting to self-change of sectionRowMaxHeightsChanged, or not stable, don't do anything
+ if (isForcedResize || (!sectionRowMaxHeightsChanged && !_this.rowUnstableMap.size)) {
+ otherState.sectionRowMaxHeights = _this.computeSectionRowMaxHeights();
+ }
+ _this.setState(__assign(__assign({ shrinkWidths: _this.computeShrinkWidths() }, _this.computeScrollerDims()), otherState), function () {
+ if (!_this.rowUnstableMap.size) {
+ _this.updateStickyScrolling(); // needs to happen AFTER final positioning committed to DOM
+ }
+ });
+ };
+ _this.handleRowHeightChange = function (rowEl, isStable) {
+ var _a = _this, rowUnstableMap = _a.rowUnstableMap, rowInnerMaxHeightMap = _a.rowInnerMaxHeightMap;
+ if (!isStable) {
+ rowUnstableMap.set(rowEl, true);
+ }
+ else {
+ rowUnstableMap.delete(rowEl);
+ var innerMaxHeight = getRowInnerMaxHeight(rowEl);
+ if (!rowInnerMaxHeightMap.has(rowEl) || rowInnerMaxHeightMap.get(rowEl) !== innerMaxHeight) {
+ rowInnerMaxHeightMap.set(rowEl, innerMaxHeight);
+ _this.anyRowHeightsChanged = true;
+ }
+ if (!rowUnstableMap.size && _this.anyRowHeightsChanged) {
+ _this.anyRowHeightsChanged = false;
+ _this.setState({
+ sectionRowMaxHeights: _this.computeSectionRowMaxHeights(),
+ });
+ }
+ }
+ };
+ return _this;
+ }
+ ScrollGrid.prototype.render = function () {
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ var shrinkWidths = state.shrinkWidths;
+ var colGroupStats = this.compileColGroupStats(props.colGroups.map(function (colGroup) { return [colGroup]; }));
+ var microColGroupNodes = this.renderMicroColGroups(colGroupStats.map(function (stat, i) { return [stat.cols, shrinkWidths[i]]; }));
+ var classNames = getScrollGridClassNames(props.liquid, context);
+ var _b = this.getDims(); _b[0]; _b[1];
+ // TODO: make DRY
+ var sectionConfigs = props.sections;
+ var configCnt = sectionConfigs.length;
+ var configI = 0;
+ var currentConfig;
+ var headSectionNodes = [];
+ var bodySectionNodes = [];
+ var footSectionNodes = [];
+ while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'header') {
+ headSectionNodes.push(this.renderSection(currentConfig, configI, colGroupStats, microColGroupNodes, state.sectionRowMaxHeights, true));
+ configI += 1;
+ }
+ while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'body') {
+ bodySectionNodes.push(this.renderSection(currentConfig, configI, colGroupStats, microColGroupNodes, state.sectionRowMaxHeights, false));
+ configI += 1;
+ }
+ while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'footer') {
+ footSectionNodes.push(this.renderSection(currentConfig, configI, colGroupStats, microColGroupNodes, state.sectionRowMaxHeights, true));
+ configI += 1;
+ }
+ var isBuggy = !getCanVGrowWithinCell(); // see NOTE in SimpleScrollGrid
+ var roleAttrs = { role: 'rowgroup' };
+ return createElement('table', {
+ ref: props.elRef,
+ role: 'grid',
+ className: classNames.join(' '),
+ }, renderMacroColGroup(colGroupStats, shrinkWidths), Boolean(!isBuggy && headSectionNodes.length) && createElement.apply(void 0, __spreadArray(['thead', roleAttrs], headSectionNodes)), Boolean(!isBuggy && bodySectionNodes.length) && createElement.apply(void 0, __spreadArray(['tbody', roleAttrs], bodySectionNodes)), Boolean(!isBuggy && footSectionNodes.length) && createElement.apply(void 0, __spreadArray(['tfoot', roleAttrs], footSectionNodes)), isBuggy && createElement.apply(void 0, __spreadArray(__spreadArray(__spreadArray(['tbody', roleAttrs], headSectionNodes), bodySectionNodes), footSectionNodes)));
+ };
+ ScrollGrid.prototype.renderSection = function (sectionConfig, sectionIndex, colGroupStats, microColGroupNodes, sectionRowMaxHeights, isHeader) {
+ var _this = this;
+ if ('outerContent' in sectionConfig) {
+ return (createElement(Fragment, { key: sectionConfig.key }, sectionConfig.outerContent));
+ }
+ return (createElement("tr", { key: sectionConfig.key, role: "presentation", className: getSectionClassNames(sectionConfig, this.props.liquid).join(' ') }, sectionConfig.chunks.map(function (chunkConfig, i) { return _this.renderChunk(sectionConfig, sectionIndex, colGroupStats[i], microColGroupNodes[i], chunkConfig, i, (sectionRowMaxHeights[sectionIndex] || [])[i] || [], isHeader); })));
+ };
+ ScrollGrid.prototype.renderChunk = function (sectionConfig, sectionIndex, colGroupStat, microColGroupNode, chunkConfig, chunkIndex, rowHeights, isHeader) {
+ if ('outerContent' in chunkConfig) {
+ return (createElement(Fragment, { key: chunkConfig.key }, chunkConfig.outerContent));
+ }
+ var state = this.state;
+ var scrollerClientWidths = state.scrollerClientWidths, scrollerClientHeights = state.scrollerClientHeights;
+ var _a = this.getDims(), sectionCnt = _a[0], chunksPerSection = _a[1];
+ var index = sectionIndex * chunksPerSection + chunkIndex;
+ var sideScrollIndex = (!this.context.isRtl || getIsRtlScrollbarOnLeft()) ? chunksPerSection - 1 : 0;
+ var isVScrollSide = chunkIndex === sideScrollIndex;
+ var isLastSection = sectionIndex === sectionCnt - 1;
+ var forceXScrollbars = isLastSection && state.forceXScrollbars; // NOOOO can result in `null`
+ var forceYScrollbars = isVScrollSide && state.forceYScrollbars; // NOOOO can result in `null`
+ var allowXScrolling = colGroupStat && colGroupStat.allowXScrolling; // rename?
+ var allowYScrolling = getAllowYScrolling(this.props, sectionConfig); // rename? do in section func?
+ var chunkVGrow = getSectionHasLiquidHeight(this.props, sectionConfig); // do in section func?
+ var expandRows = sectionConfig.expandRows && chunkVGrow;
+ var tableMinWidth = (colGroupStat && colGroupStat.totalColMinWidth) || '';
+ var content = renderChunkContent(sectionConfig, chunkConfig, {
+ tableColGroupNode: microColGroupNode,
+ tableMinWidth: tableMinWidth,
+ clientWidth: scrollerClientWidths[index] !== undefined ? scrollerClientWidths[index] : null,
+ clientHeight: scrollerClientHeights[index] !== undefined ? scrollerClientHeights[index] : null,
+ expandRows: expandRows,
+ syncRowHeights: Boolean(sectionConfig.syncRowHeights),
+ rowSyncHeights: rowHeights,
+ reportRowHeightChange: this.handleRowHeightChange,
+ }, isHeader);
+ var overflowX = forceXScrollbars ? (isLastSection ? 'scroll' : 'scroll-hidden') :
+ !allowXScrolling ? 'hidden' :
+ (isLastSection ? 'auto' : 'scroll-hidden');
+ var overflowY = forceYScrollbars ? (isVScrollSide ? 'scroll' : 'scroll-hidden') :
+ !allowYScrolling ? 'hidden' :
+ (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 = (createElement(ClippedScroller, { ref: this.clippedScrollerRefs.createRef(index), scrollerElRef: this.scrollerElRefs.createRef(index), overflowX: overflowX, overflowY: overflowY, liquid: chunkVGrow, maxHeight: sectionConfig.maxHeight }, content));
+ return createElement(isHeader ? 'th' : 'td', {
+ key: chunkConfig.key,
+ ref: this.chunkElRefs.createRef(index),
+ role: 'presentation',
+ }, content);
+ };
+ ScrollGrid.prototype.componentDidMount = function () {
+ this.updateScrollSyncers();
+ this.handleSizing(false);
+ this.context.addResizeHandler(this.handleSizing);
+ };
+ ScrollGrid.prototype.componentDidUpdate = function (prevProps, prevState) {
+ this.updateScrollSyncers();
+ // TODO: need better solution when state contains non-sizing things
+ this.handleSizing(false, prevState.sectionRowMaxHeights !== this.state.sectionRowMaxHeights);
+ };
+ ScrollGrid.prototype.componentWillUnmount = function () {
+ this.context.removeResizeHandler(this.handleSizing);
+ this.destroyStickyScrolling();
+ this.destroyScrollSyncers();
+ };
+ ScrollGrid.prototype.allowSizing = function () {
+ var now = new Date();
+ if (!this.lastSizingDate ||
+ now.valueOf() > this.lastSizingDate.valueOf() + config.SCROLLGRID_RESIZE_INTERVAL) {
+ this.lastSizingDate = now;
+ this.recentSizingCnt = 0;
+ return true;
+ }
+ return (this.recentSizingCnt += 1) <= 10;
+ };
+ ScrollGrid.prototype.computeShrinkWidths = function () {
+ var _this = this;
+ var colGroupStats = this.compileColGroupStats(this.props.colGroups.map(function (colGroup) { return [colGroup]; }));
+ var _a = this.getDims(), sectionCnt = _a[0], chunksPerSection = _a[1];
+ var cnt = sectionCnt * chunksPerSection;
+ var shrinkWidths = [];
+ colGroupStats.forEach(function (colGroupStat, i) {
+ if (colGroupStat.hasShrinkCol) {
+ var chunkEls = _this.chunkElRefs.collect(i, cnt, chunksPerSection); // in one col
+ shrinkWidths[i] = computeShrinkWidth(chunkEls);
+ }
+ });
+ return shrinkWidths;
+ };
+ // has the side effect of grooming rowInnerMaxHeightMap
+ // TODO: somehow short-circuit if there are no new height changes
+ ScrollGrid.prototype.computeSectionRowMaxHeights = function () {
+ var newHeightMap = new Map();
+ var _a = this.getDims(), sectionCnt = _a[0], chunksPerSection = _a[1];
+ var sectionRowMaxHeights = [];
+ for (var sectionI = 0; sectionI < sectionCnt; sectionI += 1) {
+ var sectionConfig = this.props.sections[sectionI];
+ var assignableHeights = []; // chunk, row
+ if (sectionConfig && sectionConfig.syncRowHeights) {
+ var rowHeightsByChunk = [];
+ for (var chunkI = 0; chunkI < chunksPerSection; chunkI += 1) {
+ var index = sectionI * chunksPerSection + chunkI;
+ var rowHeights = [];
+ var chunkEl = this.chunkElRefs.currentMap[index];
+ if (chunkEl) {
+ rowHeights = findElements(chunkEl, '.fc-scrollgrid-sync-table tr').map(function (rowEl) {
+ var max = getRowInnerMaxHeight(rowEl);
+ newHeightMap.set(rowEl, max);
+ return max;
+ });
+ }
+ else {
+ rowHeights = [];
+ }
+ rowHeightsByChunk.push(rowHeights);
+ }
+ var rowCnt = rowHeightsByChunk[0].length;
+ var isEqualRowCnt = true;
+ for (var chunkI = 1; chunkI < chunksPerSection; chunkI += 1) {
+ var isOuterContent = sectionConfig.chunks[chunkI] && sectionConfig.chunks[chunkI].outerContent !== undefined; // can be null
+ if (!isOuterContent && rowHeightsByChunk[chunkI].length !== rowCnt) { // skip outer content
+ isEqualRowCnt = false;
+ break;
+ }
+ }
+ if (!isEqualRowCnt) {
+ var chunkHeightSums = [];
+ for (var chunkI = 0; chunkI < chunksPerSection; chunkI += 1) {
+ chunkHeightSums.push(sumNumbers(rowHeightsByChunk[chunkI]) + rowHeightsByChunk[chunkI].length);
+ }
+ var maxTotalSum = Math.max.apply(Math, chunkHeightSums);
+ for (var chunkI = 0; chunkI < chunksPerSection; chunkI += 1) {
+ var rowInChunkCnt = rowHeightsByChunk[chunkI].length;
+ var rowInChunkTotalHeight = maxTotalSum - rowInChunkCnt; // subtract border
+ // height of non-first row. we do this to avoid rounding, because it's unreliable within a table
+ var rowInChunkHeightOthers = Math.floor(rowInChunkTotalHeight / rowInChunkCnt);
+ // whatever is leftover goes to the first row
+ var rowInChunkHeightFirst = rowInChunkTotalHeight - rowInChunkHeightOthers * (rowInChunkCnt - 1);
+ var rowInChunkHeights = [];
+ var row = 0;
+ if (row < rowInChunkCnt) {
+ rowInChunkHeights.push(rowInChunkHeightFirst);
+ row += 1;
+ }
+ while (row < rowInChunkCnt) {
+ rowInChunkHeights.push(rowInChunkHeightOthers);
+ row += 1;
+ }
+ assignableHeights.push(rowInChunkHeights);
+ }
+ }
+ else {
+ for (var chunkI = 0; chunkI < chunksPerSection; chunkI += 1) {
+ assignableHeights.push([]);
+ }
+ for (var row = 0; row < rowCnt; row += 1) {
+ var rowHeightsAcrossChunks = [];
+ for (var chunkI = 0; chunkI < chunksPerSection; chunkI += 1) {
+ var h = rowHeightsByChunk[chunkI][row];
+ if (h != null) { // protect against outerContent
+ rowHeightsAcrossChunks.push(h);
+ }
+ }
+ var maxHeight = Math.max.apply(Math, rowHeightsAcrossChunks);
+ for (var chunkI = 0; chunkI < chunksPerSection; chunkI += 1) {
+ assignableHeights[chunkI].push(maxHeight);
+ }
+ }
+ }
+ }
+ sectionRowMaxHeights.push(assignableHeights);
+ }
+ this.rowInnerMaxHeightMap = newHeightMap;
+ return sectionRowMaxHeights;
+ };
+ ScrollGrid.prototype.computeScrollerDims = function () {
+ var scrollbarWidth = getScrollbarWidths();
+ var _a = this.getDims(), sectionCnt = _a[0], chunksPerSection = _a[1];
+ var sideScrollI = (!this.context.isRtl || getIsRtlScrollbarOnLeft()) ? chunksPerSection - 1 : 0;
+ var lastSectionI = sectionCnt - 1;
+ var currentScrollers = this.clippedScrollerRefs.currentMap;
+ var scrollerEls = this.scrollerElRefs.currentMap;
+ var forceYScrollbars = false;
+ var forceXScrollbars = false;
+ var scrollerClientWidths = {};
+ var scrollerClientHeights = {};
+ for (var sectionI = 0; sectionI < sectionCnt; sectionI += 1) { // along edge
+ var index = sectionI * chunksPerSection + sideScrollI;
+ var scroller = currentScrollers[index];
+ if (scroller && scroller.needsYScrolling()) {
+ forceYScrollbars = true;
+ break;
+ }
+ }
+ for (var chunkI = 0; chunkI < chunksPerSection; chunkI += 1) { // along last row
+ var index = lastSectionI * chunksPerSection + chunkI;
+ var scroller = currentScrollers[index];
+ if (scroller && scroller.needsXScrolling()) {
+ forceXScrollbars = true;
+ break;
+ }
+ }
+ for (var sectionI = 0; sectionI < sectionCnt; sectionI += 1) {
+ for (var chunkI = 0; chunkI < chunksPerSection; chunkI += 1) {
+ var index = sectionI * chunksPerSection + chunkI;
+ var scrollerEl = scrollerEls[index];
+ if (scrollerEl) {
+ // TODO: weird way to get this. need harness b/c doesn't include table borders
+ var harnessEl = scrollerEl.parentNode;
+ scrollerClientWidths[index] = Math.floor(harnessEl.getBoundingClientRect().width - ((chunkI === sideScrollI && forceYScrollbars)
+ ? scrollbarWidth.y // use global because scroller might not have scrollbars yet but will need them in future
+ : 0));
+ scrollerClientHeights[index] = Math.floor(harnessEl.getBoundingClientRect().height - ((sectionI === lastSectionI && forceXScrollbars)
+ ? scrollbarWidth.x // use global because scroller might not have scrollbars yet but will need them in future
+ : 0));
+ }
+ }
+ }
+ return { forceYScrollbars: forceYScrollbars, forceXScrollbars: forceXScrollbars, scrollerClientWidths: scrollerClientWidths, scrollerClientHeights: scrollerClientHeights };
+ };
+ ScrollGrid.prototype.updateStickyScrolling = function () {
+ var isRtl = this.context.isRtl;
+ var argsByKey = this.scrollerElRefs.getAll().map(function (scrollEl) { return [scrollEl, isRtl]; });
+ var stickyScrollings = this.getStickyScrolling(argsByKey);
+ stickyScrollings.forEach(function (stickyScrolling) { return stickyScrolling.updateSize(); });
+ this.stickyScrollings = stickyScrollings;
+ };
+ ScrollGrid.prototype.destroyStickyScrolling = function () {
+ this.stickyScrollings.forEach(destroyStickyScrolling);
+ };
+ ScrollGrid.prototype.updateScrollSyncers = function () {
+ var _a = this.getDims(), sectionCnt = _a[0], chunksPerSection = _a[1];
+ var cnt = sectionCnt * chunksPerSection;
+ var scrollElsBySection = {};
+ var scrollElsByColumn = {};
+ var scrollElMap = this.scrollerElRefs.currentMap;
+ for (var sectionI = 0; sectionI < sectionCnt; sectionI += 1) {
+ var startIndex = sectionI * chunksPerSection;
+ var endIndex = startIndex + chunksPerSection;
+ scrollElsBySection[sectionI] = collectFromHash(scrollElMap, startIndex, endIndex, 1); // use the filtered
+ }
+ for (var col = 0; col < chunksPerSection; col += 1) {
+ scrollElsByColumn[col] = this.scrollerElRefs.collect(col, cnt, chunksPerSection); // DON'T use the filtered
+ }
+ this.scrollSyncersBySection = this.getScrollSyncersBySection(scrollElsBySection);
+ this.scrollSyncersByColumn = this.getScrollSyncersByColumn(scrollElsByColumn);
+ };
+ ScrollGrid.prototype.destroyScrollSyncers = function () {
+ mapHash(this.scrollSyncersBySection, destroyScrollSyncer);
+ mapHash(this.scrollSyncersByColumn, destroyScrollSyncer);
+ };
+ ScrollGrid.prototype.getChunkConfigByIndex = function (index) {
+ var chunksPerSection = this.getDims()[1];
+ var sectionI = Math.floor(index / chunksPerSection);
+ var chunkI = index % chunksPerSection;
+ var sectionConfig = this.props.sections[sectionI];
+ return sectionConfig && sectionConfig.chunks[chunkI];
+ };
+ ScrollGrid.prototype.forceScrollLeft = function (col, scrollLeft) {
+ var scrollSyncer = this.scrollSyncersByColumn[col];
+ if (scrollSyncer) {
+ scrollSyncer.forceScrollLeft(scrollLeft);
+ }
+ };
+ ScrollGrid.prototype.forceScrollTop = function (sectionI, scrollTop) {
+ var scrollSyncer = this.scrollSyncersBySection[sectionI];
+ if (scrollSyncer) {
+ scrollSyncer.forceScrollTop(scrollTop);
+ }
+ };
+ ScrollGrid.prototype._handleChunkEl = function (chunkEl, key) {
+ var chunkConfig = this.getChunkConfigByIndex(parseInt(key, 10));
+ if (chunkConfig) { // null if section disappeared. bad, b/c won't null-set the elRef
+ setRef(chunkConfig.elRef, chunkEl);
+ }
+ };
+ ScrollGrid.prototype._handleScrollerEl = function (scrollerEl, key) {
+ var chunkConfig = this.getChunkConfigByIndex(parseInt(key, 10));
+ if (chunkConfig) { // null if section disappeared. bad, b/c won't null-set the elRef
+ setRef(chunkConfig.scrollerElRef, scrollerEl);
+ }
+ };
+ ScrollGrid.prototype.getDims = function () {
+ var sectionCnt = this.props.sections.length;
+ var chunksPerSection = sectionCnt ? this.props.sections[0].chunks.length : 0;
+ return [sectionCnt, chunksPerSection];
+ };
+ return ScrollGrid;
+ }(BaseComponent));
+ ScrollGrid.addStateEquality({
+ shrinkWidths: isArraysEqual,
+ scrollerClientWidths: isPropsEqual,
+ scrollerClientHeights: isPropsEqual,
+ });
+ function sumNumbers(numbers) {
+ var sum = 0;
+ for (var _i = 0, numbers_1 = numbers; _i < numbers_1.length; _i++) {
+ var n = numbers_1[_i];
+ sum += n;
+ }
+ return sum;
+ }
+ function getRowInnerMaxHeight(rowEl) {
+ var innerHeights = findElements(rowEl, '.fc-scrollgrid-sync-inner').map(getElHeight);
+ if (innerHeights.length) {
+ return Math.max.apply(Math, innerHeights);
+ }
+ return 0;
+ }
+ function getElHeight(el) {
+ return el.offsetHeight; // better to deal with integers, for rounding, for PureComponent
+ }
+ function renderMacroColGroup(colGroupStats, shrinkWidths) {
+ var children = colGroupStats.map(function (colGroupStat, i) {
+ var width = colGroupStat.width;
+ if (width === 'shrink') {
+ width = colGroupStat.totalColWidth + sanitizeShrinkWidth(shrinkWidths[i]) + 1; // +1 for border :(
+ }
+ return ( // eslint-disable-next-line react/jsx-key
+ createElement("col", { style: { width: width } }));
+ });
+ return createElement.apply(void 0, __spreadArray(['colgroup', {}], children));
+ }
+ function compileColGroupStat(colGroupConfig) {
+ var totalColWidth = sumColProp(colGroupConfig.cols, 'width'); // excludes "shrink"
+ var totalColMinWidth = sumColProp(colGroupConfig.cols, 'minWidth');
+ var hasShrinkCol = hasShrinkWidth(colGroupConfig.cols);
+ var allowXScrolling = colGroupConfig.width !== 'shrink' && Boolean(totalColWidth || totalColMinWidth || hasShrinkCol);
+ return {
+ hasShrinkCol: hasShrinkCol,
+ totalColWidth: totalColWidth,
+ totalColMinWidth: totalColMinWidth,
+ allowXScrolling: allowXScrolling,
+ cols: colGroupConfig.cols,
+ width: colGroupConfig.width,
+ };
+ }
+ function sumColProp(cols, propName) {
+ var total = 0;
+ for (var _i = 0, cols_1 = cols; _i < cols_1.length; _i++) {
+ var col = cols_1[_i];
+ var val = col[propName];
+ if (typeof val === 'number') {
+ total += val * (col.span || 1);
+ }
+ }
+ return total;
+ }
+ var COL_GROUP_STAT_EQUALITY = {
+ cols: isColPropsEqual,
+ };
+ function isColGroupStatsEqual(stat0, stat1) {
+ return compareObjs(stat0, stat1, COL_GROUP_STAT_EQUALITY);
+ }
+ // for memoizers...
+ function initScrollSyncer(isVertical) {
+ var scrollEls = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ scrollEls[_i - 1] = arguments[_i];
+ }
+ return new ScrollSyncer(isVertical, scrollEls);
+ }
+ function destroyScrollSyncer(scrollSyncer) {
+ scrollSyncer.destroy();
+ }
+ function initStickyScrolling(scrollEl, isRtl) {
+ return new StickyScrolling(scrollEl, isRtl);
+ }
+ function destroyStickyScrolling(stickyScrolling) {
+ stickyScrolling.destroy();
+ }
+
+ var scrollGridPlugin = createPlugin({
+ deps: [
+ premiumCommonPlugin,
+ ],
+ scrollGridImpl: ScrollGrid,
+ });
+ config.SCROLLGRID_RESIZE_INTERVAL = 500;
+
+ config.COLLAPSIBLE_WIDTH_THRESHOLD = 1200;
+ var contexts = [];
+ var undoFuncs = [];
+ var adaptivePlugin = createPlugin({
+ deps: [
+ premiumCommonPlugin,
+ ],
+ contextInit: function (context) {
+ if (!contexts.length) {
+ attachGlobalHandlers();
+ }
+ contexts.push(context);
+ context.calendarApi.on('_unmount', function () {
+ removeExact(contexts, context);
+ if (!contexts.length) {
+ removeGlobalHandlers();
+ }
+ });
+ },
+ });
+ function attachGlobalHandlers() {
+ window.addEventListener('beforeprint', handleBeforePrint);
+ window.addEventListener('afterprint', handleAfterPrint);
+ // // for testing
+ // let forPrint = false
+ // document.addEventListener('keypress', (ev) => {
+ // if (ev.key === 'p') {
+ // forPrint = !forPrint
+ // if (forPrint) {
+ // handleBeforePrint()
+ // } else {
+ // handleAfterPrint()
+ // }
+ // }
+ // })
+ }
+ function removeGlobalHandlers() {
+ window.removeEventListener('beforeprint', handleBeforePrint);
+ window.removeEventListener('afterprint', handleAfterPrint);
+ }
+ function handleBeforePrint() {
+ var scrollEls = queryScrollerEls();
+ var scrollCoords = queryScrollerCoords(scrollEls);
+ for (var _i = 0, contexts_1 = contexts; _i < contexts_1.length; _i++) {
+ var context = contexts_1[_i];
+ context.emitter.trigger('_beforeprint');
+ }
+ flushToDom(); // because printing grabs DOM immediately after
+ killHorizontalScrolling(scrollEls, scrollCoords);
+ undoFuncs.push(function () { return restoreScrollerCoords(scrollEls, scrollCoords); });
+ undoFuncs.push(freezeScrollgridWidths());
+ }
+ function handleAfterPrint() {
+ for (var _i = 0, contexts_2 = contexts; _i < contexts_2.length; _i++) {
+ var context = contexts_2[_i];
+ context.emitter.trigger('_afterprint');
+ }
+ flushToDom(); // guarantee that there are real scrollers
+ while (undoFuncs.length) {
+ undoFuncs.shift()();
+ }
+ }
+ // scrollgrid widths
+ function freezeScrollgridWidths() {
+ var els = findElements(document.body, '.fc-scrollgrid');
+ els.forEach(freezeScrollGridWidth);
+ return function () { return els.forEach(unfreezeScrollGridWidth); };
+ }
+ function freezeScrollGridWidth(el) {
+ var elWidth = el.getBoundingClientRect().width;
+ // along with collapsibleWidth, this is a hack for #5707
+ if (!el.classList.contains('fc-scrollgrid-collapsible') || elWidth < config.COLLAPSIBLE_WIDTH_THRESHOLD) {
+ el.style.width = elWidth + 'px';
+ }
+ }
+ function unfreezeScrollGridWidth(el) {
+ el.style.width = '';
+ }
+ // scrollers
+ // TODO: use scroll normalization!? yes
+ function queryScrollerEls() {
+ return findElements(document.body, '.fc-scroller-harness > .fc-scroller');
+ }
+ function queryScrollerCoords(els) {
+ return els.map(function (el) {
+ var computedStyle = window.getComputedStyle(el);
+ return {
+ scrollLeft: el.scrollLeft,
+ scrollTop: el.scrollTop,
+ overflowX: computedStyle.overflowX,
+ overflowY: computedStyle.overflowY,
+ marginBottom: computedStyle.marginBottom,
+ };
+ });
+ }
+ function killHorizontalScrolling(els, coords) {
+ els.forEach(function (el, i) {
+ el.style.overflowX = 'visible'; // need to clear X/Y to get true overflow
+ el.style.overflowY = 'visible'; // "
+ el.style.marginBottom = ''; // for clipping away scrollbar. disable
+ el.style.left = -coords[i].scrollLeft + 'px'; // simulate scrollLeft! will be position:relative
+ });
+ }
+ function restoreScrollerCoords(els, coords) {
+ els.forEach(function (el, i) {
+ var c = coords[i];
+ el.style.overflowX = c.overflowX;
+ el.style.overflowY = c.overflowY;
+ el.style.marginBottom = c.marginBottom;
+ el.style.left = '';
+ el.scrollLeft = c.scrollLeft;
+ el.scrollTop = c.scrollTop;
+ });
+ }
+
+ var MIN_AUTO_LABELS = 18; // more than `12` months but less that `24` hours
+ var MAX_AUTO_SLOTS_PER_LABEL = 6; // allows 6 10-min slots in an hour
+ var MAX_AUTO_CELLS = 200; // allows 4-days to have a :30 slot duration
+ config.MAX_TIMELINE_SLOTS = 1000;
+ // potential nice values for slot-duration and interval-duration
+ var STOCK_SUB_DURATIONS = [
+ { years: 1 },
+ { months: 1 },
+ { days: 1 },
+ { hours: 1 },
+ { minutes: 30 },
+ { minutes: 15 },
+ { minutes: 10 },
+ { minutes: 5 },
+ { minutes: 1 },
+ { seconds: 30 },
+ { seconds: 15 },
+ { seconds: 10 },
+ { seconds: 5 },
+ { seconds: 1 },
+ { milliseconds: 500 },
+ { milliseconds: 100 },
+ { milliseconds: 10 },
+ { milliseconds: 1 },
+ ];
+ function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileGenerator) {
+ var tDateProfile = {
+ labelInterval: allOptions.slotLabelInterval,
+ slotDuration: allOptions.slotDuration,
+ };
+ validateLabelAndSlot(tDateProfile, dateProfile, dateEnv); // validate after computed grid duration
+ ensureLabelInterval(tDateProfile, dateProfile, dateEnv);
+ ensureSlotDuration(tDateProfile, dateProfile, dateEnv);
+ var input = allOptions.slotLabelFormat;
+ var rawFormats = Array.isArray(input) ? input :
+ (input != null) ? [input] :
+ computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions);
+ tDateProfile.headerFormats = rawFormats.map(function (rawFormat) { return createFormatter(rawFormat); });
+ tDateProfile.isTimeScale = Boolean(tDateProfile.slotDuration.milliseconds);
+ var largeUnit = null;
+ if (!tDateProfile.isTimeScale) {
+ var slotUnit = greatestDurationDenominator(tDateProfile.slotDuration).unit;
+ if (/year|month|week/.test(slotUnit)) {
+ largeUnit = slotUnit;
+ }
+ }
+ tDateProfile.largeUnit = largeUnit;
+ tDateProfile.emphasizeWeeks =
+ asCleanDays(tDateProfile.slotDuration) === 1 &&
+ currentRangeAs('weeks', dateProfile, dateEnv) >= 2 &&
+ !allOptions.businessHours;
+ /*
+ console.log('label interval =', timelineView.labelInterval.humanize())
+ console.log('slot duration =', timelineView.slotDuration.humanize())
+ console.log('header formats =', timelineView.headerFormats)
+ console.log('isTimeScale', timelineView.isTimeScale)
+ console.log('largeUnit', timelineView.largeUnit)
+ */
+ var rawSnapDuration = allOptions.snapDuration;
+ var snapDuration;
+ var snapsPerSlot;
+ if (rawSnapDuration) {
+ snapDuration = createDuration(rawSnapDuration);
+ snapsPerSlot = wholeDivideDurations(tDateProfile.slotDuration, snapDuration);
+ // ^ TODO: warning if not whole?
+ }
+ if (snapsPerSlot == null) {
+ snapDuration = tDateProfile.slotDuration;
+ snapsPerSlot = 1;
+ }
+ tDateProfile.snapDuration = snapDuration;
+ tDateProfile.snapsPerSlot = snapsPerSlot;
+ // more...
+ var timeWindowMs = asRoughMs(dateProfile.slotMaxTime) - asRoughMs(dateProfile.slotMinTime);
+ // TODO: why not use normalizeRange!?
+ var normalizedStart = normalizeDate(dateProfile.renderRange.start, tDateProfile, dateEnv);
+ var normalizedEnd = normalizeDate(dateProfile.renderRange.end, tDateProfile, dateEnv);
+ // apply slotMinTime/slotMaxTime
+ // TODO: View should be responsible.
+ if (tDateProfile.isTimeScale) {
+ normalizedStart = dateEnv.add(normalizedStart, dateProfile.slotMinTime);
+ normalizedEnd = dateEnv.add(addDays(normalizedEnd, -1), dateProfile.slotMaxTime);
+ }
+ tDateProfile.timeWindowMs = timeWindowMs;
+ tDateProfile.normalizedRange = { start: normalizedStart, end: normalizedEnd };
+ var slotDates = [];
+ var date = normalizedStart;
+ while (date < normalizedEnd) {
+ if (isValidDate(date, tDateProfile, dateProfile, dateProfileGenerator)) {
+ slotDates.push(date);
+ }
+ date = dateEnv.add(date, tDateProfile.slotDuration);
+ }
+ tDateProfile.slotDates = slotDates;
+ // more...
+ var snapIndex = -1;
+ var snapDiff = 0; // index of the diff :(
+ var snapDiffToIndex = [];
+ var snapIndexToDiff = [];
+ date = normalizedStart;
+ while (date < normalizedEnd) {
+ if (isValidDate(date, tDateProfile, dateProfile, dateProfileGenerator)) {
+ snapIndex += 1;
+ snapDiffToIndex.push(snapIndex);
+ snapIndexToDiff.push(snapDiff);
+ }
+ else {
+ snapDiffToIndex.push(snapIndex + 0.5);
+ }
+ date = dateEnv.add(date, tDateProfile.snapDuration);
+ snapDiff += 1;
+ }
+ tDateProfile.snapDiffToIndex = snapDiffToIndex;
+ tDateProfile.snapIndexToDiff = snapIndexToDiff;
+ tDateProfile.snapCnt = snapIndex + 1; // is always one behind
+ tDateProfile.slotCnt = tDateProfile.snapCnt / tDateProfile.snapsPerSlot;
+ // more...
+ tDateProfile.isWeekStarts = buildIsWeekStarts(tDateProfile, dateEnv);
+ tDateProfile.cellRows = buildCellRows(tDateProfile, dateEnv);
+ tDateProfile.slotsPerLabel = wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
+ return tDateProfile;
+ }
+ /*
+ snaps to appropriate unit
+ */
+ function normalizeDate(date, tDateProfile, dateEnv) {
+ var normalDate = date;
+ if (!tDateProfile.isTimeScale) {
+ normalDate = startOfDay(normalDate);
+ if (tDateProfile.largeUnit) {
+ normalDate = dateEnv.startOf(normalDate, tDateProfile.largeUnit);
+ }
+ }
+ return normalDate;
+ }
+ /*
+ snaps to appropriate unit
+ */
+ function normalizeRange(range, tDateProfile, dateEnv) {
+ if (!tDateProfile.isTimeScale) {
+ range = computeVisibleDayRange(range);
+ if (tDateProfile.largeUnit) {
+ var dayRange = range; // preserve original result
+ range = {
+ start: dateEnv.startOf(range.start, tDateProfile.largeUnit),
+ end: dateEnv.startOf(range.end, tDateProfile.largeUnit),
+ };
+ // if date is partially through the interval, or is in the same interval as the start,
+ // make the exclusive end be the *next* interval
+ if (range.end.valueOf() !== dayRange.end.valueOf() || range.end <= range.start) {
+ range = {
+ start: range.start,
+ end: dateEnv.add(range.end, tDateProfile.slotDuration),
+ };
+ }
+ }
+ }
+ return range;
+ }
+ function isValidDate(date, tDateProfile, dateProfile, dateProfileGenerator) {
+ if (dateProfileGenerator.isHiddenDay(date)) {
+ return false;
+ }
+ if (tDateProfile.isTimeScale) {
+ // determine if the time is within slotMinTime/slotMaxTime, which may have wacky values
+ var day = startOfDay(date);
+ var timeMs = date.valueOf() - day.valueOf();
+ var ms = timeMs - asRoughMs(dateProfile.slotMinTime); // milliseconds since slotMinTime
+ ms = ((ms % 86400000) + 86400000) % 86400000; // make negative values wrap to 24hr clock
+ return ms < tDateProfile.timeWindowMs; // before the slotMaxTime?
+ }
+ return true;
+ }
+ function validateLabelAndSlot(tDateProfile, dateProfile, dateEnv) {
+ var currentRange = dateProfile.currentRange;
+ // make sure labelInterval doesn't exceed the max number of cells
+ if (tDateProfile.labelInterval) {
+ var labelCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, tDateProfile.labelInterval);
+ if (labelCnt > config.MAX_TIMELINE_SLOTS) {
+ console.warn('slotLabelInterval results in too many cells');
+ tDateProfile.labelInterval = null;
+ }
+ }
+ // make sure slotDuration doesn't exceed the maximum number of cells
+ if (tDateProfile.slotDuration) {
+ var slotCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, tDateProfile.slotDuration);
+ if (slotCnt > config.MAX_TIMELINE_SLOTS) {
+ console.warn('slotDuration results in too many cells');
+ tDateProfile.slotDuration = null;
+ }
+ }
+ // make sure labelInterval is a multiple of slotDuration
+ if (tDateProfile.labelInterval && tDateProfile.slotDuration) {
+ var slotsPerLabel = wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
+ if (slotsPerLabel === null || slotsPerLabel < 1) {
+ console.warn('slotLabelInterval must be a multiple of slotDuration');
+ tDateProfile.slotDuration = null;
+ }
+ }
+ }
+ function ensureLabelInterval(tDateProfile, dateProfile, dateEnv) {
+ var currentRange = dateProfile.currentRange;
+ var labelInterval = tDateProfile.labelInterval;
+ if (!labelInterval) {
+ // compute based off the slot duration
+ // find the largest label interval with an acceptable slots-per-label
+ var input = void 0;
+ if (tDateProfile.slotDuration) {
+ for (var _i = 0, STOCK_SUB_DURATIONS_1 = STOCK_SUB_DURATIONS; _i < STOCK_SUB_DURATIONS_1.length; _i++) {
+ input = STOCK_SUB_DURATIONS_1[_i];
+ var tryLabelInterval = createDuration(input);
+ var slotsPerLabel = wholeDivideDurations(tryLabelInterval, tDateProfile.slotDuration);
+ if (slotsPerLabel !== null && slotsPerLabel <= MAX_AUTO_SLOTS_PER_LABEL) {
+ labelInterval = tryLabelInterval;
+ break;
+ }
+ }
+ // use the slot duration as a last resort
+ if (!labelInterval) {
+ labelInterval = tDateProfile.slotDuration;
+ }
+ // compute based off the view's duration
+ // find the largest label interval that yields the minimum number of labels
+ }
+ else {
+ for (var _a = 0, STOCK_SUB_DURATIONS_2 = STOCK_SUB_DURATIONS; _a < STOCK_SUB_DURATIONS_2.length; _a++) {
+ input = STOCK_SUB_DURATIONS_2[_a];
+ labelInterval = createDuration(input);
+ var labelCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, labelInterval);
+ if (labelCnt >= MIN_AUTO_LABELS) {
+ break;
+ }
+ }
+ }
+ tDateProfile.labelInterval = labelInterval;
+ }
+ return labelInterval;
+ }
+ function ensureSlotDuration(tDateProfile, dateProfile, dateEnv) {
+ var currentRange = dateProfile.currentRange;
+ var slotDuration = tDateProfile.slotDuration;
+ if (!slotDuration) {
+ var labelInterval = ensureLabelInterval(tDateProfile, dateProfile, dateEnv); // will compute if necessary
+ // compute based off the label interval
+ // find the largest slot duration that is different from labelInterval, but still acceptable
+ for (var _i = 0, STOCK_SUB_DURATIONS_3 = STOCK_SUB_DURATIONS; _i < STOCK_SUB_DURATIONS_3.length; _i++) {
+ var input = STOCK_SUB_DURATIONS_3[_i];
+ var trySlotDuration = createDuration(input);
+ var slotsPerLabel = wholeDivideDurations(labelInterval, trySlotDuration);
+ if (slotsPerLabel !== null && slotsPerLabel > 1 && slotsPerLabel <= MAX_AUTO_SLOTS_PER_LABEL) {
+ slotDuration = trySlotDuration;
+ break;
+ }
+ }
+ // only allow the value if it won't exceed the view's # of slots limit
+ if (slotDuration) {
+ var slotCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, slotDuration);
+ if (slotCnt > MAX_AUTO_CELLS) {
+ slotDuration = null;
+ }
+ }
+ // use the label interval as a last resort
+ if (!slotDuration) {
+ slotDuration = labelInterval;
+ }
+ tDateProfile.slotDuration = slotDuration;
+ }
+ return slotDuration;
+ }
+ function computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions) {
+ var format1;
+ var format2;
+ var labelInterval = tDateProfile.labelInterval;
+ var unit = greatestDurationDenominator(labelInterval).unit;
+ var weekNumbersVisible = allOptions.weekNumbers;
+ var format0 = (format1 = (format2 = null));
+ // NOTE: weekNumber computation function wont work
+ if ((unit === 'week') && !weekNumbersVisible) {
+ unit = 'day';
+ }
+ switch (unit) {
+ case 'year':
+ format0 = { year: 'numeric' }; // '2015'
+ break;
+ case 'month':
+ if (currentRangeAs('years', dateProfile, dateEnv) > 1) {
+ format0 = { year: 'numeric' }; // '2015'
+ }
+ format1 = { month: 'short' }; // 'Jan'
+ break;
+ case 'week':
+ if (currentRangeAs('years', dateProfile, dateEnv) > 1) {
+ format0 = { year: 'numeric' }; // '2015'
+ }
+ format1 = { week: 'narrow' }; // 'Wk4'
+ break;
+ case 'day':
+ if (currentRangeAs('years', dateProfile, dateEnv) > 1) {
+ format0 = { year: 'numeric', month: 'long' }; // 'January 2014'
+ }
+ else if (currentRangeAs('months', dateProfile, dateEnv) > 1) {
+ format0 = { month: 'long' }; // 'January'
+ }
+ if (weekNumbersVisible) {
+ format1 = { week: 'short' }; // 'Wk 4'
+ }
+ format2 = { weekday: 'narrow', day: 'numeric' }; // 'Su 9'
+ break;
+ case 'hour':
+ if (weekNumbersVisible) {
+ format0 = { week: 'short' }; // 'Wk 4'
+ }
+ if (currentRangeAs('days', dateProfile, dateEnv) > 1) {
+ format1 = { weekday: 'short', day: 'numeric', month: 'numeric', omitCommas: true }; // Sat 4/7
+ }
+ format2 = {
+ hour: 'numeric',
+ minute: '2-digit',
+ omitZeroMinute: true,
+ meridiem: 'short',
+ };
+ break;
+ case 'minute':
+ // sufficiently large number of different minute cells?
+ if ((asRoughMinutes(labelInterval) / 60) >= MAX_AUTO_SLOTS_PER_LABEL) {
+ format0 = {
+ hour: 'numeric',
+ meridiem: 'short',
+ };
+ format1 = function (params) { return (':' + padStart(params.date.minute, 2) // ':30'
+ ); };
+ }
+ else {
+ format0 = {
+ hour: 'numeric',
+ minute: 'numeric',
+ meridiem: 'short',
+ };
+ }
+ break;
+ case 'second':
+ // sufficiently large number of different second cells?
+ if ((asRoughSeconds(labelInterval) / 60) >= MAX_AUTO_SLOTS_PER_LABEL) {
+ format0 = { hour: 'numeric', minute: '2-digit', meridiem: 'lowercase' }; // '8:30 PM'
+ format1 = function (params) { return (':' + padStart(params.date.second, 2) // ':30'
+ ); };
+ }
+ else {
+ format0 = { hour: 'numeric', minute: '2-digit', second: '2-digit', meridiem: 'lowercase' }; // '8:30:45 PM'
+ }
+ break;
+ case 'millisecond':
+ format0 = { hour: 'numeric', minute: '2-digit', second: '2-digit', meridiem: 'lowercase' }; // '8:30:45 PM'
+ format1 = function (params) { return ('.' + padStart(params.millisecond, 3)); };
+ break;
+ }
+ return [].concat(format0 || [], format1 || [], format2 || []);
+ }
+ // Compute the number of the give units in the "current" range.
+ // Won't go more precise than days.
+ // Will return `0` if there's not a clean whole interval.
+ function currentRangeAs(unit, dateProfile, dateEnv) {
+ var range = dateProfile.currentRange;
+ var res = null;
+ if (unit === 'years') {
+ res = dateEnv.diffWholeYears(range.start, range.end);
+ }
+ else if (unit === 'months') {
+ res = dateEnv.diffWholeMonths(range.start, range.end);
+ }
+ else if (unit === 'weeks') {
+ res = dateEnv.diffWholeMonths(range.start, range.end);
+ }
+ else if (unit === 'days') {
+ res = diffWholeDays(range.start, range.end);
+ }
+ return res || 0;
+ }
+ function buildIsWeekStarts(tDateProfile, dateEnv) {
+ var slotDates = tDateProfile.slotDates, emphasizeWeeks = tDateProfile.emphasizeWeeks;
+ var prevWeekNumber = null;
+ var isWeekStarts = [];
+ for (var _i = 0, slotDates_1 = slotDates; _i < slotDates_1.length; _i++) {
+ var slotDate = slotDates_1[_i];
+ var weekNumber = dateEnv.computeWeekNumber(slotDate);
+ var isWeekStart = emphasizeWeeks && (prevWeekNumber !== null) && (prevWeekNumber !== weekNumber);
+ prevWeekNumber = weekNumber;
+ isWeekStarts.push(isWeekStart);
+ }
+ return isWeekStarts;
+ }
+ function buildCellRows(tDateProfile, dateEnv) {
+ var slotDates = tDateProfile.slotDates;
+ var formats = tDateProfile.headerFormats;
+ var cellRows = formats.map(function () { return []; }); // indexed by row,col
+ var slotAsDays = asCleanDays(tDateProfile.slotDuration);
+ var guessedSlotUnit = slotAsDays === 7 ? 'week' :
+ slotAsDays === 1 ? 'day' :
+ null;
+ // specifically for navclicks
+ var rowUnitsFromFormats = formats.map(function (format) { return (format.getLargestUnit ? format.getLargestUnit() : null); });
+ // builds cellRows and slotCells
+ for (var i = 0; i < slotDates.length; i += 1) {
+ var date = slotDates[i];
+ var isWeekStart = tDateProfile.isWeekStarts[i];
+ for (var row = 0; row < formats.length; row += 1) {
+ var format = formats[row];
+ var rowCells = cellRows[row];
+ var leadingCell = rowCells[rowCells.length - 1];
+ var isLastRow = row === formats.length - 1;
+ var isSuperRow = formats.length > 1 && !isLastRow; // more than one row and not the last
+ var newCell = null;
+ var rowUnit = rowUnitsFromFormats[row] || (isLastRow ? guessedSlotUnit : null);
+ if (isSuperRow) {
+ var text = dateEnv.format(date, format);
+ if (!leadingCell || (leadingCell.text !== text)) {
+ newCell = buildCellObject(date, text, rowUnit);
+ }
+ else {
+ leadingCell.colspan += 1;
+ }
+ }
+ else if (!leadingCell ||
+ isInt(dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, date, tDateProfile.labelInterval))) {
+ var text = dateEnv.format(date, format);
+ newCell = buildCellObject(date, text, rowUnit);
+ }
+ else {
+ leadingCell.colspan += 1;
+ }
+ if (newCell) {
+ newCell.weekStart = isWeekStart;
+ rowCells.push(newCell);
+ }
+ }
+ }
+ return cellRows;
+ }
+ function buildCellObject(date, text, rowUnit) {
+ return { date: date, text: text, rowUnit: rowUnit, colspan: 1, isWeekStart: false };
+ }
+
+ var TimelineHeaderThInner = /** @class */ (function (_super) {
+ __extends(TimelineHeaderThInner, _super);
+ function TimelineHeaderThInner() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimelineHeaderThInner.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ return (createElement(ContentHook, { hookProps: props.hookProps, content: context.options.slotLabelContent, defaultContent: renderInnerContent$1 }, function (innerElRef, innerContent) { return (createElement("a", __assign({ ref: innerElRef, className: 'fc-timeline-slot-cushion fc-scrollgrid-sync-inner' + (props.isSticky ? ' fc-sticky' : '') }, props.navLinkAttrs), innerContent)); }));
+ };
+ return TimelineHeaderThInner;
+ }(BaseComponent));
+ function renderInnerContent$1(props) {
+ return props.text;
+ }
+ function refineHookProps$2(input) {
+ return {
+ level: input.level,
+ date: input.dateEnv.toDate(input.dateMarker),
+ view: input.viewApi,
+ text: input.text,
+ };
+ }
+
+ var TimelineHeaderTh = /** @class */ (function (_super) {
+ __extends(TimelineHeaderTh, _super);
+ function TimelineHeaderTh() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.refineHookProps = memoizeObjArg(refineHookProps$2);
+ _this.normalizeClassNames = buildClassNameNormalizer();
+ _this.buildCellNavLinkAttrs = memoize(buildCellNavLinkAttrs);
+ return _this;
+ }
+ TimelineHeaderTh.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var dateEnv = context.dateEnv, options = context.options;
+ var cell = props.cell, dateProfile = props.dateProfile, tDateProfile = props.tDateProfile;
+ // the cell.rowUnit is f'd
+ // giving 'month' for a 3-day view
+ // workaround: to infer day, do NOT time
+ var dateMeta = getDateMeta(cell.date, props.todayRange, props.nowDate, dateProfile);
+ var classNames = ['fc-timeline-slot', 'fc-timeline-slot-label'].concat(cell.rowUnit === 'time' // TODO: so slot classnames for week/month/bigger. see note above about rowUnit
+ ? getSlotClassNames(dateMeta, context.theme)
+ : getDayClassNames(dateMeta, context.theme));
+ if (cell.isWeekStart) {
+ classNames.push('fc-timeline-slot-em');
+ }
+ var hookProps = this.refineHookProps({
+ level: props.rowLevel,
+ dateMarker: cell.date,
+ text: cell.text,
+ dateEnv: context.dateEnv,
+ viewApi: context.viewApi,
+ });
+ var customClassNames = this.normalizeClassNames(options.slotLabelClassNames, hookProps);
+ return (createElement(MountHook, { hookProps: hookProps, didMount: options.slotLabelDidMount, willUnmount: options.slotLabelWillUnmount }, function (rootElRef) { return (createElement("th", { ref: rootElRef, className: classNames.concat(customClassNames).join(' '), "data-date": dateEnv.formatIso(cell.date, { omitTime: !tDateProfile.isTimeScale, omitTimeZoneOffset: true }), colSpan: cell.colspan },
+ createElement("div", { className: "fc-timeline-slot-frame", style: { height: props.rowInnerHeight } },
+ createElement(TimelineHeaderThInner, { hookProps: hookProps, isSticky: props.isSticky, navLinkAttrs: _this.buildCellNavLinkAttrs(context, cell.date, cell.rowUnit) })))); }));
+ };
+ return TimelineHeaderTh;
+ }(BaseComponent));
+ function buildCellNavLinkAttrs(context, cellDate, rowUnit) {
+ return (rowUnit && rowUnit !== 'time')
+ ? buildNavLinkAttrs(context, cellDate, rowUnit)
+ : {};
+ }
+
+ var TimelineHeaderRows = /** @class */ (function (_super) {
+ __extends(TimelineHeaderRows, _super);
+ function TimelineHeaderRows() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimelineHeaderRows.prototype.render = function () {
+ var _a = this.props, dateProfile = _a.dateProfile, tDateProfile = _a.tDateProfile, rowInnerHeights = _a.rowInnerHeights, todayRange = _a.todayRange, nowDate = _a.nowDate;
+ var cellRows = tDateProfile.cellRows;
+ return (createElement(Fragment, null, cellRows.map(function (rowCells, rowLevel) {
+ var isLast = rowLevel === cellRows.length - 1;
+ var isChrono = tDateProfile.isTimeScale && isLast; // the final row, with times?
+ var classNames = [
+ 'fc-timeline-header-row',
+ isChrono ? 'fc-timeline-header-row-chrono' : '',
+ ];
+ return ( // eslint-disable-next-line react/no-array-index-key
+ createElement("tr", { key: rowLevel, className: classNames.join(' ') }, rowCells.map(function (cell) { return (createElement(TimelineHeaderTh, { key: cell.date.toISOString(), cell: cell, rowLevel: rowLevel, dateProfile: dateProfile, tDateProfile: tDateProfile, todayRange: todayRange, nowDate: nowDate, rowInnerHeight: rowInnerHeights && rowInnerHeights[rowLevel], isSticky: !isLast })); })));
+ })));
+ };
+ return TimelineHeaderRows;
+ }(BaseComponent));
+
+ var TimelineCoords = /** @class */ (function () {
+ function TimelineCoords(slatRootEl, // okay to expose?
+ slatEls, dateProfile, tDateProfile, dateEnv, isRtl) {
+ this.slatRootEl = slatRootEl;
+ this.dateProfile = dateProfile;
+ this.tDateProfile = tDateProfile;
+ this.dateEnv = dateEnv;
+ this.isRtl = isRtl;
+ this.outerCoordCache = new PositionCache(slatRootEl, slatEls, true, // isHorizontal
+ false);
+ // for the inner divs within the slats
+ // used for event rendering and scrollTime, to disregard slat border
+ this.innerCoordCache = new PositionCache(slatRootEl, findDirectChildren(slatEls, 'div'), true, // isHorizontal
+ false);
+ }
+ TimelineCoords.prototype.isDateInRange = function (date) {
+ return rangeContainsMarker(this.dateProfile.currentRange, date);
+ };
+ // results range from negative width of area to 0
+ TimelineCoords.prototype.dateToCoord = function (date) {
+ var tDateProfile = this.tDateProfile;
+ var snapCoverage = this.computeDateSnapCoverage(date);
+ var slotCoverage = snapCoverage / tDateProfile.snapsPerSlot;
+ var slotIndex = Math.floor(slotCoverage);
+ slotIndex = Math.min(slotIndex, tDateProfile.slotCnt - 1);
+ var partial = slotCoverage - slotIndex;
+ var _a = this, innerCoordCache = _a.innerCoordCache, outerCoordCache = _a.outerCoordCache;
+ if (this.isRtl) {
+ return outerCoordCache.originClientRect.width - (outerCoordCache.rights[slotIndex] -
+ (innerCoordCache.getWidth(slotIndex) * partial));
+ }
+ return (outerCoordCache.lefts[slotIndex] +
+ (innerCoordCache.getWidth(slotIndex) * partial));
+ };
+ TimelineCoords.prototype.rangeToCoords = function (range) {
+ return {
+ start: this.dateToCoord(range.start),
+ end: this.dateToCoord(range.end),
+ };
+ };
+ TimelineCoords.prototype.durationToCoord = function (duration) {
+ var _a = this, dateProfile = _a.dateProfile, tDateProfile = _a.tDateProfile, dateEnv = _a.dateEnv, isRtl = _a.isRtl;
+ var coord = 0;
+ if (dateProfile) {
+ var date = dateEnv.add(dateProfile.activeRange.start, duration);
+ if (!tDateProfile.isTimeScale) {
+ date = startOfDay(date);
+ }
+ coord = this.dateToCoord(date);
+ // hack to overcome the left borders of non-first slat
+ if (!isRtl && coord) {
+ coord += 1;
+ }
+ }
+ return coord;
+ };
+ TimelineCoords.prototype.coordFromLeft = function (coord) {
+ if (this.isRtl) {
+ return this.outerCoordCache.originClientRect.width - coord;
+ }
+ return coord;
+ };
+ // returned value is between 0 and the number of snaps
+ TimelineCoords.prototype.computeDateSnapCoverage = function (date) {
+ return computeDateSnapCoverage(date, this.tDateProfile, this.dateEnv);
+ };
+ return TimelineCoords;
+ }());
+ // returned value is between 0 and the number of snaps
+ function computeDateSnapCoverage(date, tDateProfile, dateEnv) {
+ var snapDiff = dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, date, tDateProfile.snapDuration);
+ if (snapDiff < 0) {
+ return 0;
+ }
+ if (snapDiff >= tDateProfile.snapDiffToIndex.length) {
+ return tDateProfile.snapCnt;
+ }
+ var snapDiffInt = Math.floor(snapDiff);
+ var snapCoverage = tDateProfile.snapDiffToIndex[snapDiffInt];
+ if (isInt(snapCoverage)) { // not an in-between value
+ snapCoverage += snapDiff - snapDiffInt; // add the remainder
+ }
+ else {
+ // a fractional value, meaning the date is not visible
+ // always round up in this case. works for start AND end dates in a range.
+ snapCoverage = Math.ceil(snapCoverage);
+ }
+ return snapCoverage;
+ }
+ function coordToCss(hcoord, isRtl) {
+ if (hcoord === null) {
+ return { left: '', right: '' };
+ }
+ if (isRtl) {
+ return { right: hcoord, left: '' };
+ }
+ return { left: hcoord, right: '' };
+ }
+ function coordsToCss(hcoords, isRtl) {
+ if (!hcoords) {
+ return { left: '', right: '' };
+ }
+ if (isRtl) {
+ return { right: hcoords.start, left: -hcoords.end };
+ }
+ return { left: hcoords.start, right: -hcoords.end };
+ }
+
+ var TimelineHeader = /** @class */ (function (_super) {
+ __extends(TimelineHeader, _super);
+ function TimelineHeader() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.rootElRef = createRef();
+ return _this;
+ }
+ TimelineHeader.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ // TODO: very repetitive
+ // TODO: make part of tDateProfile?
+ var timerUnit = greatestDurationDenominator(props.tDateProfile.slotDuration).unit;
+ // WORKAROUND: make ignore slatCoords when out of sync with dateProfile
+ var slatCoords = props.slatCoords && props.slatCoords.dateProfile === props.dateProfile ? props.slatCoords : null;
+ return (createElement(NowTimer, { unit: timerUnit }, function (nowDate, todayRange) { return (createElement("div", { className: "fc-timeline-header", ref: _this.rootElRef },
+ createElement("table", { "aria-hidden": true, className: "fc-scrollgrid-sync-table", style: { minWidth: props.tableMinWidth, width: props.clientWidth } },
+ props.tableColGroupNode,
+ createElement("tbody", null,
+ createElement(TimelineHeaderRows, { dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, nowDate: nowDate, todayRange: todayRange, rowInnerHeights: props.rowInnerHeights }))),
+ context.options.nowIndicator && (
+ // need to have a container regardless of whether the current view has a visible now indicator
+ // because apparently removal of the element resets the scroll for some reasons (issue #5351).
+ // this issue doesn't happen for the timeline body however (
+ createElement("div", { className: "fc-timeline-now-indicator-container" }, (slatCoords && slatCoords.isDateInRange(nowDate)) && (createElement(NowIndicatorRoot, { isAxis: true, date: nowDate }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("div", { ref: rootElRef, className: ['fc-timeline-now-indicator-arrow'].concat(classNames).join(' '), style: coordToCss(slatCoords.dateToCoord(nowDate), context.isRtl) }, innerContent)); })))))); }));
+ };
+ TimelineHeader.prototype.componentDidMount = function () {
+ this.updateSize();
+ };
+ TimelineHeader.prototype.componentDidUpdate = function () {
+ this.updateSize();
+ };
+ TimelineHeader.prototype.updateSize = function () {
+ if (this.props.onMaxCushionWidth) {
+ this.props.onMaxCushionWidth(this.computeMaxCushionWidth());
+ }
+ };
+ TimelineHeader.prototype.computeMaxCushionWidth = function () {
+ return Math.max.apply(Math, findElements(this.rootElRef.current, '.fc-timeline-header-row:last-child .fc-timeline-slot-cushion').map(function (el) { return el.getBoundingClientRect().width; }));
+ };
+ return TimelineHeader;
+ }(BaseComponent));
+
+ var TimelineSlatCell = /** @class */ (function (_super) {
+ __extends(TimelineSlatCell, _super);
+ function TimelineSlatCell() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimelineSlatCell.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var dateEnv = context.dateEnv, options = context.options, theme = context.theme;
+ var date = props.date, tDateProfile = props.tDateProfile, isEm = props.isEm;
+ var dateMeta = getDateMeta(props.date, props.todayRange, props.nowDate, props.dateProfile);
+ var classNames = ['fc-timeline-slot', 'fc-timeline-slot-lane'];
+ var dataAttrs = { 'data-date': dateEnv.formatIso(date, { omitTimeZoneOffset: true, omitTime: !tDateProfile.isTimeScale }) };
+ var hookProps = __assign(__assign({ date: dateEnv.toDate(props.date) }, dateMeta), { view: context.viewApi });
+ if (isEm) {
+ classNames.push('fc-timeline-slot-em');
+ }
+ if (tDateProfile.isTimeScale) {
+ classNames.push(isInt(dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, props.date, tDateProfile.labelInterval)) ?
+ 'fc-timeline-slot-major' :
+ 'fc-timeline-slot-minor');
+ }
+ classNames.push.apply(classNames, (props.isDay
+ ? getDayClassNames(dateMeta, theme)
+ : getSlotClassNames(dateMeta, theme)));
+ return (createElement(RenderHook, { hookProps: hookProps, classNames: options.slotLaneClassNames, content: options.slotLaneContent, didMount: options.slotLaneDidMount, willUnmount: options.slotLaneWillUnmount, elRef: props.elRef }, function (rootElRef, customClassNames, innerElRef, innerContent) { return (createElement("td", __assign({ ref: rootElRef, className: classNames.concat(customClassNames).join(' ') }, dataAttrs),
+ createElement("div", { ref: innerElRef }, innerContent))); }));
+ };
+ return TimelineSlatCell;
+ }(BaseComponent));
+
+ var TimelineSlatsBody = /** @class */ (function (_super) {
+ __extends(TimelineSlatsBody, _super);
+ function TimelineSlatsBody() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimelineSlatsBody.prototype.render = function () {
+ var props = this.props;
+ var tDateProfile = props.tDateProfile, cellElRefs = props.cellElRefs;
+ var slotDates = tDateProfile.slotDates, isWeekStarts = tDateProfile.isWeekStarts;
+ var isDay = !tDateProfile.isTimeScale && !tDateProfile.largeUnit;
+ return (createElement("tbody", null,
+ createElement("tr", null, slotDates.map(function (slotDate, i) {
+ var key = slotDate.toISOString();
+ return (createElement(TimelineSlatCell, { key: key, elRef: cellElRefs.createRef(key), date: slotDate, dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange, isEm: isWeekStarts[i], isDay: isDay }));
+ }))));
+ };
+ return TimelineSlatsBody;
+ }(BaseComponent));
+
+ var TimelineSlats = /** @class */ (function (_super) {
+ __extends(TimelineSlats, _super);
+ function TimelineSlats() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.rootElRef = createRef();
+ _this.cellElRefs = new RefMap();
+ _this.handleScrollRequest = function (request) {
+ var onScrollLeftRequest = _this.props.onScrollLeftRequest;
+ var coords = _this.coords;
+ if (onScrollLeftRequest && coords) {
+ if (request.time) {
+ var scrollLeft = coords.coordFromLeft(coords.durationToCoord(request.time));
+ onScrollLeftRequest(scrollLeft);
+ }
+ return true;
+ }
+ return null; // best?
+ };
+ return _this;
+ }
+ TimelineSlats.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ return (createElement("div", { className: "fc-timeline-slots", ref: this.rootElRef },
+ createElement("table", { "aria-hidden": true, className: context.theme.getClass('table'), style: {
+ minWidth: props.tableMinWidth,
+ width: props.clientWidth,
+ } },
+ props.tableColGroupNode,
+ createElement(TimelineSlatsBody, { cellElRefs: this.cellElRefs, dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange }))));
+ };
+ TimelineSlats.prototype.componentDidMount = function () {
+ this.updateSizing();
+ this.scrollResponder = this.context.createScrollResponder(this.handleScrollRequest);
+ };
+ TimelineSlats.prototype.componentDidUpdate = function (prevProps) {
+ this.updateSizing();
+ this.scrollResponder.update(prevProps.dateProfile !== this.props.dateProfile);
+ };
+ TimelineSlats.prototype.componentWillUnmount = function () {
+ this.scrollResponder.detach();
+ if (this.props.onCoords) {
+ this.props.onCoords(null);
+ }
+ };
+ TimelineSlats.prototype.updateSizing = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ if (props.clientWidth !== null && // is sizing stable?
+ this.scrollResponder
+ // ^it's possible to have clientWidth immediately after mount (when returning from print view), but w/o scrollResponder
+ ) {
+ var rootEl = this.rootElRef.current;
+ if (rootEl.offsetWidth) { // not hidden by css
+ this.coords = new TimelineCoords(this.rootElRef.current, collectCellEls(this.cellElRefs.currentMap, props.tDateProfile.slotDates), props.dateProfile, props.tDateProfile, context.dateEnv, context.isRtl);
+ if (props.onCoords) {
+ props.onCoords(this.coords);
+ }
+ this.scrollResponder.update(false); // TODO: wouldn't have to do this if coords were in state
+ }
+ }
+ };
+ TimelineSlats.prototype.positionToHit = function (leftPosition) {
+ var outerCoordCache = this.coords.outerCoordCache;
+ var _a = this.context, dateEnv = _a.dateEnv, isRtl = _a.isRtl;
+ var tDateProfile = this.props.tDateProfile;
+ var slatIndex = outerCoordCache.leftToIndex(leftPosition);
+ if (slatIndex != null) {
+ // somewhat similar to what TimeGrid does. consolidate?
+ var slatWidth = outerCoordCache.getWidth(slatIndex);
+ var partial = isRtl ?
+ (outerCoordCache.rights[slatIndex] - leftPosition) / slatWidth :
+ (leftPosition - outerCoordCache.lefts[slatIndex]) / slatWidth;
+ var localSnapIndex = Math.floor(partial * tDateProfile.snapsPerSlot);
+ var start = dateEnv.add(tDateProfile.slotDates[slatIndex], multiplyDuration(tDateProfile.snapDuration, localSnapIndex));
+ var end = dateEnv.add(start, tDateProfile.snapDuration);
+ return {
+ dateSpan: {
+ range: { start: start, end: end },
+ allDay: !this.props.tDateProfile.isTimeScale,
+ },
+ dayEl: this.cellElRefs.currentMap[slatIndex],
+ left: outerCoordCache.lefts[slatIndex],
+ right: outerCoordCache.rights[slatIndex],
+ };
+ }
+ return null;
+ };
+ return TimelineSlats;
+ }(BaseComponent));
+ function collectCellEls(elMap, slotDates) {
+ return slotDates.map(function (slotDate) {
+ var key = slotDate.toISOString();
+ return elMap[key];
+ });
+ }
+
+ function computeSegHCoords(segs, minWidth, timelineCoords) {
+ var hcoords = [];
+ if (timelineCoords) {
+ for (var _i = 0, segs_1 = segs; _i < segs_1.length; _i++) {
+ var seg = segs_1[_i];
+ var res = timelineCoords.rangeToCoords(seg);
+ var start = Math.round(res.start); // for barely-overlapping collisions
+ var end = Math.round(res.end); //
+ if (end - start < minWidth) {
+ end = start + minWidth;
+ }
+ hcoords.push({ start: start, end: end });
+ }
+ }
+ return hcoords;
+ }
+ function computeFgSegPlacements(segs, segHCoords, // might not have for every seg
+ eventInstanceHeights, // might not have for every seg
+ moreLinkHeights, // might not have for every more-link
+ strictOrder, maxStackCnt) {
+ var segInputs = [];
+ var crudePlacements = []; // when we don't know dims
+ for (var i = 0; i < segs.length; i += 1) {
+ var seg = segs[i];
+ var instanceId = seg.eventRange.instance.instanceId;
+ var height = eventInstanceHeights[instanceId];
+ var hcoords = segHCoords[i];
+ if (height && hcoords) {
+ segInputs.push({
+ index: i,
+ span: hcoords,
+ thickness: height,
+ });
+ }
+ else {
+ crudePlacements.push({
+ seg: seg,
+ hcoords: hcoords,
+ top: null,
+ });
+ }
+ }
+ var hierarchy = new SegHierarchy();
+ if (strictOrder != null) {
+ hierarchy.strictOrder = strictOrder;
+ }
+ if (maxStackCnt != null) {
+ hierarchy.maxStackCnt = maxStackCnt;
+ }
+ var hiddenEntries = hierarchy.addSegs(segInputs);
+ var hiddenPlacements = hiddenEntries.map(function (entry) { return ({
+ seg: segs[entry.index],
+ hcoords: entry.span,
+ top: null,
+ }); });
+ var hiddenGroups = groupIntersectingEntries(hiddenEntries);
+ var moreLinkInputs = [];
+ var moreLinkCrudePlacements = [];
+ var extractSeg = function (entry) { return segs[entry.index]; };
+ for (var i = 0; i < hiddenGroups.length; i += 1) {
+ var hiddenGroup = hiddenGroups[i];
+ var sortedSegs = hiddenGroup.entries.map(extractSeg);
+ var height = moreLinkHeights[buildIsoString(computeEarliestSegStart(sortedSegs))]; // not optimal :(
+ if (height != null) {
+ // NOTE: the hiddenGroup's spanStart/spanEnd are already computed by rangeToCoords. computed during input.
+ moreLinkInputs.push({
+ index: segs.length + i,
+ thickness: height,
+ span: hiddenGroup.span,
+ });
+ }
+ else {
+ moreLinkCrudePlacements.push({
+ seg: sortedSegs,
+ hcoords: hiddenGroup.span,
+ top: null,
+ });
+ }
+ }
+ // add more-links into the hierarchy, but don't limit
+ hierarchy.maxStackCnt = -1;
+ hierarchy.addSegs(moreLinkInputs);
+ var visibleRects = hierarchy.toRects();
+ var visiblePlacements = [];
+ var maxHeight = 0;
+ for (var _i = 0, visibleRects_1 = visibleRects; _i < visibleRects_1.length; _i++) {
+ var rect = visibleRects_1[_i];
+ var segIndex = rect.index;
+ visiblePlacements.push({
+ seg: segIndex < segs.length
+ ? segs[segIndex] // a real seg
+ : hiddenGroups[segIndex - segs.length].entries.map(extractSeg),
+ hcoords: rect.span,
+ top: rect.levelCoord,
+ });
+ maxHeight = Math.max(maxHeight, rect.levelCoord + rect.thickness);
+ }
+ return [
+ visiblePlacements.concat(crudePlacements, hiddenPlacements, moreLinkCrudePlacements),
+ maxHeight,
+ ];
+ }
+
+ var TimelineLaneBg = /** @class */ (function (_super) {
+ __extends(TimelineLaneBg, _super);
+ function TimelineLaneBg() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimelineLaneBg.prototype.render = function () {
+ var props = this.props;
+ var highlightSeg = [].concat(props.eventResizeSegs, props.dateSelectionSegs);
+ return props.timelineCoords && (createElement("div", { className: "fc-timeline-bg" },
+ this.renderSegs(props.businessHourSegs || [], props.timelineCoords, 'non-business'),
+ this.renderSegs(props.bgEventSegs || [], props.timelineCoords, 'bg-event'),
+ this.renderSegs(highlightSeg, props.timelineCoords, 'highlight')));
+ };
+ TimelineLaneBg.prototype.renderSegs = function (segs, timelineCoords, fillType) {
+ var _a = this.props, todayRange = _a.todayRange, nowDate = _a.nowDate;
+ var isRtl = this.context.isRtl;
+ var segHCoords = computeSegHCoords(segs, 0, timelineCoords);
+ var children = segs.map(function (seg, i) {
+ var hcoords = segHCoords[i];
+ var hStyle = coordsToCss(hcoords, isRtl);
+ return (createElement("div", { key: buildEventRangeKey(seg.eventRange), className: "fc-timeline-bg-harness", style: hStyle }, fillType === 'bg-event' ?
+ createElement(BgEvent, __assign({ seg: seg }, getSegMeta(seg, todayRange, nowDate))) :
+ renderFill(fillType)));
+ });
+ return createElement(Fragment, null, children);
+ };
+ return TimelineLaneBg;
+ }(BaseComponent));
+
+ var TimelineLaneSlicer = /** @class */ (function (_super) {
+ __extends(TimelineLaneSlicer, _super);
+ function TimelineLaneSlicer() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimelineLaneSlicer.prototype.sliceRange = function (origRange, dateProfile, dateProfileGenerator, tDateProfile, dateEnv) {
+ var normalRange = normalizeRange(origRange, tDateProfile, dateEnv);
+ var segs = [];
+ // protect against when the span is entirely in an invalid date region
+ if (computeDateSnapCoverage(normalRange.start, tDateProfile, dateEnv)
+ < computeDateSnapCoverage(normalRange.end, tDateProfile, dateEnv)) {
+ // intersect the footprint's range with the grid's range
+ var slicedRange = intersectRanges(normalRange, tDateProfile.normalizedRange);
+ if (slicedRange) {
+ segs.push({
+ start: slicedRange.start,
+ end: slicedRange.end,
+ isStart: slicedRange.start.valueOf() === normalRange.start.valueOf()
+ && isValidDate(slicedRange.start, tDateProfile, dateProfile, dateProfileGenerator),
+ isEnd: slicedRange.end.valueOf() === normalRange.end.valueOf()
+ && isValidDate(addMs(slicedRange.end, -1), tDateProfile, dateProfile, dateProfileGenerator),
+ });
+ }
+ }
+ return segs;
+ };
+ return TimelineLaneSlicer;
+ }(Slicer));
+
+ var DEFAULT_TIME_FORMAT = createFormatter({
+ hour: 'numeric',
+ minute: '2-digit',
+ omitZeroMinute: true,
+ meridiem: 'narrow',
+ });
+ var TimelineEvent = /** @class */ (function (_super) {
+ __extends(TimelineEvent, _super);
+ function TimelineEvent() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ TimelineEvent.prototype.render = function () {
+ var props = this.props;
+ return (createElement(StandardEvent, __assign({}, props, { extraClassNames: ['fc-timeline-event', 'fc-h-event'], defaultTimeFormat: DEFAULT_TIME_FORMAT, defaultDisplayEventTime: !props.isTimeScale })));
+ };
+ return TimelineEvent;
+ }(BaseComponent));
+
+ var TimelineLaneMoreLink = /** @class */ (function (_super) {
+ __extends(TimelineLaneMoreLink, _super);
+ function TimelineLaneMoreLink() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.rootElRef = createRef();
+ return _this;
+ }
+ TimelineLaneMoreLink.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var hiddenSegs = props.hiddenSegs, elRef = props.elRef, placement = props.placement, resourceId = props.resourceId;
+ var top = placement.top, hcoords = placement.hcoords;
+ var isVisible = hcoords && top !== null;
+ var hStyle = coordsToCss(hcoords, context.isRtl);
+ var extraDateSpan = resourceId ? { resourceId: resourceId } : {};
+ return (createElement(MoreLinkRoot, { allDayDate: null, moreCnt: hiddenSegs.length, allSegs: hiddenSegs, hiddenSegs: hiddenSegs, alignmentElRef: this.rootElRef, dateProfile: props.dateProfile, todayRange: props.todayRange, extraDateSpan: extraDateSpan, popoverContent: function () { return (createElement(Fragment, null, hiddenSegs.map(function (seg) {
+ var instanceId = seg.eventRange.instance.instanceId;
+ return (createElement("div", { key: instanceId, style: { visibility: props.isForcedInvisible[instanceId] ? 'hidden' : '' } },
+ createElement(TimelineEvent, __assign({ isTimeScale: props.isTimeScale, seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: instanceId === props.eventSelection }, getSegMeta(seg, props.todayRange, props.nowDate)))));
+ }))); } }, function (rootElRef, classNames, innerElRef, innerContent, handleClick, title, isExpanded, popoverId) { return (createElement("a", { ref: function (el) {
+ setRef(rootElRef, el); // for MoreLinkRoot
+ setRef(elRef, el); // for props props
+ setRef(_this.rootElRef, el); // for this component
+ }, className: ['fc-timeline-more-link'].concat(classNames).join(' '), style: __assign({ visibility: isVisible ? '' : 'hidden', top: top || 0 }, hStyle), onClick: handleClick, title: title, "aria-expanded": isExpanded, "aria-controls": popoverId },
+ createElement("div", { ref: innerElRef, className: "fc-timeline-more-link-inner fc-sticky" }, innerContent))); }));
+ };
+ return TimelineLaneMoreLink;
+ }(BaseComponent));
+
+ var TimelineLane = /** @class */ (function (_super) {
+ __extends(TimelineLane, _super);
+ function TimelineLane() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.slicer = new TimelineLaneSlicer();
+ _this.sortEventSegs = memoize(sortEventSegs);
+ _this.harnessElRefs = new RefMap();
+ _this.moreElRefs = new RefMap();
+ _this.innerElRef = createRef();
+ // TODO: memoize event positioning
+ _this.state = {
+ eventInstanceHeights: {},
+ moreLinkHeights: {},
+ };
+ return _this;
+ }
+ TimelineLane.prototype.render = function () {
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ var options = context.options;
+ var dateProfile = props.dateProfile, tDateProfile = props.tDateProfile;
+ var slicedProps = this.slicer.sliceProps(props, dateProfile, tDateProfile.isTimeScale ? null : props.nextDayThreshold, context, // wish we didn't have to pass in the rest of the args...
+ dateProfile, context.dateProfileGenerator, tDateProfile, context.dateEnv);
+ var mirrorSegs = (slicedProps.eventDrag ? slicedProps.eventDrag.segs : null) ||
+ (slicedProps.eventResize ? slicedProps.eventResize.segs : null) ||
+ [];
+ var fgSegs = this.sortEventSegs(slicedProps.fgEventSegs, options.eventOrder);
+ var fgSegHCoords = computeSegHCoords(fgSegs, options.eventMinWidth, props.timelineCoords);
+ var _b = computeFgSegPlacements(fgSegs, fgSegHCoords, state.eventInstanceHeights, state.moreLinkHeights, options.eventOrderStrict, options.eventMaxStack), fgPlacements = _b[0], fgHeight = _b[1];
+ var isForcedInvisible = // TODO: more convenient
+ (slicedProps.eventDrag ? slicedProps.eventDrag.affectedInstances : null) ||
+ (slicedProps.eventResize ? slicedProps.eventResize.affectedInstances : null) ||
+ {};
+ return (createElement(Fragment, null,
+ createElement(TimelineLaneBg, { businessHourSegs: slicedProps.businessHourSegs, bgEventSegs: slicedProps.bgEventSegs, timelineCoords: props.timelineCoords, eventResizeSegs: slicedProps.eventResize ? slicedProps.eventResize.segs : [] /* bad new empty array? */, dateSelectionSegs: slicedProps.dateSelectionSegs, nowDate: props.nowDate, todayRange: props.todayRange }),
+ createElement("div", { className: "fc-timeline-events fc-scrollgrid-sync-inner", ref: this.innerElRef, style: { height: fgHeight } },
+ this.renderFgSegs(fgPlacements, isForcedInvisible, false, false, false),
+ this.renderFgSegs(buildMirrorPlacements(mirrorSegs, props.timelineCoords, fgPlacements), {}, Boolean(slicedProps.eventDrag), Boolean(slicedProps.eventResize), false))));
+ };
+ TimelineLane.prototype.componentDidMount = function () {
+ this.updateSize();
+ };
+ TimelineLane.prototype.componentDidUpdate = function (prevProps, prevState) {
+ if (prevProps.eventStore !== this.props.eventStore || // external thing changed?
+ prevProps.timelineCoords !== this.props.timelineCoords || // external thing changed?
+ prevState.moreLinkHeights !== this.state.moreLinkHeights // HACK. see addStateEquality
+ ) {
+ this.updateSize();
+ }
+ };
+ TimelineLane.prototype.updateSize = function () {
+ var _this = this;
+ var props = this.props;
+ var timelineCoords = props.timelineCoords;
+ if (props.onHeightChange) {
+ props.onHeightChange(this.innerElRef.current, false);
+ }
+ if (timelineCoords) {
+ this.setState({
+ eventInstanceHeights: mapHash(this.harnessElRefs.currentMap, function (harnessEl) { return (Math.round(harnessEl.getBoundingClientRect().height)); }),
+ moreLinkHeights: mapHash(this.moreElRefs.currentMap, function (moreEl) { return (Math.round(moreEl.getBoundingClientRect().height)); }),
+ }, function () {
+ if (props.onHeightChange) {
+ props.onHeightChange(_this.innerElRef.current, true);
+ }
+ });
+ }
+ };
+ TimelineLane.prototype.renderFgSegs = function (segPlacements, isForcedInvisible, isDragging, isResizing, isDateSelecting) {
+ var _a = this, harnessElRefs = _a.harnessElRefs, moreElRefs = _a.moreElRefs, props = _a.props, context = _a.context;
+ var isMirror = isDragging || isResizing || isDateSelecting;
+ return (createElement(Fragment, null, segPlacements.map(function (segPlacement) {
+ var seg = segPlacement.seg, hcoords = segPlacement.hcoords, top = segPlacement.top;
+ if (Array.isArray(seg)) { // a more-link
+ var isoStr = buildIsoString(computeEarliestSegStart(seg));
+ return (createElement(TimelineLaneMoreLink, { key: 'm:' + isoStr /* "m" for "more" */, elRef: moreElRefs.createRef(isoStr), hiddenSegs: seg, placement: segPlacement, dateProfile: props.dateProfile, nowDate: props.nowDate, todayRange: props.todayRange, isTimeScale: props.tDateProfile.isTimeScale, eventSelection: props.eventSelection, resourceId: props.resourceId, isForcedInvisible: isForcedInvisible }));
+ }
+ var instanceId = seg.eventRange.instance.instanceId;
+ var isVisible = isMirror || Boolean(!isForcedInvisible[instanceId] && hcoords && top !== null);
+ var hStyle = coordsToCss(hcoords, context.isRtl);
+ return (createElement("div", { key: 'e:' + instanceId /* "e" for "event" */, ref: isMirror ? null : harnessElRefs.createRef(instanceId), className: "fc-timeline-event-harness", style: __assign({ visibility: isVisible ? '' : 'hidden', top: top || 0 }, hStyle) },
+ createElement(TimelineEvent, __assign({ isTimeScale: props.tDateProfile.isTimeScale, seg: seg, isDragging: isDragging, isResizing: isResizing, isDateSelecting: isDateSelecting, isSelected: instanceId === props.eventSelection /* TODO: bad for mirror? */ }, getSegMeta(seg, props.todayRange, props.nowDate)))));
+ })));
+ };
+ return TimelineLane;
+ }(BaseComponent));
+ TimelineLane.addStateEquality({
+ eventInstanceHeights: isPropsEqual,
+ moreLinkHeights: isPropsEqual,
+ });
+ function buildMirrorPlacements(mirrorSegs, timelineCoords, fgPlacements) {
+ if (!mirrorSegs.length || !timelineCoords) {
+ return [];
+ }
+ var topsByInstanceId = buildAbsoluteTopHash(fgPlacements); // TODO: cache this at first render?
+ return mirrorSegs.map(function (seg) { return ({
+ seg: seg,
+ hcoords: timelineCoords.rangeToCoords(seg),
+ top: topsByInstanceId[seg.eventRange.instance.instanceId],
+ }); });
+ }
+ function buildAbsoluteTopHash(placements) {
+ var topsByInstanceId = {};
+ for (var _i = 0, placements_1 = placements; _i < placements_1.length; _i++) {
+ var placement = placements_1[_i];
+ var seg = placement.seg;
+ if (!Array.isArray(seg)) { // doesn't represent a more-link
+ topsByInstanceId[seg.eventRange.instance.instanceId] = placement.top;
+ }
+ }
+ return topsByInstanceId;
+ }
+
+ var TimelineGrid = /** @class */ (function (_super) {
+ __extends(TimelineGrid, _super);
+ function TimelineGrid() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.slatsRef = createRef();
+ _this.state = {
+ coords: null,
+ };
+ _this.handeEl = function (el) {
+ if (el) {
+ _this.context.registerInteractiveComponent(_this, { el: el });
+ }
+ else {
+ _this.context.unregisterInteractiveComponent(_this);
+ }
+ };
+ _this.handleCoords = function (coords) {
+ _this.setState({ coords: coords });
+ if (_this.props.onSlatCoords) {
+ _this.props.onSlatCoords(coords);
+ }
+ };
+ return _this;
+ }
+ TimelineGrid.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ var options = context.options;
+ var dateProfile = props.dateProfile, tDateProfile = props.tDateProfile;
+ var timerUnit = greatestDurationDenominator(tDateProfile.slotDuration).unit;
+ return (createElement("div", { className: "fc-timeline-body", ref: this.handeEl, style: {
+ minWidth: props.tableMinWidth,
+ height: props.clientHeight,
+ width: props.clientWidth,
+ } },
+ createElement(NowTimer, { unit: timerUnit }, function (nowDate, todayRange) { return (createElement(Fragment, null,
+ createElement(TimelineSlats, { ref: _this.slatsRef, dateProfile: dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, clientWidth: props.clientWidth, tableColGroupNode: props.tableColGroupNode, tableMinWidth: props.tableMinWidth, onCoords: _this.handleCoords, onScrollLeftRequest: props.onScrollLeftRequest }),
+ createElement(TimelineLane, { dateProfile: dateProfile, tDateProfile: props.tDateProfile, nowDate: nowDate, todayRange: todayRange, nextDayThreshold: options.nextDayThreshold, businessHours: props.businessHours, eventStore: props.eventStore, eventUiBases: props.eventUiBases, dateSelection: props.dateSelection, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, timelineCoords: state.coords }),
+ (options.nowIndicator && state.coords && state.coords.isDateInRange(nowDate)) && (createElement("div", { className: "fc-timeline-now-indicator-container" },
+ createElement(NowIndicatorRoot, { isAxis: false, date: nowDate }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("div", { ref: rootElRef, className: ['fc-timeline-now-indicator-line'].concat(classNames).join(' '), style: coordToCss(state.coords.dateToCoord(nowDate), context.isRtl) }, innerContent)); }))))); })));
+ };
+ // Hit System
+ // ------------------------------------------------------------------------------------------
+ TimelineGrid.prototype.queryHit = function (positionLeft, positionTop, elWidth, elHeight) {
+ var slats = this.slatsRef.current;
+ var slatHit = slats.positionToHit(positionLeft);
+ if (slatHit) {
+ return {
+ dateProfile: this.props.dateProfile,
+ dateSpan: slatHit.dateSpan,
+ rect: {
+ left: slatHit.left,
+ right: slatHit.right,
+ top: 0,
+ bottom: elHeight,
+ },
+ dayEl: slatHit.dayEl,
+ layer: 0,
+ };
+ }
+ return null;
+ };
+ return TimelineGrid;
+ }(DateComponent));
+
+ var TimelineView = /** @class */ (function (_super) {
+ __extends(TimelineView, _super);
+ function TimelineView() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.buildTimelineDateProfile = memoize(buildTimelineDateProfile);
+ _this.scrollGridRef = createRef();
+ _this.state = {
+ slatCoords: null,
+ slotCushionMaxWidth: null,
+ };
+ _this.handleSlatCoords = function (slatCoords) {
+ _this.setState({ slatCoords: slatCoords });
+ };
+ _this.handleScrollLeftRequest = function (scrollLeft) {
+ var scrollGrid = _this.scrollGridRef.current;
+ scrollGrid.forceScrollLeft(0, scrollLeft);
+ };
+ _this.handleMaxCushionWidth = function (slotCushionMaxWidth) {
+ _this.setState({
+ slotCushionMaxWidth: Math.ceil(slotCushionMaxWidth), // for less rerendering TODO: DRY
+ });
+ };
+ return _this;
+ }
+ TimelineView.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ var options = context.options;
+ var stickyHeaderDates = !props.forPrint && getStickyHeaderDates(options);
+ var stickyFooterScrollbar = !props.forPrint && getStickyFooterScrollbar(options);
+ var tDateProfile = this.buildTimelineDateProfile(props.dateProfile, context.dateEnv, options, context.dateProfileGenerator);
+ var extraClassNames = [
+ 'fc-timeline',
+ options.eventOverlap === false ? 'fc-timeline-overlap-disabled' : '',
+ ];
+ var slotMinWidth = options.slotMinWidth;
+ var slatCols = buildSlatCols(tDateProfile, slotMinWidth || this.computeFallbackSlotMinWidth(tDateProfile));
+ var sections = [
+ {
+ type: 'header',
+ key: 'header',
+ isSticky: stickyHeaderDates,
+ chunks: [{
+ key: 'timeline',
+ content: function (contentArg) { return (createElement(TimelineHeader, { dateProfile: props.dateProfile, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, tableMinWidth: contentArg.tableMinWidth, tableColGroupNode: contentArg.tableColGroupNode, tDateProfile: tDateProfile, slatCoords: state.slatCoords, onMaxCushionWidth: slotMinWidth ? null : _this.handleMaxCushionWidth })); },
+ }],
+ },
+ {
+ type: 'body',
+ key: 'body',
+ liquid: true,
+ chunks: [{
+ key: 'timeline',
+ content: function (contentArg) { return (createElement(TimelineGrid, __assign({}, props, { clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, tableMinWidth: contentArg.tableMinWidth, tableColGroupNode: contentArg.tableColGroupNode, tDateProfile: tDateProfile, onSlatCoords: _this.handleSlatCoords, onScrollLeftRequest: _this.handleScrollLeftRequest }))); },
+ }],
+ },
+ ];
+ if (stickyFooterScrollbar) {
+ sections.push({
+ type: 'footer',
+ key: 'footer',
+ isSticky: true,
+ chunks: [{
+ key: 'timeline',
+ content: renderScrollShim,
+ }],
+ });
+ }
+ return (createElement(ViewRoot, { viewSpec: context.viewSpec }, function (rootElRef, classNames) { return (createElement("div", { ref: rootElRef, className: extraClassNames.concat(classNames).join(' ') },
+ createElement(ScrollGrid, { ref: _this.scrollGridRef, liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: false, colGroups: [
+ { cols: slatCols },
+ ], sections: sections }))); }));
+ };
+ TimelineView.prototype.computeFallbackSlotMinWidth = function (tDateProfile) {
+ return Math.max(30, ((this.state.slotCushionMaxWidth || 0) / tDateProfile.slotsPerLabel));
+ };
+ return TimelineView;
+ }(DateComponent));
+ function buildSlatCols(tDateProfile, slotMinWidth) {
+ return [{
+ span: tDateProfile.slotCnt,
+ minWidth: slotMinWidth || 1, // needs to be a non-zero number to trigger horizontal scrollbars!??????
+ }];
+ }
+
+ var timelinePlugin = createPlugin({
+ deps: [
+ premiumCommonPlugin,
+ ],
+ initialView: 'timelineDay',
+ views: {
+ timeline: {
+ component: TimelineView,
+ usesMinMaxTime: true,
+ eventResizableFromStart: true, // how is this consumed for TimelineView tho?
+ },
+ timelineDay: {
+ type: 'timeline',
+ duration: { days: 1 },
+ },
+ timelineWeek: {
+ type: 'timeline',
+ duration: { weeks: 1 },
+ },
+ timelineMonth: {
+ type: 'timeline',
+ duration: { months: 1 },
+ },
+ timelineYear: {
+ type: 'timeline',
+ duration: { years: 1 },
+ },
+ },
+ });
+
+ function massageEventDragMutation(eventMutation, hit0, hit1) {
+ var resource0 = hit0.dateSpan.resourceId;
+ var resource1 = hit1.dateSpan.resourceId;
+ if (resource0 && resource1 &&
+ resource0 !== resource1) {
+ eventMutation.resourceMutation = {
+ matchResourceId: resource0,
+ setResourceId: resource1,
+ };
+ }
+ }
+ /*
+ TODO: all this would be much easier if we were using a hash!
+ */
+ function applyEventDefMutation(eventDef, mutation, context) {
+ var resourceMutation = mutation.resourceMutation;
+ if (resourceMutation && computeResourceEditable(eventDef, context)) {
+ var index = eventDef.resourceIds.indexOf(resourceMutation.matchResourceId);
+ if (index !== -1) {
+ var resourceIds = eventDef.resourceIds.slice(); // copy
+ resourceIds.splice(index, 1); // remove
+ if (resourceIds.indexOf(resourceMutation.setResourceId) === -1) { // not already in there
+ resourceIds.push(resourceMutation.setResourceId); // add
+ }
+ eventDef.resourceIds = resourceIds;
+ }
+ }
+ }
+ /*
+ HACK
+ TODO: use EventUi system instead of this
+ */
+ function computeResourceEditable(eventDef, context) {
+ var resourceEditable = eventDef.resourceEditable;
+ if (resourceEditable == null) {
+ var source = eventDef.sourceId && context.getCurrentData().eventSources[eventDef.sourceId];
+ if (source) {
+ resourceEditable = source.extendedProps.resourceEditable; // used the Source::extendedProps hack
+ }
+ if (resourceEditable == null) {
+ resourceEditable = context.options.eventResourceEditable;
+ if (resourceEditable == null) {
+ resourceEditable = context.options.editable; // TODO: use defaults system instead
+ }
+ }
+ }
+ return resourceEditable;
+ }
+ function transformEventDrop(mutation, context) {
+ var resourceMutation = mutation.resourceMutation;
+ if (resourceMutation) {
+ var calendarApi = context.calendarApi;
+ return {
+ oldResource: calendarApi.getResourceById(resourceMutation.matchResourceId),
+ newResource: calendarApi.getResourceById(resourceMutation.setResourceId),
+ };
+ }
+ return {
+ oldResource: null,
+ newResource: null,
+ };
+ }
+
+ var ResourceDataAdder = /** @class */ (function () {
+ function ResourceDataAdder() {
+ this.filterResources = memoize(filterResources);
+ }
+ ResourceDataAdder.prototype.transform = function (viewProps, calendarProps) {
+ if (calendarProps.viewSpec.optionDefaults.needsResourceData) {
+ return {
+ resourceStore: this.filterResources(calendarProps.resourceStore, calendarProps.options.filterResourcesWithEvents, calendarProps.eventStore, calendarProps.dateProfile.activeRange),
+ resourceEntityExpansions: calendarProps.resourceEntityExpansions,
+ };
+ }
+ return null;
+ };
+ return ResourceDataAdder;
+ }());
+ function filterResources(resourceStore, doFilterResourcesWithEvents, eventStore, activeRange) {
+ if (doFilterResourcesWithEvents) {
+ var instancesInRange = filterEventInstancesInRange(eventStore.instances, activeRange);
+ var hasEvents_1 = computeHasEvents(instancesInRange, eventStore.defs);
+ __assign(hasEvents_1, computeAncestorHasEvents(hasEvents_1, resourceStore));
+ return filterHash(resourceStore, function (resource, resourceId) { return hasEvents_1[resourceId]; });
+ }
+ return resourceStore;
+ }
+ function filterEventInstancesInRange(eventInstances, activeRange) {
+ return filterHash(eventInstances, function (eventInstance) { return rangesIntersect(eventInstance.range, activeRange); });
+ }
+ function computeHasEvents(eventInstances, eventDefs) {
+ var hasEvents = {};
+ for (var instanceId in eventInstances) {
+ var instance = eventInstances[instanceId];
+ for (var _i = 0, _a = eventDefs[instance.defId].resourceIds; _i < _a.length; _i++) {
+ var resourceId = _a[_i];
+ hasEvents[resourceId] = true;
+ }
+ }
+ return hasEvents;
+ }
+ /*
+ mark resources as having events if any of their ancestors have them
+ NOTE: resourceStore might not have all the resources that hasEvents{} has keyed
+ */
+ function computeAncestorHasEvents(hasEvents, resourceStore) {
+ var res = {};
+ for (var resourceId in hasEvents) {
+ var resource = void 0;
+ while ((resource = resourceStore[resourceId])) {
+ resourceId = resource.parentId; // now functioning as the parentId
+ if (resourceId) {
+ res[resourceId] = true;
+ }
+ else {
+ break;
+ }
+ }
+ }
+ return res;
+ }
+ /*
+ for making sure events that have editable resources are always draggable in resource views
+ */
+ function transformIsDraggable(val, eventDef, eventUi, context) {
+ if (!val) {
+ var state = context.getCurrentData();
+ var viewSpec = state.viewSpecs[state.currentViewType];
+ if (viewSpec.optionDefaults.needsResourceData) {
+ if (computeResourceEditable(eventDef, context)) {
+ return true;
+ }
+ }
+ }
+ return val;
+ }
+
+ // for when non-resource view should be given EventUi info (for event coloring/constraints based off of resource data)
+ var ResourceEventConfigAdder = /** @class */ (function () {
+ function ResourceEventConfigAdder() {
+ this.buildResourceEventUis = memoize(buildResourceEventUis, isPropsEqual);
+ this.injectResourceEventUis = memoize(injectResourceEventUis);
+ }
+ ResourceEventConfigAdder.prototype.transform = function (viewProps, calendarProps) {
+ if (!calendarProps.viewSpec.optionDefaults.needsResourceData) {
+ return {
+ eventUiBases: this.injectResourceEventUis(viewProps.eventUiBases, viewProps.eventStore.defs, this.buildResourceEventUis(calendarProps.resourceStore)),
+ };
+ }
+ return null;
+ };
+ return ResourceEventConfigAdder;
+ }());
+ function buildResourceEventUis(resourceStore) {
+ return mapHash(resourceStore, function (resource) { return resource.ui; });
+ }
+ function injectResourceEventUis(eventUiBases, eventDefs, resourceEventUis) {
+ return mapHash(eventUiBases, function (eventUi, defId) {
+ if (defId) { // not the '' key
+ return injectResourceEventUi(eventUi, eventDefs[defId], resourceEventUis);
+ }
+ return eventUi;
+ });
+ }
+ function injectResourceEventUi(origEventUi, eventDef, resourceEventUis) {
+ var parts = [];
+ // first resource takes precedence, which fights with the ordering of combineEventUis, thus the unshifts
+ for (var _i = 0, _a = eventDef.resourceIds; _i < _a.length; _i++) {
+ var resourceId = _a[_i];
+ if (resourceEventUis[resourceId]) {
+ parts.unshift(resourceEventUis[resourceId]);
+ }
+ }
+ parts.unshift(origEventUi);
+ return combineEventUis(parts);
+ }
+
+ var defs = []; // TODO: use plugin system
+ function registerResourceSourceDef(def) {
+ defs.push(def);
+ }
+ function getResourceSourceDef(id) {
+ return defs[id];
+ }
+ function getResourceSourceDefs() {
+ return defs;
+ }
+
+ // TODO: make this a plugin-able parser
+ // TODO: success/failure
+ var RESOURCE_SOURCE_REFINERS = {
+ id: String,
+ // for array. TODO: move to resource-array
+ resources: identity,
+ // for json feed. TODO: move to resource-json-feed
+ url: String,
+ method: String,
+ startParam: String,
+ endParam: String,
+ timeZoneParam: String,
+ extraParams: identity,
+ };
+ function parseResourceSource(input) {
+ var inputObj;
+ if (typeof input === 'string') {
+ inputObj = { url: input };
+ }
+ else if (typeof input === 'function' || Array.isArray(input)) {
+ inputObj = { resources: input };
+ }
+ else if (typeof input === 'object' && input) { // non-null object
+ inputObj = input;
+ }
+ if (inputObj) {
+ var _a = refineProps(inputObj, RESOURCE_SOURCE_REFINERS), refined = _a.refined, extra = _a.extra;
+ warnUnknownProps(extra);
+ var metaRes = buildResourceSourceMeta(refined);
+ if (metaRes) {
+ return {
+ _raw: input,
+ sourceId: guid(),
+ sourceDefId: metaRes.sourceDefId,
+ meta: metaRes.meta,
+ publicId: refined.id || '',
+ isFetching: false,
+ latestFetchId: '',
+ fetchRange: null,
+ };
+ }
+ }
+ return null;
+ }
+ function buildResourceSourceMeta(refined) {
+ var defs = getResourceSourceDefs();
+ for (var i = defs.length - 1; i >= 0; i -= 1) { // later-added plugins take precedence
+ var def = defs[i];
+ var meta = def.parseMeta(refined);
+ if (meta) {
+ return { meta: meta, sourceDefId: i };
+ }
+ }
+ return null;
+ }
+ function warnUnknownProps(props) {
+ for (var propName in props) {
+ console.warn("Unknown resource prop '" + propName + "'");
+ }
+ }
+
+ function reduceResourceSource(source, action, context) {
+ var options = context.options, dateProfile = context.dateProfile;
+ if (!source || !action) {
+ return createSource(options.initialResources || options.resources, dateProfile.activeRange, options.refetchResourcesOnNavigate, context);
+ }
+ switch (action.type) {
+ case 'RESET_RESOURCE_SOURCE':
+ return createSource(action.resourceSourceInput, dateProfile.activeRange, options.refetchResourcesOnNavigate, context);
+ case 'PREV': // TODO: how do we track all actions that affect dateProfile :(
+ case 'NEXT':
+ case 'CHANGE_DATE':
+ case 'CHANGE_VIEW_TYPE':
+ return handleRangeChange(source, dateProfile.activeRange, options.refetchResourcesOnNavigate, context);
+ case 'RECEIVE_RESOURCES':
+ case 'RECEIVE_RESOURCE_ERROR':
+ return receiveResponse(source, action.fetchId, action.fetchRange);
+ case 'REFETCH_RESOURCES':
+ return fetchSource(source, dateProfile.activeRange, context);
+ default:
+ return source;
+ }
+ }
+ function createSource(input, activeRange, refetchResourcesOnNavigate, context) {
+ if (input) {
+ var source = parseResourceSource(input);
+ source = fetchSource(source, refetchResourcesOnNavigate ? activeRange : null, context);
+ return source;
+ }
+ return null;
+ }
+ function handleRangeChange(source, activeRange, refetchResourcesOnNavigate, context) {
+ if (refetchResourcesOnNavigate &&
+ !doesSourceIgnoreRange(source) &&
+ (!source.fetchRange || !rangesEqual(source.fetchRange, activeRange))) {
+ return fetchSource(source, activeRange, context);
+ }
+ return source;
+ }
+ function doesSourceIgnoreRange(source) {
+ return Boolean(getResourceSourceDef(source.sourceDefId).ignoreRange);
+ }
+ function fetchSource(source, fetchRange, context) {
+ var sourceDef = getResourceSourceDef(source.sourceDefId);
+ var fetchId = guid();
+ sourceDef.fetch({
+ resourceSource: source,
+ range: fetchRange,
+ context: context,
+ }, function (res) {
+ context.dispatch({
+ type: 'RECEIVE_RESOURCES',
+ fetchId: fetchId,
+ fetchRange: fetchRange,
+ rawResources: res.rawResources,
+ });
+ }, function (error) {
+ context.dispatch({
+ type: 'RECEIVE_RESOURCE_ERROR',
+ fetchId: fetchId,
+ fetchRange: fetchRange,
+ error: error,
+ });
+ });
+ return __assign(__assign({}, source), { isFetching: true, latestFetchId: fetchId });
+ }
+ function receiveResponse(source, fetchId, fetchRange) {
+ if (fetchId === source.latestFetchId) {
+ return __assign(__assign({}, source), { isFetching: false, fetchRange: fetchRange });
+ }
+ return source;
+ }
+
+ var PRIVATE_ID_PREFIX = '_fc:';
+ var RESOURCE_REFINERS = {
+ id: String,
+ parentId: String,
+ children: identity,
+ title: String,
+ businessHours: identity,
+ extendedProps: identity,
+ // event-ui
+ eventEditable: Boolean,
+ eventStartEditable: Boolean,
+ eventDurationEditable: Boolean,
+ eventConstraint: identity,
+ eventOverlap: Boolean,
+ eventAllow: identity,
+ eventClassNames: parseClassNames,
+ eventBackgroundColor: String,
+ eventBorderColor: String,
+ eventTextColor: String,
+ eventColor: String,
+ };
+ /*
+ needs a full store so that it can populate children too
+ */
+ function parseResource(raw, parentId, store, context) {
+ if (parentId === void 0) { parentId = ''; }
+ var _a = refineProps(raw, RESOURCE_REFINERS), refined = _a.refined, extra = _a.extra;
+ var resource = {
+ id: refined.id || (PRIVATE_ID_PREFIX + guid()),
+ parentId: refined.parentId || parentId,
+ title: refined.title || '',
+ businessHours: refined.businessHours ? parseBusinessHours(refined.businessHours, context) : null,
+ ui: createEventUi({
+ editable: refined.eventEditable,
+ startEditable: refined.eventStartEditable,
+ durationEditable: refined.eventDurationEditable,
+ constraint: refined.eventConstraint,
+ overlap: refined.eventOverlap,
+ allow: refined.eventAllow,
+ classNames: refined.eventClassNames,
+ backgroundColor: refined.eventBackgroundColor,
+ borderColor: refined.eventBorderColor,
+ textColor: refined.eventTextColor,
+ color: refined.eventColor,
+ }, context),
+ extendedProps: __assign(__assign({}, extra), refined.extendedProps),
+ };
+ // help out ResourceApi from having user modify props
+ Object.freeze(resource.ui.classNames);
+ Object.freeze(resource.extendedProps);
+ if (store[resource.id]) ;
+ else {
+ store[resource.id] = resource;
+ if (refined.children) {
+ for (var _i = 0, _b = refined.children; _i < _b.length; _i++) {
+ var childInput = _b[_i];
+ parseResource(childInput, resource.id, store, context);
+ }
+ }
+ }
+ return resource;
+ }
+ /*
+ TODO: use this in more places
+ */
+ function getPublicId(id) {
+ if (id.indexOf(PRIVATE_ID_PREFIX) === 0) {
+ return '';
+ }
+ return id;
+ }
+
+ function reduceResourceStore(store, action, source, context) {
+ if (!store || !action) {
+ return {};
+ }
+ switch (action.type) {
+ case 'RECEIVE_RESOURCES':
+ return receiveRawResources(store, action.rawResources, action.fetchId, source, context);
+ case 'ADD_RESOURCE':
+ return addResource(store, action.resourceHash);
+ case 'REMOVE_RESOURCE':
+ return removeResource(store, action.resourceId);
+ case 'SET_RESOURCE_PROP':
+ return setResourceProp(store, action.resourceId, action.propName, action.propValue);
+ case 'SET_RESOURCE_EXTENDED_PROP':
+ return setResourceExtendedProp(store, action.resourceId, action.propName, action.propValue);
+ default:
+ return store;
+ }
+ }
+ function receiveRawResources(existingStore, inputs, fetchId, source, context) {
+ if (source.latestFetchId === fetchId) {
+ var nextStore = {};
+ for (var _i = 0, inputs_1 = inputs; _i < inputs_1.length; _i++) {
+ var input = inputs_1[_i];
+ parseResource(input, '', nextStore, context);
+ }
+ return nextStore;
+ }
+ return existingStore;
+ }
+ function addResource(existingStore, additions) {
+ // TODO: warn about duplicate IDs
+ return __assign(__assign({}, existingStore), additions);
+ }
+ function removeResource(existingStore, resourceId) {
+ var newStore = __assign({}, existingStore);
+ delete newStore[resourceId];
+ // promote children
+ for (var childResourceId in newStore) { // a child, *maybe* but probably not
+ if (newStore[childResourceId].parentId === resourceId) {
+ newStore[childResourceId] = __assign(__assign({}, newStore[childResourceId]), { parentId: '' });
+ }
+ }
+ return newStore;
+ }
+ function setResourceProp(existingStore, resourceId, name, value) {
+ var _a, _b;
+ var existingResource = existingStore[resourceId];
+ // TODO: sanitization
+ if (existingResource) {
+ return __assign(__assign({}, existingStore), (_a = {}, _a[resourceId] = __assign(__assign({}, existingResource), (_b = {}, _b[name] = value, _b)), _a));
+ }
+ return existingStore;
+ }
+ function setResourceExtendedProp(existingStore, resourceId, name, value) {
+ var _a, _b;
+ var existingResource = existingStore[resourceId];
+ if (existingResource) {
+ return __assign(__assign({}, existingStore), (_a = {}, _a[resourceId] = __assign(__assign({}, existingResource), { extendedProps: __assign(__assign({}, existingResource.extendedProps), (_b = {}, _b[name] = value, _b)) }), _a));
+ }
+ return existingStore;
+ }
+
+ function reduceResourceEntityExpansions(expansions, action) {
+ var _a;
+ if (!expansions || !action) {
+ return {};
+ }
+ switch (action.type) {
+ case 'SET_RESOURCE_ENTITY_EXPANDED':
+ return __assign(__assign({}, expansions), (_a = {}, _a[action.id] = action.isExpanded, _a));
+ default:
+ return expansions;
+ }
+ }
+
+ function reduceResources(state, action, context) {
+ var resourceSource = reduceResourceSource(state && state.resourceSource, action, context);
+ var resourceStore = reduceResourceStore(state && state.resourceStore, action, resourceSource, context);
+ var resourceEntityExpansions = reduceResourceEntityExpansions(state && state.resourceEntityExpansions, action);
+ return {
+ resourceSource: resourceSource,
+ resourceStore: resourceStore,
+ resourceEntityExpansions: resourceEntityExpansions,
+ };
+ }
+
+ var EVENT_REFINERS = {
+ resourceId: String,
+ resourceIds: identity,
+ resourceEditable: Boolean,
+ };
+ function generateEventDefResourceMembers(refined) {
+ return {
+ resourceIds: ensureStringArray(refined.resourceIds)
+ .concat(refined.resourceId ? [refined.resourceId] : []),
+ resourceEditable: refined.resourceEditable,
+ };
+ }
+ function ensureStringArray(items) {
+ return (items || []).map(function (item) { return String(item); });
+ }
+
+ function transformDateSelectionJoin(hit0, hit1) {
+ var resourceId0 = hit0.dateSpan.resourceId;
+ var resourceId1 = hit1.dateSpan.resourceId;
+ if (resourceId0 && resourceId1) {
+ return { resourceId: resourceId0 };
+ }
+ return null;
+ }
+
+ var ResourceApi = /** @class */ (function () {
+ function ResourceApi(_context, _resource) {
+ this._context = _context;
+ this._resource = _resource;
+ }
+ ResourceApi.prototype.setProp = function (name, value) {
+ var oldResource = this._resource;
+ this._context.dispatch({
+ type: 'SET_RESOURCE_PROP',
+ resourceId: oldResource.id,
+ propName: name,
+ propValue: value,
+ });
+ this.sync(oldResource);
+ };
+ ResourceApi.prototype.setExtendedProp = function (name, value) {
+ var oldResource = this._resource;
+ this._context.dispatch({
+ type: 'SET_RESOURCE_EXTENDED_PROP',
+ resourceId: oldResource.id,
+ propName: name,
+ propValue: value,
+ });
+ this.sync(oldResource);
+ };
+ ResourceApi.prototype.sync = function (oldResource) {
+ var context = this._context;
+ var resourceId = oldResource.id;
+ // TODO: what if dispatch didn't complete synchronously?
+ this._resource = context.getCurrentData().resourceStore[resourceId];
+ context.emitter.trigger('resourceChange', {
+ oldResource: new ResourceApi(context, oldResource),
+ resource: this,
+ revert: function () {
+ var _a;
+ context.dispatch({
+ type: 'ADD_RESOURCE',
+ resourceHash: (_a = {},
+ _a[resourceId] = oldResource,
+ _a),
+ });
+ },
+ });
+ };
+ ResourceApi.prototype.remove = function () {
+ var context = this._context;
+ var internalResource = this._resource;
+ var resourceId = internalResource.id;
+ context.dispatch({
+ type: 'REMOVE_RESOURCE',
+ resourceId: resourceId,
+ });
+ context.emitter.trigger('resourceRemove', {
+ resource: this,
+ revert: function () {
+ var _a;
+ context.dispatch({
+ type: 'ADD_RESOURCE',
+ resourceHash: (_a = {},
+ _a[resourceId] = internalResource,
+ _a),
+ });
+ },
+ });
+ };
+ ResourceApi.prototype.getParent = function () {
+ var context = this._context;
+ var parentId = this._resource.parentId;
+ if (parentId) {
+ return new ResourceApi(context, context.getCurrentData().resourceSource[parentId]);
+ }
+ return null;
+ };
+ ResourceApi.prototype.getChildren = function () {
+ var thisResourceId = this._resource.id;
+ var context = this._context;
+ var resourceStore = context.getCurrentData().resourceStore;
+ var childApis = [];
+ for (var resourceId in resourceStore) {
+ if (resourceStore[resourceId].parentId === thisResourceId) {
+ childApis.push(new ResourceApi(context, resourceStore[resourceId]));
+ }
+ }
+ return childApis;
+ };
+ /*
+ this is really inefficient!
+ TODO: make EventApi::resourceIds a hash or keep an index in the Calendar's state
+ */
+ ResourceApi.prototype.getEvents = function () {
+ var thisResourceId = this._resource.id;
+ var context = this._context;
+ var _a = context.getCurrentData().eventStore, defs = _a.defs, instances = _a.instances;
+ var eventApis = [];
+ for (var instanceId in instances) {
+ var instance = instances[instanceId];
+ var def = defs[instance.defId];
+ if (def.resourceIds.indexOf(thisResourceId) !== -1) { // inefficient!!!
+ eventApis.push(new EventApi(context, def, instance));
+ }
+ }
+ return eventApis;
+ };
+ Object.defineProperty(ResourceApi.prototype, "id", {
+ get: function () { return getPublicId(this._resource.id); },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ResourceApi.prototype, "title", {
+ get: function () { return this._resource.title; },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ResourceApi.prototype, "eventConstraint", {
+ get: function () { return this._resource.ui.constraints[0] || null; },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ResourceApi.prototype, "eventOverlap", {
+ get: function () { return this._resource.ui.overlap; },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ResourceApi.prototype, "eventAllow", {
+ get: function () { return this._resource.ui.allows[0] || null; },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ResourceApi.prototype, "eventBackgroundColor", {
+ get: function () { return this._resource.ui.backgroundColor; },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ResourceApi.prototype, "eventBorderColor", {
+ get: function () { return this._resource.ui.borderColor; },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ResourceApi.prototype, "eventTextColor", {
+ get: function () { return this._resource.ui.textColor; },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ResourceApi.prototype, "eventClassNames", {
+ // NOTE: user can't modify these because Object.freeze was called in event-def parsing
+ get: function () { return this._resource.ui.classNames; },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ResourceApi.prototype, "extendedProps", {
+ get: function () { return this._resource.extendedProps; },
+ enumerable: false,
+ configurable: true
+ });
+ ResourceApi.prototype.toPlainObject = function (settings) {
+ if (settings === void 0) { settings = {}; }
+ var internal = this._resource;
+ var ui = internal.ui;
+ var publicId = this.id;
+ var res = {};
+ if (publicId) {
+ res.id = publicId;
+ }
+ if (internal.title) {
+ res.title = internal.title;
+ }
+ if (settings.collapseEventColor && ui.backgroundColor && ui.backgroundColor === ui.borderColor) {
+ res.eventColor = ui.backgroundColor;
+ }
+ else {
+ if (ui.backgroundColor) {
+ res.eventBackgroundColor = ui.backgroundColor;
+ }
+ if (ui.borderColor) {
+ res.eventBorderColor = ui.borderColor;
+ }
+ }
+ if (ui.textColor) {
+ res.eventTextColor = ui.textColor;
+ }
+ if (ui.classNames.length) {
+ res.eventClassNames = ui.classNames;
+ }
+ if (Object.keys(internal.extendedProps).length) {
+ if (settings.collapseExtendedProps) {
+ __assign(res, internal.extendedProps);
+ }
+ else {
+ res.extendedProps = internal.extendedProps;
+ }
+ }
+ return res;
+ };
+ ResourceApi.prototype.toJSON = function () {
+ return this.toPlainObject();
+ };
+ return ResourceApi;
+ }());
+ function buildResourceApis(resourceStore, context) {
+ var resourceApis = [];
+ for (var resourceId in resourceStore) {
+ resourceApis.push(new ResourceApi(context, resourceStore[resourceId]));
+ }
+ return resourceApis;
+ }
+
+ CalendarApi.prototype.addResource = function (input, scrollTo) {
+ var _a;
+ var _this = this;
+ if (scrollTo === void 0) { scrollTo = true; }
+ var currentState = this.getCurrentData();
+ var resourceHash;
+ var resource;
+ if (input instanceof ResourceApi) {
+ resource = input._resource;
+ resourceHash = (_a = {}, _a[resource.id] = resource, _a);
+ }
+ else {
+ resourceHash = {};
+ resource = parseResource(input, '', resourceHash, currentState);
+ }
+ this.dispatch({
+ type: 'ADD_RESOURCE',
+ resourceHash: resourceHash,
+ });
+ if (scrollTo) {
+ // TODO: wait til dispatch completes somehow
+ this.trigger('_scrollRequest', { resourceId: resource.id });
+ }
+ var resourceApi = new ResourceApi(currentState, resource);
+ currentState.emitter.trigger('resourceAdd', {
+ resource: resourceApi,
+ revert: function () {
+ _this.dispatch({
+ type: 'REMOVE_RESOURCE',
+ resourceId: resource.id,
+ });
+ },
+ });
+ return resourceApi;
+ };
+ CalendarApi.prototype.getResourceById = function (id) {
+ id = String(id);
+ var currentState = this.getCurrentData(); // eslint-disable-line react/no-this-in-sfc
+ if (currentState.resourceStore) { // guard against calendar with no resource functionality
+ var rawResource = currentState.resourceStore[id];
+ if (rawResource) {
+ return new ResourceApi(currentState, rawResource);
+ }
+ }
+ return null;
+ };
+ CalendarApi.prototype.getResources = function () {
+ var currentState = this.getCurrentData();
+ var resourceStore = currentState.resourceStore;
+ var resourceApis = [];
+ if (resourceStore) { // guard against calendar with no resource functionality
+ for (var resourceId in resourceStore) {
+ resourceApis.push(new ResourceApi(currentState, resourceStore[resourceId]));
+ }
+ }
+ return resourceApis;
+ };
+ CalendarApi.prototype.getTopLevelResources = function () {
+ var currentState = this.getCurrentData();
+ var resourceStore = currentState.resourceStore;
+ var resourceApis = [];
+ if (resourceStore) { // guard against calendar with no resource functionality
+ for (var resourceId in resourceStore) {
+ if (!resourceStore[resourceId].parentId) {
+ resourceApis.push(new ResourceApi(currentState, resourceStore[resourceId]));
+ }
+ }
+ }
+ return resourceApis;
+ };
+ CalendarApi.prototype.refetchResources = function () {
+ this.dispatch({
+ type: 'REFETCH_RESOURCES',
+ });
+ };
+ function transformDatePoint(dateSpan, context) {
+ return dateSpan.resourceId ?
+ { resource: context.calendarApi.getResourceById(dateSpan.resourceId) } :
+ {};
+ }
+ function transformDateSpan(dateSpan, context) {
+ return dateSpan.resourceId ?
+ { resource: context.calendarApi.getResourceById(dateSpan.resourceId) } :
+ {};
+ }
+
+ /*
+ splits things BASED OFF OF which resources they are associated with.
+ creates a '' entry which is when something has NO resource.
+ */
+ var ResourceSplitter = /** @class */ (function (_super) {
+ __extends(ResourceSplitter, _super);
+ function ResourceSplitter() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ResourceSplitter.prototype.getKeyInfo = function (props) {
+ return __assign({ '': {} }, props.resourceStore);
+ };
+ ResourceSplitter.prototype.getKeysForDateSpan = function (dateSpan) {
+ return [dateSpan.resourceId || ''];
+ };
+ ResourceSplitter.prototype.getKeysForEventDef = function (eventDef) {
+ var resourceIds = eventDef.resourceIds;
+ if (!resourceIds.length) {
+ return [''];
+ }
+ return resourceIds;
+ };
+ return ResourceSplitter;
+ }(Splitter));
+
+ function isPropsValidWithResources(combinedProps, context) {
+ var splitter = new ResourceSplitter();
+ var sets = splitter.splitProps(__assign(__assign({}, combinedProps), { resourceStore: context.getCurrentData().resourceStore }));
+ for (var resourceId in sets) {
+ var props = sets[resourceId];
+ // merge in event data from the non-resource segment
+ if (resourceId && sets['']) { // current segment is not the non-resource one, and there IS a non-resource one
+ props = __assign(__assign({}, props), { eventStore: mergeEventStores(sets[''].eventStore, props.eventStore), eventUiBases: __assign(__assign({}, sets[''].eventUiBases), props.eventUiBases) });
+ }
+ if (!isPropsValid(props, context, { resourceId: resourceId }, filterConfig.bind(null, resourceId))) {
+ return false;
+ }
+ }
+ return true;
+ }
+ function filterConfig(resourceId, config) {
+ return __assign(__assign({}, config), { constraints: filterConstraints(resourceId, config.constraints) });
+ }
+ function filterConstraints(resourceId, constraints) {
+ return constraints.map(function (constraint) {
+ var defs = constraint.defs;
+ if (defs) { // we are dealing with an EventStore
+ // if any of the events define constraints to resources that are NOT this resource,
+ // then this resource is unconditionally prohibited, which is what a `false` value does.
+ for (var defId in defs) {
+ var resourceIds = defs[defId].resourceIds;
+ if (resourceIds.length && resourceIds.indexOf(resourceId) === -1) { // TODO: use a hash?!!! (for other reasons too)
+ return false;
+ }
+ }
+ }
+ return constraint;
+ });
+ }
+
+ function transformExternalDef(dateSpan) {
+ return dateSpan.resourceId ?
+ { resourceId: dateSpan.resourceId } :
+ {};
+ }
+
+ EventApi.prototype.getResources = function () {
+ var calendarApi = this._context.calendarApi;
+ return this._def.resourceIds.map(function (resourceId) { return calendarApi.getResourceById(resourceId); });
+ };
+ EventApi.prototype.setResources = function (resources) {
+ var resourceIds = [];
+ // massage resources -> resourceIds
+ for (var _i = 0, resources_1 = resources; _i < resources_1.length; _i++) {
+ var resource = resources_1[_i];
+ var resourceId = null;
+ if (typeof resource === 'string') {
+ resourceId = resource;
+ }
+ else if (typeof resource === 'number') {
+ resourceId = String(resource);
+ }
+ else if (resource instanceof ResourceApi) {
+ resourceId = resource.id; // guaranteed to always have an ID. hmmm
+ }
+ else {
+ console.warn('unknown resource type: ' + resource);
+ }
+ if (resourceId) {
+ resourceIds.push(resourceId);
+ }
+ }
+ this.mutate({
+ standardProps: {
+ resourceIds: resourceIds,
+ },
+ });
+ };
+
+ var optionChangeHandlers = {
+ resources: handleResources,
+ };
+ function handleResources(newSourceInput, context) {
+ var oldSourceInput = context.getCurrentData().resourceSource._raw;
+ if (oldSourceInput !== newSourceInput) {
+ context.dispatch({
+ type: 'RESET_RESOURCE_SOURCE',
+ resourceSourceInput: newSourceInput,
+ });
+ }
+ }
+
+ var DEFAULT_RESOURCE_ORDER = parseFieldSpecs('id,title');
+ function handleResourceStore(resourceStore, calendarData) {
+ var emitter = calendarData.emitter;
+ if (emitter.hasHandlers('resourcesSet')) {
+ emitter.trigger('resourcesSet', buildResourceApis(resourceStore, calendarData));
+ }
+ }
+
+ var OPTION_REFINERS = {
+ initialResources: identity,
+ resources: identity,
+ eventResourceEditable: Boolean,
+ refetchResourcesOnNavigate: Boolean,
+ resourceOrder: parseFieldSpecs,
+ filterResourcesWithEvents: Boolean,
+ resourceGroupField: String,
+ resourceAreaWidth: identity,
+ resourceAreaColumns: identity,
+ resourcesInitiallyExpanded: Boolean,
+ datesAboveResources: Boolean,
+ needsResourceData: Boolean,
+ resourceAreaHeaderClassNames: identity,
+ resourceAreaHeaderContent: identity,
+ resourceAreaHeaderDidMount: identity,
+ resourceAreaHeaderWillUnmount: identity,
+ resourceGroupLabelClassNames: identity,
+ resourceGroupLabelContent: identity,
+ resourceGroupLabelDidMount: identity,
+ resourceGroupLabelWillUnmount: identity,
+ resourceLabelClassNames: identity,
+ resourceLabelContent: identity,
+ resourceLabelDidMount: identity,
+ resourceLabelWillUnmount: identity,
+ resourceLaneClassNames: identity,
+ resourceLaneContent: identity,
+ resourceLaneDidMount: identity,
+ resourceLaneWillUnmount: identity,
+ resourceGroupLaneClassNames: identity,
+ resourceGroupLaneContent: identity,
+ resourceGroupLaneDidMount: identity,
+ resourceGroupLaneWillUnmount: identity,
+ };
+ var LISTENER_REFINERS = {
+ resourcesSet: identity,
+ resourceAdd: identity,
+ resourceChange: identity,
+ resourceRemove: identity,
+ };
+
+ registerResourceSourceDef({
+ ignoreRange: true,
+ parseMeta: function (refined) {
+ if (Array.isArray(refined.resources)) {
+ return refined.resources;
+ }
+ return null;
+ },
+ fetch: function (arg, successCallback) {
+ successCallback({
+ rawResources: arg.resourceSource.meta,
+ });
+ },
+ });
+
+ registerResourceSourceDef({
+ parseMeta: function (refined) {
+ if (typeof refined.resources === 'function') {
+ return refined.resources;
+ }
+ return null;
+ },
+ fetch: function (arg, success, failure) {
+ var dateEnv = arg.context.dateEnv;
+ var func = arg.resourceSource.meta;
+ var publicArg = arg.range ? {
+ start: dateEnv.toDate(arg.range.start),
+ end: dateEnv.toDate(arg.range.end),
+ startStr: dateEnv.formatIso(arg.range.start),
+ endStr: dateEnv.formatIso(arg.range.end),
+ timeZone: dateEnv.timeZone,
+ } : {};
+ // TODO: make more dry with EventSourceFunc
+ // TODO: accept a response?
+ unpromisify(func.bind(null, publicArg), function (rawResources) {
+ success({ rawResources: rawResources }); // needs an object response
+ }, failure);
+ },
+ });
+
+ registerResourceSourceDef({
+ parseMeta: function (refined) {
+ if (refined.url) {
+ return {
+ url: refined.url,
+ method: (refined.method || 'GET').toUpperCase(),
+ extraParams: refined.extraParams,
+ };
+ }
+ return null;
+ },
+ fetch: function (arg, successCallback, failureCallback) {
+ var meta = arg.resourceSource.meta;
+ var requestParams = buildRequestParams(meta, arg.range, arg.context);
+ requestJson(meta.method, meta.url, requestParams, function (rawResources, xhr) {
+ successCallback({ rawResources: rawResources, xhr: xhr });
+ }, function (message, xhr) {
+ failureCallback({ message: message, xhr: xhr });
+ });
+ },
+ });
+ // TODO: somehow consolidate with event json feed
+ function buildRequestParams(meta, range, context) {
+ var dateEnv = context.dateEnv, options = context.options;
+ var startParam;
+ var endParam;
+ var timeZoneParam;
+ var customRequestParams;
+ var params = {};
+ if (range) {
+ startParam = meta.startParam;
+ if (startParam == null) {
+ startParam = options.startParam;
+ }
+ endParam = meta.endParam;
+ if (endParam == null) {
+ endParam = options.endParam;
+ }
+ timeZoneParam = meta.timeZoneParam;
+ if (timeZoneParam == null) {
+ timeZoneParam = options.timeZoneParam;
+ }
+ params[startParam] = dateEnv.formatIso(range.start);
+ params[endParam] = dateEnv.formatIso(range.end);
+ if (dateEnv.timeZone !== 'local') {
+ params[timeZoneParam] = dateEnv.timeZone;
+ }
+ }
+ // retrieve any outbound GET/POST data from the options
+ if (typeof meta.extraParams === 'function') {
+ // supplied as a function that returns a key/value object
+ customRequestParams = meta.extraParams();
+ }
+ else {
+ // probably supplied as a straight key/value object
+ customRequestParams = meta.extraParams || {};
+ }
+ __assign(params, customRequestParams);
+ return params;
+ }
+
+ // TODO: not used for Spreadsheet. START USING. difficult because of col-specific rendering props
+ function ResourceLabelRoot(props) {
+ return (createElement(ViewContextType.Consumer, null, function (context) {
+ var options = context.options;
+ var hookProps = {
+ resource: new ResourceApi(context, props.resource),
+ date: props.date ? context.dateEnv.toDate(props.date) : null,
+ view: context.viewApi,
+ };
+ var dataAttrs = {
+ 'data-resource-id': props.resource.id,
+ 'data-date': props.date ? formatDayString(props.date) : undefined,
+ };
+ return (createElement(RenderHook, { hookProps: hookProps, classNames: options.resourceLabelClassNames, content: options.resourceLabelContent, defaultContent: renderInnerContent, didMount: options.resourceLabelDidMount, willUnmount: options.resourceLabelWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return props.children(rootElRef, classNames, // TODO: pass in 'fc-resource' ?
+ dataAttrs, innerElRef, innerContent); }));
+ }));
+ }
+ function renderInnerContent(props) {
+ return props.resource.title || props.resource.id;
+ }
+
+ var ResourceCell = /** @class */ (function (_super) {
+ __extends(ResourceCell, _super);
+ function ResourceCell() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ResourceCell.prototype.render = function () {
+ var props = this.props;
+ return (createElement(ResourceLabelRoot, { resource: props.resource, date: props.date }, function (elRef, customClassNames, dataAttrs, innerElRef, innerContent) { return (createElement("th", __assign({ ref: elRef, role: "columnheader", className: ['fc-col-header-cell', 'fc-resource'].concat(customClassNames).join(' '), colSpan: props.colSpan }, dataAttrs),
+ createElement("div", { className: "fc-scrollgrid-sync-inner" },
+ createElement("span", { className: [
+ 'fc-col-header-cell-cushion',
+ props.isSticky ? 'fc-sticky' : '',
+ ].join(' '), ref: innerElRef }, innerContent)))); }));
+ };
+ return ResourceCell;
+ }(BaseComponent));
+
+ var ResourceDayHeader = /** @class */ (function (_super) {
+ __extends(ResourceDayHeader, _super);
+ function ResourceDayHeader() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.buildDateFormat = memoize(buildDateFormat);
+ return _this;
+ }
+ ResourceDayHeader.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var dateFormat = this.buildDateFormat(context.options.dayHeaderFormat, props.datesRepDistinctDays, props.dates.length);
+ return (createElement(NowTimer, { unit: "day" }, function (nowDate, todayRange) {
+ if (props.dates.length === 1) {
+ return _this.renderResourceRow(props.resources, props.dates[0]);
+ }
+ if (context.options.datesAboveResources) {
+ return _this.renderDayAndResourceRows(props.dates, dateFormat, todayRange, props.resources);
+ }
+ return _this.renderResourceAndDayRows(props.resources, props.dates, dateFormat, todayRange);
+ }));
+ };
+ ResourceDayHeader.prototype.renderResourceRow = function (resources, date) {
+ var resourceCells = resources.map(function (resource) { return (createElement(ResourceCell, { key: resource.id, resource: resource, colSpan: 1, date: date })); });
+ return this.buildTr(resourceCells, 'resources');
+ };
+ ResourceDayHeader.prototype.renderDayAndResourceRows = function (dates, dateFormat, todayRange, resources) {
+ var dateCells = [];
+ var resourceCells = [];
+ for (var _i = 0, dates_1 = dates; _i < dates_1.length; _i++) {
+ var date = dates_1[_i];
+ dateCells.push(this.renderDateCell(date, dateFormat, todayRange, resources.length, null, true));
+ for (var _a = 0, resources_1 = resources; _a < resources_1.length; _a++) {
+ var resource = resources_1[_a];
+ resourceCells.push(createElement(ResourceCell, { key: resource.id + ':' + date.toISOString(), resource: resource, colSpan: 1, date: date }));
+ }
+ }
+ return (createElement(Fragment, null,
+ this.buildTr(dateCells, 'day'),
+ this.buildTr(resourceCells, 'resources')));
+ };
+ ResourceDayHeader.prototype.renderResourceAndDayRows = function (resources, dates, dateFormat, todayRange) {
+ var resourceCells = [];
+ var dateCells = [];
+ for (var _i = 0, resources_2 = resources; _i < resources_2.length; _i++) {
+ var resource = resources_2[_i];
+ resourceCells.push(createElement(ResourceCell, { key: resource.id, resource: resource, colSpan: dates.length, isSticky: true }));
+ for (var _a = 0, dates_2 = dates; _a < dates_2.length; _a++) {
+ var date = dates_2[_a];
+ dateCells.push(this.renderDateCell(date, dateFormat, todayRange, 1, resource));
+ }
+ }
+ return (createElement(Fragment, null,
+ this.buildTr(resourceCells, 'resources'),
+ this.buildTr(dateCells, 'day')));
+ };
+ // a cell with date text. might have a resource associated with it
+ ResourceDayHeader.prototype.renderDateCell = function (date, dateFormat, todayRange, colSpan, resource, isSticky) {
+ var props = this.props;
+ var keyPostfix = resource ? ":" + resource.id : '';
+ var extraHookProps = resource ? { resource: new ResourceApi(this.context, resource) } : {};
+ var extraDataAttrs = resource ? { 'data-resource-id': resource.id } : {};
+ return props.datesRepDistinctDays ? (createElement(TableDateCell, { key: date.toISOString() + keyPostfix, date: date, dateProfile: props.dateProfile, todayRange: todayRange, colCnt: props.dates.length * props.resources.length, dayHeaderFormat: dateFormat, colSpan: colSpan, isSticky: isSticky, extraHookProps: extraHookProps, extraDataAttrs: extraDataAttrs })) : (createElement(TableDowCell // we can't leverage the pure-componentness becausae the extra* props are new every time :(
+ , { key: date.getUTCDay() + keyPostfix, dow: date.getUTCDay(), dayHeaderFormat: dateFormat, colSpan: colSpan, isSticky: isSticky, extraHookProps: extraHookProps, extraDataAttrs: extraDataAttrs }));
+ };
+ ResourceDayHeader.prototype.buildTr = function (cells, key) {
+ var renderIntro = this.props.renderIntro;
+ if (!cells.length) {
+ cells = [createElement("td", { key: 0 }, "\u00A0")];
+ }
+ return (createElement("tr", { key: key, role: "row" },
+ renderIntro && renderIntro(key),
+ cells));
+ };
+ return ResourceDayHeader;
+ }(BaseComponent));
+ function buildDateFormat(dayHeaderFormat, datesRepDistinctDays, dayCnt) {
+ return dayHeaderFormat || computeFallbackHeaderFormat(datesRepDistinctDays, dayCnt);
+ }
+
+ var ResourceIndex = /** @class */ (function () {
+ function ResourceIndex(resources) {
+ var indicesById = {};
+ var ids = [];
+ for (var i = 0; i < resources.length; i += 1) {
+ var id = resources[i].id;
+ ids.push(id);
+ indicesById[id] = i;
+ }
+ this.ids = ids;
+ this.indicesById = indicesById;
+ this.length = resources.length;
+ }
+ return ResourceIndex;
+ }());
+
+ var AbstractResourceDayTableModel = /** @class */ (function () {
+ function AbstractResourceDayTableModel(dayTableModel, resources, context) {
+ this.dayTableModel = dayTableModel;
+ this.resources = resources;
+ this.context = context;
+ this.resourceIndex = new ResourceIndex(resources);
+ this.rowCnt = dayTableModel.rowCnt;
+ this.colCnt = dayTableModel.colCnt * resources.length;
+ this.cells = this.buildCells();
+ }
+ AbstractResourceDayTableModel.prototype.buildCells = function () {
+ var _a = this, rowCnt = _a.rowCnt, dayTableModel = _a.dayTableModel, resources = _a.resources;
+ var rows = [];
+ for (var row = 0; row < rowCnt; row += 1) {
+ var rowCells = [];
+ for (var dateCol = 0; dateCol < dayTableModel.colCnt; dateCol += 1) {
+ for (var resourceCol = 0; resourceCol < resources.length; resourceCol += 1) {
+ var resource = resources[resourceCol];
+ var extraHookProps = { resource: new ResourceApi(this.context, resource) };
+ var extraDataAttrs = { 'data-resource-id': resource.id };
+ var extraClassNames = ['fc-resource'];
+ var extraDateSpan = { resourceId: resource.id };
+ var date = dayTableModel.cells[row][dateCol].date;
+ rowCells[this.computeCol(dateCol, resourceCol)] = {
+ key: resource.id + ':' + date.toISOString(),
+ date: date,
+ extraHookProps: extraHookProps,
+ extraDataAttrs: extraDataAttrs,
+ extraClassNames: extraClassNames,
+ extraDateSpan: extraDateSpan,
+ };
+ }
+ }
+ rows.push(rowCells);
+ }
+ return rows;
+ };
+ return AbstractResourceDayTableModel;
+ }());
+
+ /*
+ resources over dates
+ */
+ var ResourceDayTableModel = /** @class */ (function (_super) {
+ __extends(ResourceDayTableModel, _super);
+ function ResourceDayTableModel() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ResourceDayTableModel.prototype.computeCol = function (dateI, resourceI) {
+ return resourceI * this.dayTableModel.colCnt + dateI;
+ };
+ /*
+ all date ranges are intact
+ */
+ ResourceDayTableModel.prototype.computeColRanges = function (dateStartI, dateEndI, resourceI) {
+ return [
+ {
+ firstCol: this.computeCol(dateStartI, resourceI),
+ lastCol: this.computeCol(dateEndI, resourceI),
+ isStart: true,
+ isEnd: true,
+ },
+ ];
+ };
+ return ResourceDayTableModel;
+ }(AbstractResourceDayTableModel));
+
+ /*
+ dates over resources
+ */
+ var DayResourceTableModel = /** @class */ (function (_super) {
+ __extends(DayResourceTableModel, _super);
+ function DayResourceTableModel() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ DayResourceTableModel.prototype.computeCol = function (dateI, resourceI) {
+ return dateI * this.resources.length + resourceI;
+ };
+ /*
+ every single day is broken up
+ */
+ DayResourceTableModel.prototype.computeColRanges = function (dateStartI, dateEndI, resourceI) {
+ var segs = [];
+ for (var i = dateStartI; i <= dateEndI; i += 1) {
+ var col = this.computeCol(i, resourceI);
+ segs.push({
+ firstCol: col,
+ lastCol: col,
+ isStart: i === dateStartI,
+ isEnd: i === dateEndI,
+ });
+ }
+ return segs;
+ };
+ return DayResourceTableModel;
+ }(AbstractResourceDayTableModel));
+
+ var NO_SEGS = []; // for memoizing
+ var VResourceJoiner = /** @class */ (function () {
+ function VResourceJoiner() {
+ this.joinDateSelection = memoize(this.joinSegs);
+ this.joinBusinessHours = memoize(this.joinSegs);
+ this.joinFgEvents = memoize(this.joinSegs);
+ this.joinBgEvents = memoize(this.joinSegs);
+ this.joinEventDrags = memoize(this.joinInteractions);
+ this.joinEventResizes = memoize(this.joinInteractions);
+ }
+ /*
+ propSets also has a '' key for things with no resource
+ */
+ VResourceJoiner.prototype.joinProps = function (propSets, resourceDayTable) {
+ var dateSelectionSets = [];
+ var businessHoursSets = [];
+ var fgEventSets = [];
+ var bgEventSets = [];
+ var eventDrags = [];
+ var eventResizes = [];
+ var eventSelection = '';
+ var keys = resourceDayTable.resourceIndex.ids.concat(['']); // add in the all-resource key
+ for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+ var key = keys_1[_i];
+ var props = propSets[key];
+ dateSelectionSets.push(props.dateSelectionSegs);
+ businessHoursSets.push(key ? props.businessHourSegs : NO_SEGS); // don't include redundant all-resource businesshours
+ fgEventSets.push(key ? props.fgEventSegs : NO_SEGS); // don't include fg all-resource segs
+ bgEventSets.push(props.bgEventSegs);
+ eventDrags.push(props.eventDrag);
+ eventResizes.push(props.eventResize);
+ eventSelection = eventSelection || props.eventSelection;
+ }
+ return {
+ dateSelectionSegs: this.joinDateSelection.apply(this, __spreadArray([resourceDayTable], dateSelectionSets)),
+ businessHourSegs: this.joinBusinessHours.apply(this, __spreadArray([resourceDayTable], businessHoursSets)),
+ fgEventSegs: this.joinFgEvents.apply(this, __spreadArray([resourceDayTable], fgEventSets)),
+ bgEventSegs: this.joinBgEvents.apply(this, __spreadArray([resourceDayTable], bgEventSets)),
+ eventDrag: this.joinEventDrags.apply(this, __spreadArray([resourceDayTable], eventDrags)),
+ eventResize: this.joinEventResizes.apply(this, __spreadArray([resourceDayTable], eventResizes)),
+ eventSelection: eventSelection,
+ };
+ };
+ VResourceJoiner.prototype.joinSegs = function (resourceDayTable) {
+ var segGroups = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ segGroups[_i - 1] = arguments[_i];
+ }
+ var resourceCnt = resourceDayTable.resources.length;
+ var transformedSegs = [];
+ for (var i = 0; i < resourceCnt; i += 1) {
+ for (var _a = 0, _b = segGroups[i]; _a < _b.length; _a++) {
+ var seg = _b[_a];
+ transformedSegs.push.apply(transformedSegs, this.transformSeg(seg, resourceDayTable, i));
+ }
+ for (var _c = 0, _d = segGroups[resourceCnt]; _c < _d.length; _c++) { // one beyond. the all-resource
+ var seg = _d[_c];
+ transformedSegs.push.apply(// one beyond. the all-resource
+ transformedSegs, this.transformSeg(seg, resourceDayTable, i));
+ }
+ }
+ return transformedSegs;
+ };
+ /*
+ for expanding non-resource segs to all resources.
+ only for public use.
+ no memoizing.
+ */
+ VResourceJoiner.prototype.expandSegs = function (resourceDayTable, segs) {
+ var resourceCnt = resourceDayTable.resources.length;
+ var transformedSegs = [];
+ for (var i = 0; i < resourceCnt; i += 1) {
+ for (var _i = 0, segs_1 = segs; _i < segs_1.length; _i++) {
+ var seg = segs_1[_i];
+ transformedSegs.push.apply(transformedSegs, this.transformSeg(seg, resourceDayTable, i));
+ }
+ }
+ return transformedSegs;
+ };
+ VResourceJoiner.prototype.joinInteractions = function (resourceDayTable) {
+ var interactions = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ interactions[_i - 1] = arguments[_i];
+ }
+ var resourceCnt = resourceDayTable.resources.length;
+ var affectedInstances = {};
+ var transformedSegs = [];
+ var anyInteractions = false;
+ var isEvent = false;
+ for (var i = 0; i < resourceCnt; i += 1) {
+ var interaction = interactions[i];
+ if (interaction) {
+ anyInteractions = true;
+ for (var _a = 0, _b = interaction.segs; _a < _b.length; _a++) {
+ var seg = _b[_a];
+ transformedSegs.push.apply(transformedSegs, this.transformSeg(seg, resourceDayTable, i));
+ }
+ __assign(affectedInstances, interaction.affectedInstances);
+ isEvent = isEvent || interaction.isEvent;
+ }
+ if (interactions[resourceCnt]) { // one beyond. the all-resource
+ for (var _c = 0, _d = interactions[resourceCnt].segs; _c < _d.length; _c++) {
+ var seg = _d[_c];
+ transformedSegs.push.apply(transformedSegs, this.transformSeg(seg, resourceDayTable, i));
+ }
+ }
+ }
+ if (anyInteractions) {
+ return {
+ affectedInstances: affectedInstances,
+ segs: transformedSegs,
+ isEvent: isEvent,
+ };
+ }
+ return null;
+ };
+ return VResourceJoiner;
+ }());
+
+ /*
+ TODO: just use ResourceHash somehow? could then use the generic ResourceSplitter
+ */
+ var VResourceSplitter = /** @class */ (function (_super) {
+ __extends(VResourceSplitter, _super);
+ function VResourceSplitter() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ VResourceSplitter.prototype.getKeyInfo = function (props) {
+ var resourceDayTableModel = props.resourceDayTableModel;
+ var hash = mapHash(resourceDayTableModel.resourceIndex.indicesById, function (i) { return resourceDayTableModel.resources[i]; }); // :(
+ hash[''] = {};
+ return hash;
+ };
+ VResourceSplitter.prototype.getKeysForDateSpan = function (dateSpan) {
+ return [dateSpan.resourceId || ''];
+ };
+ VResourceSplitter.prototype.getKeysForEventDef = function (eventDef) {
+ var resourceIds = eventDef.resourceIds;
+ if (!resourceIds.length) {
+ return [''];
+ }
+ return resourceIds;
+ };
+ return VResourceSplitter;
+ }(Splitter));
+
+ /*
+ doesn't accept grouping
+ */
+ function flattenResources(resourceStore, orderSpecs) {
+ return buildRowNodes(resourceStore, [], orderSpecs, false, {}, true)
+ .map(function (node) { return node.resource; });
+ }
+ function buildRowNodes(resourceStore, groupSpecs, orderSpecs, isVGrouping, expansions, expansionDefault) {
+ var complexNodes = buildHierarchy(resourceStore, isVGrouping ? -1 : 1, groupSpecs, orderSpecs);
+ var flatNodes = [];
+ flattenNodes(complexNodes, flatNodes, isVGrouping, [], 0, expansions, expansionDefault);
+ return flatNodes;
+ }
+ function flattenNodes(complexNodes, res, isVGrouping, rowSpans, depth, expansions, expansionDefault) {
+ for (var i = 0; i < complexNodes.length; i += 1) {
+ var complexNode = complexNodes[i];
+ var group = complexNode.group;
+ if (group) {
+ if (isVGrouping) {
+ var firstRowIndex = res.length;
+ var rowSpanIndex = rowSpans.length;
+ flattenNodes(complexNode.children, res, isVGrouping, rowSpans.concat(0), depth, expansions, expansionDefault);
+ if (firstRowIndex < res.length) {
+ var firstRow = res[firstRowIndex];
+ var firstRowSpans = firstRow.rowSpans = firstRow.rowSpans.slice();
+ firstRowSpans[rowSpanIndex] = res.length - firstRowIndex;
+ }
+ }
+ else {
+ var id = group.spec.field + ':' + group.value;
+ var isExpanded = expansions[id] != null ? expansions[id] : expansionDefault;
+ res.push({ id: id, group: group, isExpanded: isExpanded });
+ if (isExpanded) {
+ flattenNodes(complexNode.children, res, isVGrouping, rowSpans, depth + 1, expansions, expansionDefault);
+ }
+ }
+ }
+ else if (complexNode.resource) {
+ var id = complexNode.resource.id;
+ var isExpanded = expansions[id] != null ? expansions[id] : expansionDefault;
+ res.push({
+ id: id,
+ rowSpans: rowSpans,
+ depth: depth,
+ isExpanded: isExpanded,
+ hasChildren: Boolean(complexNode.children.length),
+ resource: complexNode.resource,
+ resourceFields: complexNode.resourceFields,
+ });
+ if (isExpanded) {
+ flattenNodes(complexNode.children, res, isVGrouping, rowSpans, depth + 1, expansions, expansionDefault);
+ }
+ }
+ }
+ }
+ function buildHierarchy(resourceStore, maxDepth, groupSpecs, orderSpecs) {
+ var resourceNodes = buildResourceNodes(resourceStore, orderSpecs);
+ var builtNodes = [];
+ for (var resourceId in resourceNodes) {
+ var resourceNode = resourceNodes[resourceId];
+ if (!resourceNode.resource.parentId) {
+ insertResourceNode(resourceNode, builtNodes, groupSpecs, 0, maxDepth, orderSpecs);
+ }
+ }
+ return builtNodes;
+ }
+ function buildResourceNodes(resourceStore, orderSpecs) {
+ var nodeHash = {};
+ for (var resourceId in resourceStore) {
+ var resource = resourceStore[resourceId];
+ nodeHash[resourceId] = {
+ resource: resource,
+ resourceFields: buildResourceFields(resource),
+ children: [],
+ };
+ }
+ for (var resourceId in resourceStore) {
+ var resource = resourceStore[resourceId];
+ if (resource.parentId) {
+ var parentNode = nodeHash[resource.parentId];
+ if (parentNode) {
+ insertResourceNodeInSiblings(nodeHash[resourceId], parentNode.children, orderSpecs);
+ }
+ }
+ }
+ return nodeHash;
+ }
+ function insertResourceNode(resourceNode, nodes, groupSpecs, depth, maxDepth, orderSpecs) {
+ if (groupSpecs.length && (maxDepth === -1 || depth <= maxDepth)) {
+ var groupNode = ensureGroupNodes(resourceNode, nodes, groupSpecs[0]);
+ insertResourceNode(resourceNode, groupNode.children, groupSpecs.slice(1), depth + 1, maxDepth, orderSpecs);
+ }
+ else {
+ insertResourceNodeInSiblings(resourceNode, nodes, orderSpecs);
+ }
+ }
+ function ensureGroupNodes(resourceNode, nodes, groupSpec) {
+ var groupValue = resourceNode.resourceFields[groupSpec.field];
+ var groupNode;
+ var newGroupIndex;
+ // find an existing group that matches, or determine the position for a new group
+ if (groupSpec.order) {
+ for (newGroupIndex = 0; newGroupIndex < nodes.length; newGroupIndex += 1) {
+ var node = nodes[newGroupIndex];
+ if (node.group) {
+ var cmp = flexibleCompare(groupValue, node.group.value) * groupSpec.order;
+ if (cmp === 0) {
+ groupNode = node;
+ break;
+ }
+ else if (cmp < 0) {
+ break;
+ }
+ }
+ }
+ }
+ else { // the groups are unordered
+ for (newGroupIndex = 0; newGroupIndex < nodes.length; newGroupIndex += 1) {
+ var node = nodes[newGroupIndex];
+ if (node.group && groupValue === node.group.value) {
+ groupNode = node;
+ break;
+ }
+ }
+ }
+ if (!groupNode) {
+ groupNode = {
+ group: {
+ value: groupValue,
+ spec: groupSpec,
+ },
+ children: [],
+ };
+ nodes.splice(newGroupIndex, 0, groupNode);
+ }
+ return groupNode;
+ }
+ function insertResourceNodeInSiblings(resourceNode, siblings, orderSpecs) {
+ var i;
+ for (i = 0; i < siblings.length; i += 1) {
+ var cmp = compareByFieldSpecs(siblings[i].resourceFields, resourceNode.resourceFields, orderSpecs); // TODO: pass in ResourceApi?
+ if (cmp > 0) { // went 1 past. insert at i
+ break;
+ }
+ }
+ siblings.splice(i, 0, resourceNode);
+ }
+ function buildResourceFields(resource) {
+ var obj = __assign(__assign(__assign({}, resource.extendedProps), resource.ui), resource);
+ delete obj.ui;
+ delete obj.extendedProps;
+ return obj;
+ }
+ function isGroupsEqual(group0, group1) {
+ return group0.spec === group1.spec && group0.value === group1.value;
+ }
+
+ var resourceCommonPlugin = createPlugin({
+ deps: [
+ premiumCommonPlugin,
+ ],
+ reducers: [
+ reduceResources,
+ ],
+ isLoadingFuncs: [
+ function (state) { return state.resourceSource && state.resourceSource.isFetching; },
+ ],
+ eventRefiners: EVENT_REFINERS,
+ eventDefMemberAdders: [generateEventDefResourceMembers],
+ isDraggableTransformers: [transformIsDraggable],
+ eventDragMutationMassagers: [massageEventDragMutation],
+ eventDefMutationAppliers: [applyEventDefMutation],
+ dateSelectionTransformers: [transformDateSelectionJoin],
+ datePointTransforms: [transformDatePoint],
+ dateSpanTransforms: [transformDateSpan],
+ viewPropsTransformers: [ResourceDataAdder, ResourceEventConfigAdder],
+ isPropsValid: isPropsValidWithResources,
+ externalDefTransforms: [transformExternalDef],
+ eventDropTransformers: [transformEventDrop],
+ optionChangeHandlers: optionChangeHandlers,
+ optionRefiners: OPTION_REFINERS,
+ listenerRefiners: LISTENER_REFINERS,
+ propSetHandlers: { resourceStore: handleResourceStore },
+ });
+
+ var ResourceDayTableJoiner = /** @class */ (function (_super) {
+ __extends(ResourceDayTableJoiner, _super);
+ function ResourceDayTableJoiner() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ResourceDayTableJoiner.prototype.transformSeg = function (seg, resourceDayTableModel, resourceI) {
+ var colRanges = resourceDayTableModel.computeColRanges(seg.firstCol, seg.lastCol, resourceI);
+ return colRanges.map(function (colRange) { return (__assign(__assign(__assign({}, seg), colRange), { isStart: seg.isStart && colRange.isStart, isEnd: seg.isEnd && colRange.isEnd })); });
+ };
+ return ResourceDayTableJoiner;
+ }(VResourceJoiner));
+
+ var ResourceDayTable = /** @class */ (function (_super) {
+ __extends(ResourceDayTable, _super);
+ function ResourceDayTable() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.splitter = new VResourceSplitter();
+ _this.slicers = {};
+ _this.joiner = new ResourceDayTableJoiner();
+ _this.tableRef = createRef();
+ _this.isHitComboAllowed = function (hit0, hit1) {
+ var allowAcrossResources = _this.props.resourceDayTableModel.dayTableModel.colCnt === 1;
+ return allowAcrossResources || hit0.dateSpan.resourceId === hit1.dateSpan.resourceId;
+ };
+ return _this;
+ }
+ ResourceDayTable.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var resourceDayTableModel = props.resourceDayTableModel, nextDayThreshold = props.nextDayThreshold, dateProfile = props.dateProfile;
+ var splitProps = this.splitter.splitProps(props);
+ this.slicers = mapHash(splitProps, function (split, resourceId) { return _this.slicers[resourceId] || new DayTableSlicer(); });
+ var slicedProps = mapHash(this.slicers, function (slicer, resourceId) { return slicer.sliceProps(splitProps[resourceId], dateProfile, nextDayThreshold, context, resourceDayTableModel.dayTableModel); });
+ return (createElement(Table, __assign({ forPrint: props.forPrint, ref: this.tableRef }, this.joiner.joinProps(slicedProps, resourceDayTableModel), { cells: resourceDayTableModel.cells, dateProfile: dateProfile, colGroupNode: props.colGroupNode, tableMinWidth: props.tableMinWidth, renderRowIntro: props.renderRowIntro, dayMaxEvents: props.dayMaxEvents, dayMaxEventRows: props.dayMaxEventRows, showWeekNumbers: props.showWeekNumbers, expandRows: props.expandRows, headerAlignElRef: props.headerAlignElRef, clientWidth: props.clientWidth, clientHeight: props.clientHeight, isHitComboAllowed: this.isHitComboAllowed })));
+ };
+ return ResourceDayTable;
+ }(DateComponent));
+
+ var ResourceDayTableView = /** @class */ (function (_super) {
+ __extends(ResourceDayTableView, _super);
+ function ResourceDayTableView() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.flattenResources = memoize(flattenResources);
+ _this.buildResourceDayTableModel = memoize(buildResourceDayTableModel);
+ _this.headerRef = createRef();
+ _this.tableRef = createRef();
+ return _this;
+ }
+ ResourceDayTableView.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var options = context.options;
+ var resourceOrderSpecs = options.resourceOrder || DEFAULT_RESOURCE_ORDER;
+ var resources = this.flattenResources(props.resourceStore, resourceOrderSpecs);
+ var resourceDayTableModel = this.buildResourceDayTableModel(props.dateProfile, context.dateProfileGenerator, resources, options.datesAboveResources, context);
+ var headerContent = options.dayHeaders && (createElement(ResourceDayHeader, { ref: this.headerRef, resources: resources, dateProfile: props.dateProfile, dates: resourceDayTableModel.dayTableModel.headerDates, datesRepDistinctDays: true }));
+ var bodyContent = function (contentArg) { return (createElement(ResourceDayTable, { ref: _this.tableRef, dateProfile: props.dateProfile, resourceDayTableModel: resourceDayTableModel, businessHours: props.businessHours, eventStore: props.eventStore, eventUiBases: props.eventUiBases, dateSelection: props.dateSelection, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, nextDayThreshold: options.nextDayThreshold, tableMinWidth: contentArg.tableMinWidth, colGroupNode: contentArg.tableColGroupNode, dayMaxEvents: options.dayMaxEvents, dayMaxEventRows: options.dayMaxEventRows, showWeekNumbers: options.weekNumbers, expandRows: !props.isHeightAuto, headerAlignElRef: _this.headerElRef, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, forPrint: props.forPrint })); };
+ return options.dayMinWidth
+ ? this.renderHScrollLayout(headerContent, bodyContent, resourceDayTableModel.colCnt, options.dayMinWidth)
+ : this.renderSimpleLayout(headerContent, bodyContent);
+ };
+ return ResourceDayTableView;
+ }(TableView));
+ function buildResourceDayTableModel(dateProfile, dateProfileGenerator, resources, datesAboveResources, context) {
+ var dayTable = buildDayTableModel(dateProfile, dateProfileGenerator);
+ return datesAboveResources ?
+ new DayResourceTableModel(dayTable, resources, context) :
+ new ResourceDayTableModel(dayTable, resources, context);
+ }
+
+ var resourceDayGridPlugin = createPlugin({
+ deps: [
+ premiumCommonPlugin,
+ resourceCommonPlugin,
+ dayGridPlugin,
+ ],
+ initialView: 'resourceDayGridDay',
+ views: {
+ resourceDayGrid: {
+ type: 'dayGrid',
+ component: ResourceDayTableView,
+ needsResourceData: true,
+ },
+ resourceDayGridDay: {
+ type: 'resourceDayGrid',
+ duration: { days: 1 },
+ },
+ resourceDayGridWeek: {
+ type: 'resourceDayGrid',
+ duration: { weeks: 1 },
+ },
+ resourceDayGridMonth: {
+ type: 'resourceDayGrid',
+ duration: { months: 1 },
+ // TODO: wish we didn't have to C&P from dayGrid's file
+ monthMode: true,
+ fixedWeekCount: true,
+ },
+ },
+ });
+
+ var ResourceDayTimeColsJoiner = /** @class */ (function (_super) {
+ __extends(ResourceDayTimeColsJoiner, _super);
+ function ResourceDayTimeColsJoiner() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ResourceDayTimeColsJoiner.prototype.transformSeg = function (seg, resourceDayTable, resourceI) {
+ return [
+ __assign(__assign({}, seg), { col: resourceDayTable.computeCol(seg.col, resourceI) }),
+ ];
+ };
+ return ResourceDayTimeColsJoiner;
+ }(VResourceJoiner));
+
+ var ResourceDayTimeCols = /** @class */ (function (_super) {
+ __extends(ResourceDayTimeCols, _super);
+ function ResourceDayTimeCols() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.buildDayRanges = memoize(buildDayRanges);
+ _this.splitter = new VResourceSplitter();
+ _this.slicers = {};
+ _this.joiner = new ResourceDayTimeColsJoiner();
+ _this.timeColsRef = createRef();
+ _this.isHitComboAllowed = function (hit0, hit1) {
+ var allowAcrossResources = _this.dayRanges.length === 1;
+ return allowAcrossResources || hit0.dateSpan.resourceId === hit1.dateSpan.resourceId;
+ };
+ return _this;
+ }
+ ResourceDayTimeCols.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var dateEnv = context.dateEnv, options = context.options;
+ var dateProfile = props.dateProfile, resourceDayTableModel = props.resourceDayTableModel;
+ var dayRanges = this.dayRanges = this.buildDayRanges(resourceDayTableModel.dayTableModel, dateProfile, dateEnv);
+ var splitProps = this.splitter.splitProps(props);
+ this.slicers = mapHash(splitProps, function (split, resourceId) { return _this.slicers[resourceId] || new DayTimeColsSlicer(); });
+ var slicedProps = mapHash(this.slicers, function (slicer, resourceId) { return slicer.sliceProps(splitProps[resourceId], dateProfile, null, context, dayRanges); });
+ return ( // TODO: would move this further down hierarchy, but sliceNowDate needs it
+ createElement(NowTimer, { unit: options.nowIndicator ? 'minute' : 'day' }, function (nowDate, todayRange) { return (createElement(TimeCols, __assign({ ref: _this.timeColsRef }, _this.joiner.joinProps(slicedProps, resourceDayTableModel), { dateProfile: dateProfile, axis: props.axis, slotDuration: props.slotDuration, slatMetas: props.slatMetas, cells: resourceDayTableModel.cells[0], tableColGroupNode: props.tableColGroupNode, tableMinWidth: props.tableMinWidth, clientWidth: props.clientWidth, clientHeight: props.clientHeight, expandRows: props.expandRows, nowDate: nowDate, nowIndicatorSegs: options.nowIndicator && _this.buildNowIndicatorSegs(nowDate), todayRange: todayRange, onScrollTopRequest: props.onScrollTopRequest, forPrint: props.forPrint, onSlatCoords: props.onSlatCoords, isHitComboAllowed: _this.isHitComboAllowed }))); }));
+ };
+ ResourceDayTimeCols.prototype.buildNowIndicatorSegs = function (date) {
+ var nonResourceSegs = this.slicers[''].sliceNowDate(date, this.context, this.dayRanges);
+ return this.joiner.expandSegs(this.props.resourceDayTableModel, nonResourceSegs);
+ };
+ return ResourceDayTimeCols;
+ }(DateComponent));
+
+ var ResourceDayTimeColsView = /** @class */ (function (_super) {
+ __extends(ResourceDayTimeColsView, _super);
+ function ResourceDayTimeColsView() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.flattenResources = memoize(flattenResources);
+ _this.buildResourceTimeColsModel = memoize(buildResourceTimeColsModel);
+ _this.buildSlatMetas = memoize(buildSlatMetas);
+ return _this;
+ }
+ ResourceDayTimeColsView.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var options = context.options, dateEnv = context.dateEnv;
+ var dateProfile = props.dateProfile;
+ var splitProps = this.allDaySplitter.splitProps(props);
+ var resourceOrderSpecs = options.resourceOrder || DEFAULT_RESOURCE_ORDER;
+ var resources = this.flattenResources(props.resourceStore, resourceOrderSpecs);
+ var resourceDayTableModel = this.buildResourceTimeColsModel(dateProfile, context.dateProfileGenerator, resources, options.datesAboveResources, context);
+ var slatMetas = this.buildSlatMetas(dateProfile.slotMinTime, dateProfile.slotMaxTime, options.slotLabelInterval, options.slotDuration, dateEnv);
+ var dayMinWidth = options.dayMinWidth;
+ var hasAttachedAxis = !dayMinWidth;
+ var hasDetachedAxis = dayMinWidth;
+ var headerContent = options.dayHeaders && (createElement(ResourceDayHeader, { resources: resources, dates: resourceDayTableModel.dayTableModel.headerDates, dateProfile: dateProfile, datesRepDistinctDays: true, renderIntro: hasAttachedAxis ? this.renderHeadAxis : null }));
+ var allDayContent = (options.allDaySlot !== false) && (function (contentArg) { return (createElement(ResourceDayTable, __assign({}, splitProps.allDay, { dateProfile: dateProfile, resourceDayTableModel: resourceDayTableModel, nextDayThreshold: options.nextDayThreshold, tableMinWidth: contentArg.tableMinWidth, colGroupNode: contentArg.tableColGroupNode, renderRowIntro: hasAttachedAxis ? _this.renderTableRowAxis : null, showWeekNumbers: false, expandRows: false, headerAlignElRef: _this.headerElRef, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, forPrint: props.forPrint }, _this.getAllDayMaxEventProps()))); });
+ var timeGridContent = function (contentArg) { return (createElement(ResourceDayTimeCols, __assign({}, splitProps.timed, { dateProfile: dateProfile, axis: hasAttachedAxis, slotDuration: options.slotDuration, slatMetas: slatMetas, resourceDayTableModel: resourceDayTableModel, tableColGroupNode: contentArg.tableColGroupNode, tableMinWidth: contentArg.tableMinWidth, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, onSlatCoords: _this.handleSlatCoords, expandRows: contentArg.expandRows, forPrint: props.forPrint, onScrollTopRequest: _this.handleScrollTopRequest }))); };
+ return hasDetachedAxis
+ ? this.renderHScrollLayout(headerContent, allDayContent, timeGridContent, resourceDayTableModel.colCnt, dayMinWidth, slatMetas, this.state.slatCoords)
+ : this.renderSimpleLayout(headerContent, allDayContent, timeGridContent);
+ };
+ return ResourceDayTimeColsView;
+ }(TimeColsView));
+ function buildResourceTimeColsModel(dateProfile, dateProfileGenerator, resources, datesAboveResources, context) {
+ var dayTable = buildTimeColsModel(dateProfile, dateProfileGenerator);
+ return datesAboveResources ?
+ new DayResourceTableModel(dayTable, resources, context) :
+ new ResourceDayTableModel(dayTable, resources, context);
+ }
+
+ var resourceTimeGridPlugin = createPlugin({
+ deps: [
+ premiumCommonPlugin,
+ resourceCommonPlugin,
+ timeGridPlugin,
+ ],
+ initialView: 'resourceTimeGridDay',
+ views: {
+ resourceTimeGrid: {
+ type: 'timeGrid',
+ component: ResourceDayTimeColsView,
+ needsResourceData: true,
+ },
+ resourceTimeGridDay: {
+ type: 'resourceTimeGrid',
+ duration: { days: 1 },
+ },
+ resourceTimeGridWeek: {
+ type: 'resourceTimeGrid',
+ duration: { weeks: 1 },
+ },
+ },
+ });
+
+ /*
+ Renders the DOM responsible for the subrow expander area,
+ as well as the space before it (used to align expanders of similar depths)
+ */
+ function ExpanderIcon(_a) {
+ var depth = _a.depth, hasChildren = _a.hasChildren, isExpanded = _a.isExpanded, onExpanderClick = _a.onExpanderClick;
+ var nodes = [];
+ for (var i = 0; i < depth; i += 1) {
+ nodes.push(createElement("span", { className: "fc-icon" }));
+ }
+ var iconClassNames = ['fc-icon'];
+ if (hasChildren) {
+ if (isExpanded) {
+ iconClassNames.push('fc-icon-minus-square');
+ }
+ else {
+ iconClassNames.push('fc-icon-plus-square');
+ }
+ }
+ nodes.push(createElement("span", { className: 'fc-datagrid-expander' + (hasChildren ? '' : ' fc-datagrid-expander-placeholder'), onClick: onExpanderClick },
+ createElement("span", { className: iconClassNames.join(' ') })));
+ return createElement.apply(void 0, __spreadArray([Fragment, {}], nodes));
+ }
+
+ function refineHookProps$1(raw) {
+ return {
+ resource: new ResourceApi(raw.context, raw.resource),
+ fieldValue: raw.fieldValue,
+ view: raw.context.viewApi,
+ };
+ }
+
+ var SpreadsheetIndividualCellInner = /** @class */ (function (_super) {
+ __extends(SpreadsheetIndividualCellInner, _super);
+ function SpreadsheetIndividualCellInner() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ SpreadsheetIndividualCellInner.prototype.render = function () {
+ var props = this.props;
+ return (createElement(ContentHook, { hookProps: props.hookProps, content: props.colSpec.cellContent, defaultContent: renderResourceInner }, function (innerElRef, innerContent) { return (createElement("span", { className: "fc-datagrid-cell-main", ref: innerElRef }, innerContent)); }));
+ };
+ return SpreadsheetIndividualCellInner;
+ }(BaseComponent));
+ function renderResourceInner(hookProps) {
+ return hookProps.fieldValue || createElement(Fragment, null, "\u00A0");
+ }
+
+ // worth making a PureComponent? (because of innerHeight)
+ var SpreadsheetIndividualCell = /** @class */ (function (_super) {
+ __extends(SpreadsheetIndividualCell, _super);
+ function SpreadsheetIndividualCell() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.refineHookProps = memoizeObjArg(refineHookProps$1);
+ _this.normalizeClassNames = buildClassNameNormalizer();
+ _this.onExpanderClick = function (ev) {
+ var props = _this.props;
+ if (props.hasChildren) {
+ _this.context.dispatch({
+ type: 'SET_RESOURCE_ENTITY_EXPANDED',
+ id: props.resource.id,
+ isExpanded: !props.isExpanded,
+ });
+ }
+ };
+ return _this;
+ }
+ SpreadsheetIndividualCell.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var colSpec = props.colSpec;
+ var hookProps = this.refineHookProps({
+ resource: props.resource,
+ fieldValue: props.fieldValue,
+ context: context,
+ });
+ var customClassNames = this.normalizeClassNames(colSpec.cellClassNames, hookProps);
+ return (createElement(MountHook, { hookProps: hookProps, didMount: colSpec.cellDidMount, willUnmount: colSpec.cellWillUnmount }, function (rootElRef) { return (createElement("td", { ref: rootElRef, role: "gridcell", "data-resource-id": props.resource.id, className: [
+ 'fc-datagrid-cell',
+ 'fc-resource',
+ ].concat(customClassNames).join(' ') },
+ createElement("div", { className: "fc-datagrid-cell-frame", style: { height: props.innerHeight } },
+ createElement("div", { className: "fc-datagrid-cell-cushion fc-scrollgrid-sync-inner" },
+ colSpec.isMain && (createElement(ExpanderIcon, { depth: props.depth, hasChildren: props.hasChildren, isExpanded: props.isExpanded, onExpanderClick: _this.onExpanderClick })),
+ createElement(SpreadsheetIndividualCellInner, { hookProps: hookProps, colSpec: colSpec }))))); }));
+ };
+ return SpreadsheetIndividualCell;
+ }(BaseComponent));
+
+ // for VERTICAL cell grouping, in spreadsheet area
+ var SpreadsheetGroupCell = /** @class */ (function (_super) {
+ __extends(SpreadsheetGroupCell, _super);
+ function SpreadsheetGroupCell() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ SpreadsheetGroupCell.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var colSpec = props.colSpec;
+ var hookProps = {
+ groupValue: props.fieldValue,
+ view: context.viewApi,
+ };
+ // a grouped cell. no data that is specific to this specific resource
+ // `colSpec` is for the group. a GroupSpec :(
+ return (createElement(RenderHook, { hookProps: hookProps, classNames: colSpec.cellClassNames, content: colSpec.cellContent, defaultContent: renderGroupInner, didMount: colSpec.cellDidMount, willUnmount: colSpec.cellWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (
+ // TODO: make data-attr with group value?
+ createElement("td", { ref: rootElRef, role: "gridcell", rowSpan: props.rowSpan, className: ['fc-datagrid-cell', 'fc-resource-group'].concat(classNames).join(' ') },
+ createElement("div", { className: "fc-datagrid-cell-frame fc-datagrid-cell-frame-liquid" },
+ createElement("div", { className: "fc-datagrid-cell-cushion fc-sticky", ref: innerElRef }, innerContent)))); }));
+ };
+ return SpreadsheetGroupCell;
+ }(BaseComponent));
+ function renderGroupInner(hookProps) {
+ return hookProps.groupValue || createElement(Fragment, null, "\u00A0");
+ }
+
+ var SpreadsheetRow = /** @class */ (function (_super) {
+ __extends(SpreadsheetRow, _super);
+ function SpreadsheetRow() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ SpreadsheetRow.prototype.render = function () {
+ var props = this.props;
+ var resource = props.resource, rowSpans = props.rowSpans, depth = props.depth;
+ var resourceFields = buildResourceFields(resource); // slightly inefficient. already done up the call stack
+ return (createElement("tr", { role: "row" }, props.colSpecs.map(function (colSpec, i) {
+ var rowSpan = rowSpans[i];
+ if (rowSpan === 0) { // not responsible for group-based rows. VRowGroup is
+ return null;
+ }
+ if (rowSpan == null) {
+ rowSpan = 1;
+ }
+ var fieldValue = colSpec.field ? resourceFields[colSpec.field] :
+ (resource.title || getPublicId(resource.id));
+ if (rowSpan > 1) {
+ return (createElement(SpreadsheetGroupCell, { key: i, colSpec: colSpec, fieldValue: fieldValue, rowSpan: rowSpan }));
+ }
+ return (createElement(SpreadsheetIndividualCell, { key: i, colSpec: colSpec, resource: resource, fieldValue: fieldValue, depth: depth, hasChildren: props.hasChildren, isExpanded: props.isExpanded, innerHeight: props.innerHeight }));
+ })));
+ };
+ return SpreadsheetRow;
+ }(BaseComponent));
+ SpreadsheetRow.addPropsEquality({
+ rowSpans: isArraysEqual,
+ });
+
+ // for HORIZONTAL cell grouping, in spreadsheet area
+ var SpreadsheetGroupRow = /** @class */ (function (_super) {
+ __extends(SpreadsheetGroupRow, _super);
+ function SpreadsheetGroupRow() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.innerInnerRef = createRef();
+ _this.onExpanderClick = function () {
+ var props = _this.props;
+ _this.context.dispatch({
+ type: 'SET_RESOURCE_ENTITY_EXPANDED',
+ id: props.id,
+ isExpanded: !props.isExpanded,
+ });
+ };
+ return _this;
+ }
+ SpreadsheetGroupRow.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var hookProps = { groupValue: props.group.value, view: context.viewApi };
+ var spec = props.group.spec;
+ return (createElement("tr", { role: "row" },
+ createElement(RenderHook, { hookProps: hookProps, classNames: spec.labelClassNames, content: spec.labelContent, defaultContent: renderCellInner, didMount: spec.labelDidMount, willUnmount: spec.labelWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("th", { ref: rootElRef,
+ // ARIA TODO: not really a columnheader
+ // extremely tedious to make this aria-compliant,
+ // to assign multiple headers to each cell
+ // https://www.w3.org/WAI/tutorials/tables/multi-level/
+ role: "columnheader", scope: "colgroup", colSpan: props.spreadsheetColCnt, className: [
+ 'fc-datagrid-cell',
+ 'fc-resource-group',
+ context.theme.getClass('tableCellShaded'),
+ ].concat(classNames).join(' ') },
+ createElement("div", { className: "fc-datagrid-cell-frame", style: { height: props.innerHeight } },
+ createElement("div", { className: "fc-datagrid-cell-cushion fc-scrollgrid-sync-inner", ref: _this.innerInnerRef },
+ createElement(ExpanderIcon, { depth: 0, hasChildren: true, isExpanded: props.isExpanded, onExpanderClick: _this.onExpanderClick }),
+ createElement("span", { className: "fc-datagrid-cell-main", ref: innerElRef }, innerContent))))); })));
+ };
+ return SpreadsheetGroupRow;
+ }(BaseComponent));
+ SpreadsheetGroupRow.addPropsEquality({
+ group: isGroupsEqual,
+ });
+ function renderCellInner(hookProps) {
+ return hookProps.groupValue || createElement(Fragment, null, "\u00A0");
+ }
+
+ var SPREADSHEET_COL_MIN_WIDTH = 20;
+ var SpreadsheetHeader = /** @class */ (function (_super) {
+ __extends(SpreadsheetHeader, _super);
+ function SpreadsheetHeader() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.resizerElRefs = new RefMap(_this._handleColResizerEl.bind(_this));
+ _this.colDraggings = {};
+ return _this;
+ }
+ SpreadsheetHeader.prototype.render = function () {
+ var _this = this;
+ var _a = this.props, colSpecs = _a.colSpecs, superHeaderRendering = _a.superHeaderRendering, rowInnerHeights = _a.rowInnerHeights;
+ var hookProps = { view: this.context.viewApi };
+ var rowNodes = [];
+ rowInnerHeights = rowInnerHeights.slice(); // copy, because we're gonna pop
+ if (superHeaderRendering) {
+ var rowInnerHeight_1 = rowInnerHeights.shift();
+ rowNodes.push(createElement("tr", { key: "row-super", role: "row" },
+ createElement(RenderHook, { hookProps: hookProps, classNames: superHeaderRendering.headerClassNames, content: superHeaderRendering.headerContent, didMount: superHeaderRendering.headerDidMount, willUnmount: superHeaderRendering.headerWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("th", { ref: rootElRef, role: "columnheader", scope: "colgroup", colSpan: colSpecs.length, className: [
+ 'fc-datagrid-cell',
+ 'fc-datagrid-cell-super',
+ ].concat(classNames).join(' ') },
+ createElement("div", { className: "fc-datagrid-cell-frame", style: { height: rowInnerHeight_1 } },
+ createElement("div", { className: "fc-datagrid-cell-cushion fc-scrollgrid-sync-inner", ref: innerElRef }, innerContent)))); })));
+ }
+ var rowInnerHeight = rowInnerHeights.shift();
+ rowNodes.push(createElement("tr", { key: "row", role: "row" }, colSpecs.map(function (colSpec, i) {
+ var isLastCol = i === (colSpecs.length - 1);
+ // need empty inner div for abs positioning for resizer
+ return (createElement(RenderHook, { key: i, hookProps: hookProps, classNames: colSpec.headerClassNames, content: colSpec.headerContent, didMount: colSpec.headerDidMount, willUnmount: colSpec.headerWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("th", { ref: rootElRef, role: "columnheader", className: ['fc-datagrid-cell'].concat(classNames).join(' ') },
+ createElement("div", { className: "fc-datagrid-cell-frame", style: { height: rowInnerHeight } },
+ createElement("div", { className: "fc-datagrid-cell-cushion fc-scrollgrid-sync-inner" },
+ colSpec.isMain && (createElement("span", { className: "fc-datagrid-expander fc-datagrid-expander-placeholder" },
+ createElement("span", { className: "fc-icon" }))),
+ createElement("span", { className: "fc-datagrid-cell-main", ref: innerElRef }, innerContent)),
+ !isLastCol &&
+ createElement("div", { className: "fc-datagrid-cell-resizer", ref: _this.resizerElRefs.createRef(i) })))); }));
+ })));
+ return (createElement(Fragment, null, rowNodes));
+ };
+ SpreadsheetHeader.prototype._handleColResizerEl = function (resizerEl, index) {
+ var colDraggings = this.colDraggings;
+ if (!resizerEl) {
+ var dragging = colDraggings[index];
+ if (dragging) {
+ dragging.destroy();
+ delete colDraggings[index];
+ }
+ }
+ else {
+ var dragging = this.initColResizing(resizerEl, parseInt(index, 10));
+ if (dragging) {
+ colDraggings[index] = dragging;
+ }
+ }
+ };
+ SpreadsheetHeader.prototype.initColResizing = function (resizerEl, index) {
+ var _a = this.context, pluginHooks = _a.pluginHooks, isRtl = _a.isRtl;
+ var onColWidthChange = this.props.onColWidthChange;
+ var ElementDraggingImpl = pluginHooks.elementDraggingImpl;
+ if (ElementDraggingImpl) {
+ var dragging = new ElementDraggingImpl(resizerEl);
+ var startWidth_1; // of just the single column
+ var currentWidths_1; // of all columns
+ dragging.emitter.on('dragstart', function () {
+ var allCells = findElements(elementClosest(resizerEl, 'tr'), 'th');
+ currentWidths_1 = allCells.map(function (cellEl) { return (cellEl.getBoundingClientRect().width); });
+ startWidth_1 = currentWidths_1[index];
+ });
+ dragging.emitter.on('dragmove', function (pev) {
+ currentWidths_1[index] = Math.max(startWidth_1 + pev.deltaX * (isRtl ? -1 : 1), SPREADSHEET_COL_MIN_WIDTH);
+ if (onColWidthChange) {
+ onColWidthChange(currentWidths_1.slice()); // send a copy since currentWidths continues to be mutated
+ }
+ });
+ dragging.setAutoScrollEnabled(false); // because gets weird with auto-scrolling time area
+ return dragging;
+ }
+ return null;
+ };
+ return SpreadsheetHeader;
+ }(BaseComponent));
+
+ var ResourceTimelineLaneMisc = /** @class */ (function (_super) {
+ __extends(ResourceTimelineLaneMisc, _super);
+ function ResourceTimelineLaneMisc() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ResourceTimelineLaneMisc.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var hookProps = { resource: new ResourceApi(context, props.resource) }; // just easier to make directly
+ return (createElement(ContentHook, { hookProps: hookProps, content: context.options.resourceLaneContent }, function (innerElRef, innerContent) { return (innerContent && // TODO: test how this would interfere with height
+ createElement("div", { className: "fc-timeline-lane-misc", ref: innerElRef }, innerContent)); }));
+ };
+ return ResourceTimelineLaneMisc;
+ }(BaseComponent));
+
+ var ResourceTimelineLane = /** @class */ (function (_super) {
+ __extends(ResourceTimelineLane, _super);
+ function ResourceTimelineLane() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.refineHookProps = memoizeObjArg(refineHookProps);
+ _this.normalizeClassNames = buildClassNameNormalizer();
+ _this.handleHeightChange = function (innerEl, isStable) {
+ if (_this.props.onHeightChange) {
+ _this.props.onHeightChange(
+ // would want to use own ref, but not guaranteed to be ready when this fires
+ elementClosest(innerEl, 'tr'), isStable);
+ }
+ };
+ return _this;
+ }
+ ResourceTimelineLane.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, context = _a.context;
+ var options = context.options;
+ var hookProps = this.refineHookProps({ resource: props.resource, context: context });
+ var customClassNames = this.normalizeClassNames(options.resourceLaneClassNames, hookProps);
+ return (createElement("tr", { ref: props.elRef },
+ createElement(MountHook, { hookProps: hookProps, didMount: options.resourceLaneDidMount, willUnmount: options.resourceLaneWillUnmount }, function (rootElRef) { return (createElement("td", { ref: rootElRef, className: ['fc-timeline-lane', 'fc-resource'].concat(customClassNames).join(' '), "data-resource-id": props.resource.id },
+ createElement("div", { className: "fc-timeline-lane-frame", style: { height: props.innerHeight } },
+ createElement(ResourceTimelineLaneMisc, { resource: props.resource }),
+ createElement(TimelineLane, { dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange, nextDayThreshold: props.nextDayThreshold, businessHours: props.businessHours, eventStore: props.eventStore, eventUiBases: props.eventUiBases, dateSelection: props.dateSelection, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, timelineCoords: props.timelineCoords, onHeightChange: _this.handleHeightChange, resourceId: props.resource.id })))); }))); // important NOT to do liquid-height. dont want to shrink height smaller than content
+ };
+ return ResourceTimelineLane;
+ }(BaseComponent));
+ function refineHookProps(raw) {
+ return {
+ resource: new ResourceApi(raw.context, raw.resource),
+ };
+ }
+
+ /*
+ parallels the SpreadsheetGroupRow
+ */
+ var DividerRow = /** @class */ (function (_super) {
+ __extends(DividerRow, _super);
+ function DividerRow() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ DividerRow.prototype.render = function () {
+ var _this = this;
+ var props = this.props;
+ var renderingHooks = this.props.renderingHooks;
+ var hookProps = { groupValue: props.groupValue, view: this.context.viewApi };
+ return (createElement("tr", { ref: props.elRef },
+ createElement(RenderHook, { hookProps: hookProps, classNames: renderingHooks.laneClassNames, content: renderingHooks.laneContent, didMount: renderingHooks.laneDidMount, willUnmount: renderingHooks.laneWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("td", { ref: rootElRef, className: [
+ 'fc-timeline-lane',
+ 'fc-resource-group',
+ _this.context.theme.getClass('tableCellShaded'),
+ ].concat(classNames).join(' ') },
+ createElement("div", { style: { height: props.innerHeight }, ref: innerElRef }, innerContent))); })));
+ };
+ return DividerRow;
+ }(BaseComponent));
+
+ var ResourceTimelineLanesBody = /** @class */ (function (_super) {
+ __extends(ResourceTimelineLanesBody, _super);
+ function ResourceTimelineLanesBody() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ResourceTimelineLanesBody.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ var rowElRefs = props.rowElRefs, innerHeights = props.innerHeights;
+ return (createElement("tbody", null, props.rowNodes.map(function (node, index) {
+ if (node.group) {
+ return (createElement(DividerRow, { key: node.id, elRef: rowElRefs.createRef(node.id), groupValue: node.group.value, renderingHooks: node.group.spec, innerHeight: innerHeights[index] || '' }));
+ }
+ if (node.resource) {
+ var resource = node.resource;
+ return (createElement(ResourceTimelineLane, __assign({ key: node.id, elRef: rowElRefs.createRef(node.id) }, props.splitProps[resource.id], { resource: resource, dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange, nextDayThreshold: context.options.nextDayThreshold, businessHours: resource.businessHours || props.fallbackBusinessHours, innerHeight: innerHeights[index] || '', timelineCoords: props.slatCoords, onHeightChange: props.onRowHeightChange })));
+ }
+ return null;
+ })));
+ };
+ return ResourceTimelineLanesBody;
+ }(BaseComponent));
+
+ var ResourceTimelineLanes = /** @class */ (function (_super) {
+ __extends(ResourceTimelineLanes, _super);
+ function ResourceTimelineLanes() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.rootElRef = createRef();
+ _this.rowElRefs = new RefMap();
+ return _this;
+ }
+ ResourceTimelineLanes.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ return (createElement("table", { ref: this.rootElRef, "aria-hidden": true, className: 'fc-scrollgrid-sync-table ' + context.theme.getClass('table'), style: {
+ minWidth: props.tableMinWidth,
+ width: props.clientWidth,
+ height: props.minHeight,
+ } },
+ createElement(ResourceTimelineLanesBody, { rowElRefs: this.rowElRefs, rowNodes: props.rowNodes, dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange, splitProps: props.splitProps, fallbackBusinessHours: props.fallbackBusinessHours, slatCoords: props.slatCoords, innerHeights: props.innerHeights, onRowHeightChange: props.onRowHeightChange })));
+ };
+ ResourceTimelineLanes.prototype.componentDidMount = function () {
+ this.updateCoords();
+ };
+ ResourceTimelineLanes.prototype.componentDidUpdate = function () {
+ this.updateCoords();
+ };
+ ResourceTimelineLanes.prototype.componentWillUnmount = function () {
+ if (this.props.onRowCoords) {
+ this.props.onRowCoords(null);
+ }
+ };
+ ResourceTimelineLanes.prototype.updateCoords = function () {
+ var props = this.props;
+ if (props.onRowCoords && props.clientWidth !== null) { // a populated clientWidth means sizing has stabilized
+ this.props.onRowCoords(new PositionCache(this.rootElRef.current, collectRowEls(this.rowElRefs.currentMap, props.rowNodes), false, true));
+ }
+ };
+ return ResourceTimelineLanes;
+ }(BaseComponent));
+ function collectRowEls(elMap, rowNodes) {
+ return rowNodes.map(function (rowNode) { return elMap[rowNode.id]; });
+ }
+
+ var ResourceTimelineGrid = /** @class */ (function (_super) {
+ __extends(ResourceTimelineGrid, _super);
+ function ResourceTimelineGrid() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.computeHasResourceBusinessHours = memoize(computeHasResourceBusinessHours);
+ _this.resourceSplitter = new ResourceSplitter(); // doesn't let it do businessHours tho
+ _this.bgSlicer = new TimelineLaneSlicer();
+ _this.slatsRef = createRef(); // needed for Hit creation :(
+ _this.state = {
+ slatCoords: null,
+ };
+ _this.handleEl = function (el) {
+ if (el) {
+ _this.context.registerInteractiveComponent(_this, { el: el });
+ }
+ else {
+ _this.context.unregisterInteractiveComponent(_this);
+ }
+ };
+ _this.handleSlatCoords = function (slatCoords) {
+ _this.setState({ slatCoords: slatCoords });
+ if (_this.props.onSlatCoords) {
+ _this.props.onSlatCoords(slatCoords);
+ }
+ };
+ _this.handleRowCoords = function (rowCoords) {
+ _this.rowCoords = rowCoords;
+ if (_this.props.onRowCoords) {
+ _this.props.onRowCoords(rowCoords);
+ }
+ };
+ return _this;
+ }
+ ResourceTimelineGrid.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ var dateProfile = props.dateProfile, tDateProfile = props.tDateProfile;
+ var timerUnit = greatestDurationDenominator(tDateProfile.slotDuration).unit;
+ var hasResourceBusinessHours = this.computeHasResourceBusinessHours(props.rowNodes);
+ var splitProps = this.resourceSplitter.splitProps(props);
+ var bgLaneProps = splitProps[''];
+ var bgSlicedProps = this.bgSlicer.sliceProps(bgLaneProps, dateProfile, tDateProfile.isTimeScale ? null : props.nextDayThreshold, context, // wish we didn't need to pass in the rest of these args...
+ dateProfile, context.dateProfileGenerator, tDateProfile, context.dateEnv);
+ // WORKAROUND: make ignore slatCoords when out of sync with dateProfile
+ var slatCoords = state.slatCoords && state.slatCoords.dateProfile === props.dateProfile ? state.slatCoords : null;
+ return (createElement("div", { ref: this.handleEl, className: [
+ 'fc-timeline-body',
+ props.expandRows ? 'fc-timeline-body-expandrows' : '',
+ ].join(' '), style: { minWidth: props.tableMinWidth } },
+ createElement(NowTimer, { unit: timerUnit }, function (nowDate, todayRange) { return (createElement(Fragment, null,
+ createElement(TimelineSlats, { ref: _this.slatsRef, dateProfile: dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, clientWidth: props.clientWidth, tableColGroupNode: props.tableColGroupNode, tableMinWidth: props.tableMinWidth, onCoords: _this.handleSlatCoords, onScrollLeftRequest: props.onScrollLeftRequest }),
+ createElement(TimelineLaneBg, { businessHourSegs: hasResourceBusinessHours ? null : bgSlicedProps.businessHourSegs, bgEventSegs: bgSlicedProps.bgEventSegs, timelineCoords: slatCoords,
+ // empty array will result in unnecessary rerenders?
+ eventResizeSegs: (bgSlicedProps.eventResize ? bgSlicedProps.eventResize.segs : []), dateSelectionSegs: bgSlicedProps.dateSelectionSegs, nowDate: nowDate, todayRange: todayRange }),
+ createElement(ResourceTimelineLanes, { rowNodes: props.rowNodes, dateProfile: dateProfile, tDateProfile: props.tDateProfile, nowDate: nowDate, todayRange: todayRange, splitProps: splitProps, fallbackBusinessHours: hasResourceBusinessHours ? props.businessHours : null, clientWidth: props.clientWidth, minHeight: props.expandRows ? props.clientHeight : '', tableMinWidth: props.tableMinWidth, innerHeights: props.rowInnerHeights, slatCoords: slatCoords, onRowCoords: _this.handleRowCoords, onRowHeightChange: props.onRowHeightChange }),
+ (context.options.nowIndicator && slatCoords && slatCoords.isDateInRange(nowDate)) && (createElement("div", { className: "fc-timeline-now-indicator-container" },
+ createElement(NowIndicatorRoot, { isAxis: false, date: nowDate }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("div", { ref: rootElRef, className: ['fc-timeline-now-indicator-line'].concat(classNames).join(' '), style: coordToCss(slatCoords.dateToCoord(nowDate), context.isRtl) }, innerContent)); }))))); })));
+ };
+ // Hit System
+ // ------------------------------------------------------------------------------------------
+ ResourceTimelineGrid.prototype.queryHit = function (positionLeft, positionTop) {
+ var rowCoords = this.rowCoords;
+ var rowIndex = rowCoords.topToIndex(positionTop);
+ if (rowIndex != null) {
+ var resource = this.props.rowNodes[rowIndex].resource;
+ if (resource) { // not a group
+ var slatHit = this.slatsRef.current.positionToHit(positionLeft);
+ if (slatHit) {
+ return {
+ dateProfile: this.props.dateProfile,
+ dateSpan: {
+ range: slatHit.dateSpan.range,
+ allDay: slatHit.dateSpan.allDay,
+ resourceId: resource.id,
+ },
+ rect: {
+ left: slatHit.left,
+ right: slatHit.right,
+ top: rowCoords.tops[rowIndex],
+ bottom: rowCoords.bottoms[rowIndex],
+ },
+ dayEl: slatHit.dayEl,
+ layer: 0,
+ };
+ }
+ }
+ }
+ return null;
+ };
+ return ResourceTimelineGrid;
+ }(DateComponent));
+ function computeHasResourceBusinessHours(rowNodes) {
+ for (var _i = 0, rowNodes_1 = rowNodes; _i < rowNodes_1.length; _i++) {
+ var node = rowNodes_1[_i];
+ var resource = node.resource;
+ if (resource && resource.businessHours) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ var MIN_RESOURCE_AREA_WIDTH = 30; // definitely bigger than scrollbars
+ // RENAME?
+ var ResourceTimelineViewLayout = /** @class */ (function (_super) {
+ __extends(ResourceTimelineViewLayout, _super);
+ function ResourceTimelineViewLayout() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.scrollGridRef = createRef();
+ _this.timeBodyScrollerElRef = createRef();
+ _this.spreadsheetHeaderChunkElRef = createRef();
+ _this.rootElRef = createRef();
+ _this.ensureScrollGridResizeId = 0;
+ _this.state = {
+ resourceAreaWidthOverride: null,
+ };
+ /*
+ ghetto debounce. don't race with ScrollGrid's resizing delay. solves #6140
+ */
+ _this.ensureScrollGridResize = function () {
+ if (_this.ensureScrollGridResizeId) {
+ clearTimeout(_this.ensureScrollGridResizeId);
+ }
+ _this.ensureScrollGridResizeId = setTimeout(function () {
+ _this.scrollGridRef.current.handleSizing(false);
+ }, config.SCROLLGRID_RESIZE_INTERVAL + 1);
+ };
+ return _this;
+ }
+ ResourceTimelineViewLayout.prototype.render = function () {
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ var options = context.options;
+ var stickyHeaderDates = !props.forPrint && getStickyHeaderDates(options);
+ var stickyFooterScrollbar = !props.forPrint && getStickyFooterScrollbar(options);
+ var sections = [
+ {
+ type: 'header',
+ key: 'header',
+ syncRowHeights: true,
+ isSticky: stickyHeaderDates,
+ chunks: [
+ {
+ key: 'datagrid',
+ elRef: this.spreadsheetHeaderChunkElRef,
+ // TODO: allow the content to specify this. have general-purpose 'content' with obj with keys
+ tableClassName: 'fc-datagrid-header',
+ rowContent: props.spreadsheetHeaderRows,
+ },
+ {
+ key: 'divider',
+ outerContent: (createElement("td", { role: "presentation", className: 'fc-resource-timeline-divider ' + context.theme.getClass('tableCellShaded') })),
+ },
+ {
+ key: 'timeline',
+ content: props.timeHeaderContent,
+ },
+ ],
+ },
+ {
+ type: 'body',
+ key: 'body',
+ syncRowHeights: true,
+ liquid: true,
+ expandRows: Boolean(options.expandRows),
+ chunks: [
+ {
+ key: 'datagrid',
+ tableClassName: 'fc-datagrid-body',
+ rowContent: props.spreadsheetBodyRows,
+ },
+ {
+ key: 'divider',
+ outerContent: (createElement("td", { role: "presentation", className: 'fc-resource-timeline-divider ' + context.theme.getClass('tableCellShaded') })),
+ },
+ {
+ key: 'timeline',
+ scrollerElRef: this.timeBodyScrollerElRef,
+ content: props.timeBodyContent,
+ },
+ ],
+ },
+ ];
+ if (stickyFooterScrollbar) {
+ sections.push({
+ type: 'footer',
+ key: 'footer',
+ isSticky: true,
+ chunks: [
+ {
+ key: 'datagrid',
+ content: renderScrollShim,
+ },
+ {
+ key: 'divider',
+ outerContent: (createElement("td", { role: "presentation", className: 'fc-resource-timeline-divider ' + context.theme.getClass('tableCellShaded') })),
+ },
+ {
+ key: 'timeline',
+ content: renderScrollShim,
+ },
+ ],
+ });
+ }
+ var resourceAreaWidth = state.resourceAreaWidthOverride != null
+ ? state.resourceAreaWidthOverride
+ : options.resourceAreaWidth;
+ return (createElement(ScrollGrid, { ref: this.scrollGridRef, elRef: this.rootElRef, liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: false, colGroups: [
+ { cols: props.spreadsheetCols, width: resourceAreaWidth },
+ { cols: [] },
+ { cols: props.timeCols },
+ ], sections: sections }));
+ };
+ ResourceTimelineViewLayout.prototype.forceTimeScroll = function (left) {
+ var scrollGrid = this.scrollGridRef.current;
+ scrollGrid.forceScrollLeft(2, left); // 2 = the time area
+ };
+ ResourceTimelineViewLayout.prototype.forceResourceScroll = function (top) {
+ var scrollGrid = this.scrollGridRef.current;
+ scrollGrid.forceScrollTop(1, top); // 1 = the body
+ };
+ ResourceTimelineViewLayout.prototype.getResourceScroll = function () {
+ var timeBodyScrollerEl = this.timeBodyScrollerElRef.current;
+ return timeBodyScrollerEl.scrollTop;
+ };
+ // Resource Area Resizing
+ // ------------------------------------------------------------------------------------------
+ // NOTE: a callback Ref for the resizer was firing multiple times with same elements (Preact)
+ // that's why we use spreadsheetResizerElRef instead
+ ResourceTimelineViewLayout.prototype.componentDidMount = function () {
+ this.initSpreadsheetResizing();
+ };
+ ResourceTimelineViewLayout.prototype.componentWillUnmount = function () {
+ this.destroySpreadsheetResizing();
+ };
+ ResourceTimelineViewLayout.prototype.initSpreadsheetResizing = function () {
+ var _this = this;
+ var _a = this.context, isRtl = _a.isRtl, pluginHooks = _a.pluginHooks;
+ var ElementDraggingImpl = pluginHooks.elementDraggingImpl;
+ var spreadsheetHeadEl = this.spreadsheetHeaderChunkElRef.current;
+ if (ElementDraggingImpl) {
+ var rootEl_1 = this.rootElRef.current;
+ var dragging = this.spreadsheetResizerDragging = new ElementDraggingImpl(rootEl_1, '.fc-resource-timeline-divider');
+ var dragStartWidth_1;
+ var viewWidth_1;
+ dragging.emitter.on('dragstart', function () {
+ dragStartWidth_1 = spreadsheetHeadEl.getBoundingClientRect().width;
+ viewWidth_1 = rootEl_1.getBoundingClientRect().width;
+ });
+ dragging.emitter.on('dragmove', function (pev) {
+ var newWidth = dragStartWidth_1 + pev.deltaX * (isRtl ? -1 : 1);
+ newWidth = Math.max(newWidth, MIN_RESOURCE_AREA_WIDTH);
+ newWidth = Math.min(newWidth, viewWidth_1 - MIN_RESOURCE_AREA_WIDTH);
+ // scrollgrid will ignore resize requests if there are too many :|
+ _this.setState({
+ resourceAreaWidthOverride: newWidth,
+ }, _this.ensureScrollGridResize);
+ });
+ dragging.setAutoScrollEnabled(false); // because gets weird with auto-scrolling time area
+ }
+ };
+ ResourceTimelineViewLayout.prototype.destroySpreadsheetResizing = function () {
+ if (this.spreadsheetResizerDragging) {
+ this.spreadsheetResizerDragging.destroy();
+ }
+ };
+ return ResourceTimelineViewLayout;
+ }(BaseComponent));
+
+ var ResourceTimelineView = /** @class */ (function (_super) {
+ __extends(ResourceTimelineView, _super);
+ function ResourceTimelineView(props, context) {
+ var _this = _super.call(this, props, context) || this;
+ _this.processColOptions = memoize(processColOptions);
+ _this.buildTimelineDateProfile = memoize(buildTimelineDateProfile);
+ _this.hasNesting = memoize(hasNesting);
+ _this.buildRowNodes = memoize(buildRowNodes);
+ _this.layoutRef = createRef();
+ _this.rowNodes = [];
+ _this.renderedRowNodes = [];
+ _this.buildRowIndex = memoize(buildRowIndex);
+ _this.handleSlatCoords = function (slatCoords) {
+ _this.setState({ slatCoords: slatCoords });
+ };
+ _this.handleRowCoords = function (rowCoords) {
+ _this.rowCoords = rowCoords;
+ _this.scrollResponder.update(false); // TODO: could eliminate this if rowCoords lived in state
+ };
+ _this.handleMaxCushionWidth = function (slotCushionMaxWidth) {
+ _this.setState({
+ slotCushionMaxWidth: Math.ceil(slotCushionMaxWidth), // for less rerendering TODO: DRY
+ });
+ };
+ // Scrolling
+ // ------------------------------------------------------------------------------------------------------------------
+ // this is useful for scrolling prev/next dates while resource is scrolled down
+ _this.handleScrollLeftRequest = function (scrollLeft) {
+ var layout = _this.layoutRef.current;
+ layout.forceTimeScroll(scrollLeft);
+ };
+ _this.handleScrollRequest = function (request) {
+ var rowCoords = _this.rowCoords;
+ var layout = _this.layoutRef.current;
+ var rowId = request.rowId || request.resourceId;
+ if (rowCoords) {
+ if (rowId) {
+ var rowIdToIndex = _this.buildRowIndex(_this.renderedRowNodes);
+ var index = rowIdToIndex[rowId];
+ if (index != null) {
+ var scrollTop = (request.fromBottom != null ?
+ rowCoords.bottoms[index] - request.fromBottom : // pixels from bottom edge
+ rowCoords.tops[index] // just use top edge
+ );
+ layout.forceResourceScroll(scrollTop);
+ }
+ }
+ return true;
+ }
+ return null;
+ };
+ // Resource INDIVIDUAL-Column Area Resizing
+ // ------------------------------------------------------------------------------------------
+ _this.handleColWidthChange = function (colWidths) {
+ _this.setState({
+ spreadsheetColWidths: colWidths,
+ });
+ };
+ _this.state = {
+ resourceAreaWidth: context.options.resourceAreaWidth,
+ spreadsheetColWidths: [],
+ };
+ return _this;
+ }
+ ResourceTimelineView.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ var options = context.options, viewSpec = context.viewSpec;
+ var _b = this.processColOptions(context.options), superHeaderRendering = _b.superHeaderRendering, groupSpecs = _b.groupSpecs, orderSpecs = _b.orderSpecs, isVGrouping = _b.isVGrouping, colSpecs = _b.colSpecs;
+ var tDateProfile = this.buildTimelineDateProfile(props.dateProfile, context.dateEnv, options, context.dateProfileGenerator);
+ var rowNodes = this.rowNodes = this.buildRowNodes(props.resourceStore, groupSpecs, orderSpecs, isVGrouping, props.resourceEntityExpansions, options.resourcesInitiallyExpanded);
+ var extraClassNames = [
+ 'fc-resource-timeline',
+ this.hasNesting(rowNodes) ? '' : 'fc-resource-timeline-flat',
+ 'fc-timeline',
+ options.eventOverlap === false ? 'fc-timeline-overlap-disabled' : 'fc-timeline-overlap-enabled',
+ ];
+ var slotMinWidth = options.slotMinWidth;
+ var slatCols = buildSlatCols(tDateProfile, slotMinWidth || this.computeFallbackSlotMinWidth(tDateProfile));
+ return (createElement(ViewRoot, { viewSpec: viewSpec }, function (rootElRef, classNames) { return (createElement("div", { ref: rootElRef, className: extraClassNames.concat(classNames).join(' ') },
+ createElement(ResourceTimelineViewLayout, { ref: _this.layoutRef, forPrint: props.forPrint, isHeightAuto: props.isHeightAuto, spreadsheetCols: buildSpreadsheetCols(colSpecs, state.spreadsheetColWidths, ''), spreadsheetHeaderRows: function (contentArg) { return (createElement(SpreadsheetHeader // TODO: rename to SpreadsheetHeaderRows
+ , { superHeaderRendering: superHeaderRendering, colSpecs: colSpecs, onColWidthChange: _this.handleColWidthChange, rowInnerHeights: contentArg.rowSyncHeights })); }, spreadsheetBodyRows: function (contentArg) { return (createElement(Fragment, null, _this.renderSpreadsheetRows(rowNodes, colSpecs, contentArg.rowSyncHeights))); }, timeCols: slatCols, timeHeaderContent: function (contentArg) { return (createElement(TimelineHeader, { clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, tableMinWidth: contentArg.tableMinWidth, tableColGroupNode: contentArg.tableColGroupNode, dateProfile: props.dateProfile, tDateProfile: tDateProfile, slatCoords: state.slatCoords, rowInnerHeights: contentArg.rowSyncHeights, onMaxCushionWidth: slotMinWidth ? null : _this.handleMaxCushionWidth })); }, timeBodyContent: function (contentArg) { return (createElement(ResourceTimelineGrid, { dateProfile: props.dateProfile, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, tableMinWidth: contentArg.tableMinWidth, tableColGroupNode: contentArg.tableColGroupNode, expandRows: contentArg.expandRows, tDateProfile: tDateProfile, rowNodes: rowNodes, businessHours: props.businessHours, dateSelection: props.dateSelection, eventStore: props.eventStore, eventUiBases: props.eventUiBases, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, resourceStore: props.resourceStore, nextDayThreshold: context.options.nextDayThreshold, rowInnerHeights: contentArg.rowSyncHeights, onSlatCoords: _this.handleSlatCoords, onRowCoords: _this.handleRowCoords, onScrollLeftRequest: _this.handleScrollLeftRequest, onRowHeightChange: contentArg.reportRowHeightChange })); } }))); }));
+ };
+ ResourceTimelineView.prototype.renderSpreadsheetRows = function (nodes, colSpecs, rowSyncHeights) {
+ return nodes.map(function (node, index) {
+ if (node.group) {
+ return (createElement(SpreadsheetGroupRow, { key: node.id, id: node.id, spreadsheetColCnt: colSpecs.length, isExpanded: node.isExpanded, group: node.group, innerHeight: rowSyncHeights[index] || '' }));
+ }
+ if (node.resource) {
+ return (createElement(SpreadsheetRow, { key: node.id, colSpecs: colSpecs, rowSpans: node.rowSpans, depth: node.depth, isExpanded: node.isExpanded, hasChildren: node.hasChildren, resource: node.resource, innerHeight: rowSyncHeights[index] || '' }));
+ }
+ return null;
+ });
+ };
+ ResourceTimelineView.prototype.componentDidMount = function () {
+ this.renderedRowNodes = this.rowNodes;
+ this.scrollResponder = this.context.createScrollResponder(this.handleScrollRequest);
+ };
+ ResourceTimelineView.prototype.getSnapshotBeforeUpdate = function () {
+ if (!this.props.forPrint) { // because print-view is always zero?
+ return { resourceScroll: this.queryResourceScroll() };
+ }
+ return {};
+ };
+ ResourceTimelineView.prototype.componentDidUpdate = function (prevProps, prevState, snapshot) {
+ this.renderedRowNodes = this.rowNodes;
+ this.scrollResponder.update(prevProps.dateProfile !== this.props.dateProfile);
+ if (snapshot.resourceScroll) {
+ this.handleScrollRequest(snapshot.resourceScroll); // TODO: this gets triggered too often
+ }
+ };
+ ResourceTimelineView.prototype.componentWillUnmount = function () {
+ this.scrollResponder.detach();
+ };
+ ResourceTimelineView.prototype.computeFallbackSlotMinWidth = function (tDateProfile) {
+ return Math.max(30, ((this.state.slotCushionMaxWidth || 0) / tDateProfile.slotsPerLabel));
+ };
+ ResourceTimelineView.prototype.queryResourceScroll = function () {
+ var _a = this, rowCoords = _a.rowCoords, renderedRowNodes = _a.renderedRowNodes;
+ if (rowCoords) {
+ var layout = this.layoutRef.current;
+ var trBottoms = rowCoords.bottoms;
+ var scrollTop = layout.getResourceScroll();
+ var scroll_1 = {};
+ for (var i = 0; i < trBottoms.length; i += 1) {
+ var rowNode = renderedRowNodes[i];
+ var elBottom = trBottoms[i] - scrollTop; // from the top of the scroller
+ if (elBottom > 0) {
+ scroll_1.rowId = rowNode.id;
+ scroll_1.fromBottom = elBottom;
+ break;
+ }
+ }
+ return scroll_1;
+ }
+ return null;
+ };
+ return ResourceTimelineView;
+ }(BaseComponent));
+ ResourceTimelineView.addStateEquality({
+ spreadsheetColWidths: isArraysEqual,
+ });
+ function buildRowIndex(rowNodes) {
+ var rowIdToIndex = {};
+ for (var i = 0; i < rowNodes.length; i += 1) {
+ rowIdToIndex[rowNodes[i].id] = i;
+ }
+ return rowIdToIndex;
+ }
+ function buildSpreadsheetCols(colSpecs, forcedWidths, fallbackWidth) {
+ if (fallbackWidth === void 0) { fallbackWidth = ''; }
+ return colSpecs.map(function (colSpec, i) { return ({
+ className: colSpec.isMain ? 'fc-main-col' : '',
+ width: forcedWidths[i] || colSpec.width || fallbackWidth,
+ }); });
+ }
+ function hasNesting(nodes) {
+ for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+ var node = nodes_1[_i];
+ if (node.group) {
+ return true;
+ }
+ if (node.resource) {
+ if (node.hasChildren) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ function processColOptions(options) {
+ var allColSpecs = options.resourceAreaColumns || [];
+ var superHeaderRendering = null;
+ if (!allColSpecs.length) {
+ allColSpecs.push({
+ headerClassNames: options.resourceAreaHeaderClassNames,
+ headerContent: options.resourceAreaHeaderContent || 'Resources',
+ headerDidMount: options.resourceAreaHeaderDidMount,
+ headerWillUnmount: options.resourceAreaHeaderWillUnmount,
+ });
+ }
+ else if (options.resourceAreaHeaderContent) { // weird way to determine if content
+ superHeaderRendering = {
+ headerClassNames: options.resourceAreaHeaderClassNames,
+ headerContent: options.resourceAreaHeaderContent,
+ headerDidMount: options.resourceAreaHeaderDidMount,
+ headerWillUnmount: options.resourceAreaHeaderWillUnmount,
+ };
+ }
+ var plainColSpecs = [];
+ var groupColSpecs = []; // part of the colSpecs, but filtered out in order to put first
+ var groupSpecs = [];
+ var isVGrouping = false;
+ for (var _i = 0, allColSpecs_1 = allColSpecs; _i < allColSpecs_1.length; _i++) {
+ var colSpec = allColSpecs_1[_i];
+ if (colSpec.group) {
+ groupColSpecs.push(__assign(__assign({}, colSpec), { cellClassNames: colSpec.cellClassNames || options.resourceGroupLabelClassNames, cellContent: colSpec.cellContent || options.resourceGroupLabelContent, cellDidMount: colSpec.cellDidMount || options.resourceGroupLabelDidMount, cellWillUnmount: colSpec.cellWillUnmount || options.resourceGroupLaneWillUnmount }));
+ }
+ else {
+ plainColSpecs.push(colSpec);
+ }
+ }
+ // BAD: mutates a user-supplied option
+ var mainColSpec = plainColSpecs[0];
+ mainColSpec.isMain = true;
+ mainColSpec.cellClassNames = mainColSpec.cellClassNames || options.resourceLabelClassNames;
+ mainColSpec.cellContent = mainColSpec.cellContent || options.resourceLabelContent;
+ mainColSpec.cellDidMount = mainColSpec.cellDidMount || options.resourceLabelDidMount;
+ mainColSpec.cellWillUnmount = mainColSpec.cellWillUnmount || options.resourceLabelWillUnmount;
+ if (groupColSpecs.length) {
+ groupSpecs = groupColSpecs;
+ isVGrouping = true;
+ }
+ else {
+ var hGroupField = options.resourceGroupField;
+ if (hGroupField) {
+ groupSpecs.push({
+ field: hGroupField,
+ labelClassNames: options.resourceGroupLabelClassNames,
+ labelContent: options.resourceGroupLabelContent,
+ labelDidMount: options.resourceGroupLabelDidMount,
+ labelWillUnmount: options.resourceGroupLabelWillUnmount,
+ laneClassNames: options.resourceGroupLaneClassNames,
+ laneContent: options.resourceGroupLaneContent,
+ laneDidMount: options.resourceGroupLaneDidMount,
+ laneWillUnmount: options.resourceGroupLaneWillUnmount,
+ });
+ }
+ }
+ var allOrderSpecs = options.resourceOrder || DEFAULT_RESOURCE_ORDER;
+ var plainOrderSpecs = [];
+ for (var _a = 0, allOrderSpecs_1 = allOrderSpecs; _a < allOrderSpecs_1.length; _a++) {
+ var orderSpec = allOrderSpecs_1[_a];
+ var isGroup = false;
+ for (var _b = 0, groupSpecs_1 = groupSpecs; _b < groupSpecs_1.length; _b++) {
+ var groupSpec = groupSpecs_1[_b];
+ if (groupSpec.field === orderSpec.field) {
+ groupSpec.order = orderSpec.order; // -1, 0, 1
+ isGroup = true;
+ break;
+ }
+ }
+ if (!isGroup) {
+ plainOrderSpecs.push(orderSpec);
+ }
+ }
+ return {
+ superHeaderRendering: superHeaderRendering,
+ isVGrouping: isVGrouping,
+ groupSpecs: groupSpecs,
+ colSpecs: groupColSpecs.concat(plainColSpecs),
+ orderSpecs: plainOrderSpecs,
+ };
+ }
+
+ var resourceTimelinePlugin = createPlugin({
+ deps: [
+ premiumCommonPlugin,
+ resourceCommonPlugin,
+ timelinePlugin,
+ ],
+ initialView: 'resourceTimelineDay',
+ views: {
+ resourceTimeline: {
+ type: 'timeline',
+ component: ResourceTimelineView,
+ needsResourceData: true,
+ resourceAreaWidth: '30%',
+ resourcesInitiallyExpanded: true,
+ eventResizableFromStart: true, // TODO: not DRY with this same setting in the main timeline config
+ },
+ resourceTimelineDay: {
+ type: 'resourceTimeline',
+ duration: { days: 1 },
+ },
+ resourceTimelineWeek: {
+ type: 'resourceTimeline',
+ duration: { weeks: 1 },
+ },
+ resourceTimelineMonth: {
+ type: 'resourceTimeline',
+ duration: { months: 1 },
+ },
+ resourceTimelineYear: {
+ type: 'resourceTimeline',
+ duration: { years: 1 },
+ },
+ },
+ });
+
+ globalPlugins.push(interactionPlugin, dayGridPlugin, timeGridPlugin, listPlugin, plugin, googleCalendarPlugin, scrollGridPlugin, adaptivePlugin, timelinePlugin, resourceCommonPlugin, resourceDayGridPlugin, resourceTimeGridPlugin, resourceTimelinePlugin);
+
+ exports.AbstractResourceDayTableModel = AbstractResourceDayTableModel;
+ exports.BASE_OPTION_DEFAULTS = BASE_OPTION_DEFAULTS;
+ exports.BASE_OPTION_REFINERS = BASE_OPTION_REFINERS;
+ exports.BaseComponent = BaseComponent;
+ exports.BgEvent = BgEvent;
+ exports.BootstrapTheme = BootstrapTheme;
+ exports.Calendar = Calendar;
+ exports.CalendarApi = CalendarApi;
+ exports.CalendarContent = CalendarContent;
+ exports.CalendarDataManager = CalendarDataManager;
+ exports.CalendarDataProvider = CalendarDataProvider;
+ exports.CalendarRoot = CalendarRoot;
+ exports.Component = Component;
+ exports.ContentHook = ContentHook;
+ exports.CustomContentRenderContext = CustomContentRenderContext;
+ exports.DEFAULT_RESOURCE_ORDER = DEFAULT_RESOURCE_ORDER;
+ exports.DateComponent = DateComponent;
+ exports.DateEnv = DateEnv;
+ exports.DateProfileGenerator = DateProfileGenerator;
+ exports.DayCellContent = DayCellContent;
+ exports.DayCellRoot = DayCellRoot;
+ exports.DayGridView = DayTableView;
+ exports.DayHeader = DayHeader;
+ exports.DayResourceTableModel = DayResourceTableModel;
+ exports.DaySeriesModel = DaySeriesModel;
+ exports.DayTable = DayTable;
+ exports.DayTableModel = DayTableModel;
+ exports.DayTableSlicer = DayTableSlicer;
+ exports.DayTimeCols = DayTimeCols;
+ exports.DayTimeColsSlicer = DayTimeColsSlicer;
+ exports.DayTimeColsView = DayTimeColsView;
+ exports.DelayedRunner = DelayedRunner;
+ exports.Draggable = ExternalDraggable;
+ exports.ElementDragging = ElementDragging;
+ exports.ElementScrollController = ElementScrollController;
+ exports.Emitter = Emitter;
+ exports.EventApi = EventApi;
+ exports.EventRoot = EventRoot;
+ exports.EventSourceApi = EventSourceApi;
+ exports.FeaturefulElementDragging = FeaturefulElementDragging;
+ exports.Fragment = Fragment;
+ exports.Interaction = Interaction;
+ exports.ListView = ListView;
+ exports.MoreLinkRoot = MoreLinkRoot;
+ exports.MountHook = MountHook;
+ exports.NamedTimeZoneImpl = NamedTimeZoneImpl;
+ exports.NowIndicatorRoot = NowIndicatorRoot;
+ exports.NowTimer = NowTimer;
+ exports.PointerDragging = PointerDragging;
+ exports.PositionCache = PositionCache;
+ exports.RefMap = RefMap;
+ exports.RenderHook = RenderHook;
+ exports.ResourceApi = ResourceApi;
+ exports.ResourceDayHeader = ResourceDayHeader;
+ exports.ResourceDayTable = ResourceDayTable;
+ exports.ResourceDayTableModel = ResourceDayTableModel;
+ exports.ResourceDayTableView = ResourceDayTableView;
+ exports.ResourceDayTimeCols = ResourceDayTimeCols;
+ exports.ResourceDayTimeColsView = ResourceDayTimeColsView;
+ exports.ResourceLabelRoot = ResourceLabelRoot;
+ exports.ResourceSplitter = ResourceSplitter;
+ exports.ResourceTimelineLane = ResourceTimelineLane;
+ exports.ResourceTimelineView = ResourceTimelineView;
+ exports.ScrollController = ScrollController;
+ exports.ScrollGrid = ScrollGrid;
+ exports.ScrollResponder = ScrollResponder;
+ exports.Scroller = Scroller;
+ exports.SegHierarchy = SegHierarchy;
+ exports.SimpleScrollGrid = SimpleScrollGrid;
+ exports.Slicer = Slicer;
+ exports.Splitter = Splitter;
+ exports.SpreadsheetRow = SpreadsheetRow;
+ exports.StandardEvent = StandardEvent;
+ exports.Table = Table;
+ exports.TableDateCell = TableDateCell;
+ exports.TableDowCell = TableDowCell;
+ exports.TableView = TableView;
+ exports.Theme = Theme;
+ exports.ThirdPartyDraggable = ThirdPartyDraggable;
+ exports.TimeCols = TimeCols;
+ exports.TimeColsSlatsCoords = TimeColsSlatsCoords;
+ exports.TimeColsView = TimeColsView;
+ exports.TimelineCoords = TimelineCoords;
+ exports.TimelineHeader = TimelineHeader;
+ exports.TimelineHeaderRows = TimelineHeaderRows;
+ exports.TimelineLane = TimelineLane;
+ exports.TimelineLaneBg = TimelineLaneBg;
+ exports.TimelineLaneSlicer = TimelineLaneSlicer;
+ exports.TimelineSlats = TimelineSlats;
+ exports.TimelineView = TimelineView;
+ exports.VResourceJoiner = VResourceJoiner;
+ exports.VResourceSplitter = VResourceSplitter;
+ exports.ViewApi = ViewApi;
+ exports.ViewContextType = ViewContextType;
+ exports.ViewRoot = ViewRoot;
+ exports.WeekNumberRoot = WeekNumberRoot;
+ exports.WindowScrollController = WindowScrollController;
+ exports.addDays = addDays;
+ exports.addDurations = addDurations;
+ exports.addMs = addMs;
+ exports.addWeeks = addWeeks;
+ exports.allowContextMenu = allowContextMenu;
+ exports.allowSelection = allowSelection;
+ exports.applyMutationToEventStore = applyMutationToEventStore;
+ exports.applyStyle = applyStyle;
+ exports.applyStyleProp = applyStyleProp;
+ exports.asCleanDays = asCleanDays;
+ exports.asRoughMinutes = asRoughMinutes;
+ exports.asRoughMs = asRoughMs;
+ exports.asRoughSeconds = asRoughSeconds;
+ exports.binarySearch = binarySearch;
+ exports.buildClassNameNormalizer = buildClassNameNormalizer;
+ exports.buildDayRanges = buildDayRanges;
+ exports.buildDayTableModel = buildDayTableModel;
+ exports.buildEntryKey = buildEntryKey;
+ exports.buildEventApis = buildEventApis;
+ exports.buildEventRangeKey = buildEventRangeKey;
+ exports.buildHashFromArray = buildHashFromArray;
+ exports.buildIsoString = buildIsoString;
+ exports.buildNavLinkAttrs = buildNavLinkAttrs;
+ exports.buildResourceFields = buildResourceFields;
+ exports.buildRowNodes = buildRowNodes;
+ exports.buildSegCompareObj = buildSegCompareObj;
+ exports.buildSegTimeText = buildSegTimeText;
+ exports.buildSlatCols = buildSlatCols;
+ exports.buildSlatMetas = buildSlatMetas;
+ exports.buildTimeColsModel = buildTimeColsModel;
+ exports.buildTimelineDateProfile = buildTimelineDateProfile;
+ exports.collectFromHash = collectFromHash;
+ exports.combineEventUis = combineEventUis;
+ exports.compareByFieldSpec = compareByFieldSpec;
+ exports.compareByFieldSpecs = compareByFieldSpecs;
+ exports.compareNumbers = compareNumbers;
+ exports.compareObjs = compareObjs;
+ exports.computeEarliestSegStart = computeEarliestSegStart;
+ exports.computeEdges = computeEdges;
+ exports.computeFallbackHeaderFormat = computeFallbackHeaderFormat;
+ exports.computeHeightAndMargins = computeHeightAndMargins;
+ exports.computeInnerRect = computeInnerRect;
+ exports.computeRect = computeRect;
+ exports.computeSegDraggable = computeSegDraggable;
+ exports.computeSegEndResizable = computeSegEndResizable;
+ exports.computeSegStartResizable = computeSegStartResizable;
+ exports.computeShrinkWidth = computeShrinkWidth;
+ exports.computeSmallestCellWidth = computeSmallestCellWidth;
+ exports.computeVisibleDayRange = computeVisibleDayRange;
+ exports.config = config;
+ exports.constrainPoint = constrainPoint;
+ exports.coordToCss = coordToCss;
+ exports.coordsToCss = coordsToCss;
+ exports.createAriaClickAttrs = createAriaClickAttrs;
+ exports.createContext = createContext;
+ exports.createDuration = createDuration;
+ exports.createElement = createElement;
+ exports.createEmptyEventStore = createEmptyEventStore;
+ exports.createEventInstance = createEventInstance;
+ exports.createEventUi = createEventUi;
+ exports.createFormatter = createFormatter;
+ exports.createPlugin = createPlugin;
+ exports.createPortal = createPortal;
+ exports.createRef = createRef;
+ exports.diffDates = diffDates;
+ exports.diffDayAndTime = diffDayAndTime;
+ exports.diffDays = diffDays;
+ exports.diffPoints = diffPoints;
+ exports.diffWeeks = diffWeeks;
+ exports.diffWholeDays = diffWholeDays;
+ exports.diffWholeWeeks = diffWholeWeeks;
+ exports.disableCursor = disableCursor;
+ exports.elementClosest = elementClosest;
+ exports.elementMatches = elementMatches;
+ exports.enableCursor = enableCursor;
+ exports.eventTupleToStore = eventTupleToStore;
+ exports.filterEventStoreDefs = filterEventStoreDefs;
+ exports.filterHash = filterHash;
+ exports.findDirectChildren = findDirectChildren;
+ exports.findElements = findElements;
+ exports.flattenResources = flattenResources;
+ exports.flexibleCompare = flexibleCompare;
+ exports.flushToDom = flushToDom;
+ exports.formatDate = formatDate;
+ exports.formatDayString = formatDayString;
+ exports.formatIsoTimeString = formatIsoTimeString;
+ exports.formatRange = formatRange;
+ exports.getAllowYScrolling = getAllowYScrolling;
+ exports.getCanVGrowWithinCell = getCanVGrowWithinCell;
+ exports.getClippingParents = getClippingParents;
+ exports.getDateMeta = getDateMeta;
+ exports.getDayClassNames = getDayClassNames;
+ exports.getDefaultEventEnd = getDefaultEventEnd;
+ exports.getElRoot = getElRoot;
+ exports.getElSeg = getElSeg;
+ exports.getEntrySpanEnd = getEntrySpanEnd;
+ exports.getEventClassNames = getEventClassNames;
+ exports.getEventTargetViaRoot = getEventTargetViaRoot;
+ exports.getIsRtlScrollbarOnLeft = getIsRtlScrollbarOnLeft;
+ exports.getPublicId = getPublicId;
+ exports.getRectCenter = getRectCenter;
+ exports.getRelevantEvents = getRelevantEvents;
+ exports.getScrollGridClassNames = getScrollGridClassNames;
+ exports.getScrollbarWidths = getScrollbarWidths;
+ exports.getSectionClassNames = getSectionClassNames;
+ exports.getSectionHasLiquidHeight = getSectionHasLiquidHeight;
+ exports.getSegAnchorAttrs = getSegAnchorAttrs;
+ exports.getSegMeta = getSegMeta;
+ exports.getSlotClassNames = getSlotClassNames;
+ exports.getStickyFooterScrollbar = getStickyFooterScrollbar;
+ exports.getStickyHeaderDates = getStickyHeaderDates;
+ exports.getUnequalProps = getUnequalProps;
+ exports.getUniqueDomId = getUniqueDomId;
+ exports.globalLocales = globalLocales;
+ exports.globalPlugins = globalPlugins;
+ exports.greatestDurationDenominator = greatestDurationDenominator;
+ exports.groupIntersectingEntries = groupIntersectingEntries;
+ exports.guid = guid;
+ exports.hasBgRendering = hasBgRendering;
+ exports.hasShrinkWidth = hasShrinkWidth;
+ exports.identity = identity;
+ exports.interactionSettingsStore = interactionSettingsStore;
+ exports.interactionSettingsToStore = interactionSettingsToStore;
+ exports.intersectRanges = intersectRanges;
+ exports.intersectRects = intersectRects;
+ exports.intersectSpans = intersectSpans;
+ exports.isArraysEqual = isArraysEqual;
+ exports.isColPropsEqual = isColPropsEqual;
+ exports.isDateSelectionValid = isDateSelectionValid;
+ exports.isDateSpansEqual = isDateSpansEqual;
+ exports.isGroupsEqual = isGroupsEqual;
+ exports.isInt = isInt;
+ exports.isInteractionValid = isInteractionValid;
+ exports.isMultiDayRange = isMultiDayRange;
+ exports.isPropsEqual = isPropsEqual;
+ exports.isPropsValid = isPropsValid;
+ exports.isValidDate = isValidDate$1;
+ exports.joinSpans = joinSpans;
+ exports.listenBySelector = listenBySelector;
+ exports.mapHash = mapHash;
+ exports.memoize = memoize;
+ exports.memoizeArraylike = memoizeArraylike;
+ exports.memoizeHashlike = memoizeHashlike;
+ exports.memoizeObjArg = memoizeObjArg;
+ exports.mergeEventStores = mergeEventStores;
+ exports.multiplyDuration = multiplyDuration;
+ exports.padStart = padStart;
+ exports.parseBusinessHours = parseBusinessHours;
+ exports.parseClassNames = parseClassNames;
+ exports.parseDragMeta = parseDragMeta;
+ exports.parseEventDef = parseEventDef;
+ exports.parseFieldSpecs = parseFieldSpecs;
+ exports.parseMarker = parse;
+ exports.pointInsideRect = pointInsideRect;
+ exports.preventContextMenu = preventContextMenu;
+ exports.preventDefault = preventDefault;
+ exports.preventSelection = preventSelection;
+ exports.rangeContainsMarker = rangeContainsMarker;
+ exports.rangeContainsRange = rangeContainsRange;
+ exports.rangesEqual = rangesEqual;
+ exports.rangesIntersect = rangesIntersect;
+ exports.refineEventDef = refineEventDef;
+ exports.refineProps = refineProps;
+ exports.removeElement = removeElement;
+ exports.removeExact = removeExact;
+ exports.render = render;
+ exports.renderChunkContent = renderChunkContent;
+ exports.renderFill = renderFill;
+ exports.renderMicroColGroup = renderMicroColGroup;
+ exports.renderScrollShim = renderScrollShim;
+ exports.requestJson = requestJson;
+ exports.sanitizeShrinkWidth = sanitizeShrinkWidth;
+ exports.setElSeg = setElSeg;
+ exports.setRef = setRef;
+ exports.setScrollFromLeftEdge = setScrollFromLeftEdge;
+ exports.sliceEventStore = sliceEventStore;
+ exports.sliceEvents = sliceEvents;
+ exports.sortEventSegs = sortEventSegs;
+ exports.startOfDay = startOfDay;
+ exports.translateRect = translateRect;
+ exports.triggerDateSelect = triggerDateSelect;
+ exports.unmountComponentAtNode = unmountComponentAtNode;
+ exports.unpromisify = unpromisify;
+ exports.version = version;
+ exports.whenTransitionDone = whenTransitionDone;
+ exports.wholeDivideDurations = wholeDivideDurations;
+
+ Object.defineProperty(exports, '__esModule', { value: true });
+
+ return exports;
+
+}({}));
diff --git a/theme/libs/fullcalendar/main.min.css b/theme/libs/fullcalendar/main.min.css
new file mode 100644
index 000000000..b4efa1969
--- /dev/null
+++ b/theme/libs/fullcalendar/main.min.css
@@ -0,0 +1 @@
+.fc-icon,.fc-unselectable{-moz-user-select:none;-ms-user-select:none}.fc .fc-button,.fc-icon{text-transform:none;font-weight:400}.fc-not-allowed,.fc-not-allowed .fc-event{cursor:not-allowed}.fc .fc-button:not(:disabled),.fc a[data-navlink],.fc-event.fc-event-draggable,.fc-event[href]{cursor:pointer}.fc-unselectable{-webkit-user-select:none;user-select:none;-webkit-touch-callout:none;-webkit-tap-highlight-color:transparent}.fc{display:flex;flex-direction:column;font-size:1em}.fc .fc-button,.fc-icon{display:inline-block;text-align:center}.fc,.fc *,.fc :after,.fc :before{box-sizing:border-box}.fc table{border-collapse:collapse;border-spacing:0;font-size:1em}.fc th{text-align:center}.fc td,.fc th{vertical-align:top;padding:0}.fc .fc-button,.fc .fc-button .fc-icon,.fc .fc-button-group,.fc .fc-timegrid-slot-label{vertical-align:middle}.fc a[data-navlink]:hover{text-decoration:underline}.fc .fc-button:hover,.fc .fc-list-event-title a,a.fc-event,a.fc-event:hover{text-decoration:none}.fc-direction-ltr{direction:ltr;text-align:left}.fc-direction-rtl{direction:rtl;text-align:right}.fc-theme-standard td,.fc-theme-standard th{border:1px solid #ddd;border:1px solid var(--fc-border-color,#ddd)}.fc-liquid-hack td,.fc-liquid-hack th{position:relative}@font-face{font-family:fcicons;src:url("data:application/x-font-ttf;charset=utf-8;base64,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") format('truetype');font-weight:400;font-style:normal}.fc-icon{width:1em;height:1em;-webkit-user-select:none;user-select:none;font-family:fcicons!important;speak:none;font-style:normal;font-variant:normal;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fc-icon-chevron-left:before{content:"\e900"}.fc-icon-chevron-right:before{content:"\e901"}.fc-icon-chevrons-left:before{content:"\e902"}.fc-icon-chevrons-right:before{content:"\e903"}.fc-icon-minus-square:before{content:"\e904"}.fc-icon-plus-square:before{content:"\e905"}.fc-icon-x:before{content:"\e906"}.fc .fc-button{overflow:visible;text-transform:none;margin:0;font-family:inherit}.fc .fc-button::-moz-focus-inner{padding:0;border-style:none}.fc .fc-button{-webkit-appearance:button;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;background-color:transparent;border:1px solid transparent;padding:.4em .65em;font-size:1em;line-height:1.5;border-radius:.25em}.fc .fc-button:focus{outline:0;box-shadow:0 0 0 .2rem rgba(44,62,80,.25)}.fc .fc-button-primary:focus,.fc .fc-button-primary:not(:disabled).fc-button-active:focus,.fc .fc-button-primary:not(:disabled):active:focus{box-shadow:0 0 0 .2rem rgba(76,91,106,.5)}.fc .fc-button:disabled{opacity:.65}.fc .fc-button-primary{color:#fff;color:var(--fc-button-text-color,#fff);background-color:#2C3E50;background-color:var(--fc-button-bg-color,#2C3E50);border-color:#2C3E50;border-color:var(--fc-button-border-color,#2C3E50)}.fc .fc-button-primary:hover{color:#fff;color:var(--fc-button-text-color,#fff);background-color:#1e2b37;background-color:var(--fc-button-hover-bg-color,#1e2b37);border-color:#1a252f;border-color:var(--fc-button-hover-border-color,#1a252f)}.fc .fc-button-primary:disabled{color:#fff;color:var(--fc-button-text-color,#fff);background-color:#2C3E50;background-color:var(--fc-button-bg-color,#2C3E50);border-color:#2C3E50;border-color:var(--fc-button-border-color,#2C3E50)}.fc .fc-button-primary:not(:disabled).fc-button-active,.fc .fc-button-primary:not(:disabled):active{color:#fff;color:var(--fc-button-text-color,#fff);background-color:#1a252f;background-color:var(--fc-button-active-bg-color,#1a252f);border-color:#151e27;border-color:var(--fc-button-active-border-color,#151e27)}.fc .fc-button .fc-icon{font-size:1.5em}.fc .fc-button-group{position:relative;display:inline-flex}.fc .fc-button-group>.fc-button{position:relative;flex:1 1 auto}.fc .fc-button-group>.fc-button.fc-button-active,.fc .fc-button-group>.fc-button:active,.fc .fc-button-group>.fc-button:focus,.fc .fc-button-group>.fc-button:hover{z-index:1}.fc-direction-ltr .fc-button-group>.fc-button:not(:first-child){margin-left:-1px;border-top-left-radius:0;border-bottom-left-radius:0}.fc-direction-ltr .fc-button-group>.fc-button:not(:last-child){border-top-right-radius:0;border-bottom-right-radius:0}.fc-direction-rtl .fc-button-group>.fc-button:not(:first-child){margin-right:-1px;border-top-right-radius:0;border-bottom-right-radius:0}.fc-direction-rtl .fc-button-group>.fc-button:not(:last-child){border-top-left-radius:0;border-bottom-left-radius:0}.fc .fc-toolbar{display:flex;justify-content:space-between;align-items:center}.fc .fc-toolbar.fc-header-toolbar{margin-bottom:1.5em}.fc .fc-toolbar.fc-footer-toolbar{margin-top:1.5em}.fc .fc-toolbar-title{font-size:1.75em;margin:0}.fc-direction-ltr .fc-toolbar>*>:not(:first-child){margin-left:.75em}.fc-direction-rtl .fc-toolbar>*>:not(:first-child){margin-right:.75em}.fc-direction-rtl .fc-toolbar-ltr{flex-direction:row-reverse}.fc .fc-scroller{-webkit-overflow-scrolling:touch;position:relative}.fc .fc-scroller-liquid{height:100%}.fc .fc-scroller-liquid-absolute{position:absolute;top:0;right:0;left:0;bottom:0}.fc .fc-scroller-harness{position:relative;overflow:hidden;direction:ltr}.fc .fc-scroller-harness-liquid{height:100%}.fc-direction-rtl .fc-scroller-harness>.fc-scroller{direction:rtl}.fc-theme-standard .fc-scrollgrid{border:1px solid #ddd;border:1px solid var(--fc-border-color,#ddd)}.fc .fc-scrollgrid,.fc .fc-scrollgrid-section-footer>*,.fc .fc-scrollgrid-section-header>*{border-bottom-width:0}.fc .fc-scrollgrid,.fc .fc-scrollgrid table{width:100%;table-layout:fixed}.fc .fc-scrollgrid table{border-top-style:hidden;border-left-style:hidden;border-right-style:hidden}.fc .fc-scrollgrid{border-collapse:separate;border-right-width:0}.fc .fc-scrollgrid-liquid{height:100%}.fc .fc-scrollgrid-section,.fc .fc-scrollgrid-section table,.fc .fc-scrollgrid-section>td{height:1px}.fc .fc-scrollgrid-section-liquid>td{height:100%}.fc .fc-scrollgrid-section>*{border-top-width:0;border-left-width:0}.fc .fc-scrollgrid-section-body table,.fc .fc-scrollgrid-section-footer table{border-bottom-style:hidden}.fc .fc-scrollgrid-section-sticky>*{background:var(--fc-page-bg-color,#fff);position:sticky;z-index:3}.fc .fc-scrollgrid-section-header.fc-scrollgrid-section-sticky>*{top:0}.fc .fc-scrollgrid-section-footer.fc-scrollgrid-section-sticky>*{bottom:0}.fc .fc-scrollgrid-sticky-shim{height:1px;margin-bottom:-1px}.fc-sticky{position:sticky}.fc .fc-view-harness{flex-grow:1;position:relative}.fc .fc-bg-event,.fc .fc-highlight,.fc .fc-non-business,.fc .fc-view-harness-active>.fc-view{position:absolute;top:0;left:0;right:0;bottom:0}.fc .fc-col-header-cell-cushion{display:inline-block;padding:2px 4px}.fc .fc-non-business{background:rgba(215,215,215,.3);background:var(--fc-non-business-color,rgba(215,215,215,.3))}.fc .fc-bg-event{background:var(--fc-bg-event-color,#8fdf82);opacity:.3;opacity:var(--fc-bg-event-opacity,.3)}.fc .fc-bg-event .fc-event-title{margin:.5em;font-size:.85em;font-size:var(--fc-small-font-size,.85em);font-style:italic}.fc .fc-highlight{background:rgba(188,232,241,.3);background:var(--fc-highlight-color,rgba(188,232,241,.3))}.fc .fc-cell-shaded,.fc .fc-day-disabled{background:rgba(208,208,208,.3);background:var(--fc-neutral-bg-color,rgba(208,208,208,.3))}.fc-event .fc-event-main{position:relative;z-index:2}.fc-event-dragging:not(.fc-event-selected){opacity:.75}.fc-event-dragging.fc-event-selected{box-shadow:0 2px 7px rgba(0,0,0,.3)}.fc-event .fc-event-resizer{display:none;position:absolute;z-index:4}.fc-event-selected .fc-event-resizer,.fc-event:hover .fc-event-resizer,.fc-h-event{display:block}.fc-event-selected .fc-event-resizer{border-radius:4px;border-radius:calc(var(--fc-event-resizer-dot-total-width,8px)/ 2);border-width:1px;border-width:var(--fc-event-resizer-dot-border-width,1px);width:8px;width:var(--fc-event-resizer-dot-total-width,8px);height:8px;height:var(--fc-event-resizer-dot-total-width,8px);border-style:solid;border-color:inherit;background:var(--fc-page-bg-color,#fff)}.fc-event-selected .fc-event-resizer:before{content:'';position:absolute;top:-20px;left:-20px;right:-20px;bottom:-20px}.fc-event-selected,.fc-event:focus{box-shadow:0 2px 5px rgba(0,0,0,.2)}.fc-event-selected:before,.fc-event:focus:before{content:"";position:absolute;z-index:3;top:0;left:0;right:0;bottom:0}.fc-event-selected:after,.fc-event:focus:after{content:"";background:rgba(0,0,0,.25);background:var(--fc-event-selected-overlay-color,rgba(0,0,0,.25));position:absolute;z-index:1;top:-1px;left:-1px;right:-1px;bottom:-1px}.fc-h-event{border:1px solid #3788d8;border:1px solid var(--fc-event-border-color,#3788d8);background-color:#3788d8;background-color:var(--fc-event-bg-color,#3788d8)}.fc-h-event .fc-event-main{color:#fff;color:var(--fc-event-text-color,#fff)}.fc-h-event .fc-event-main-frame{display:flex}.fc-h-event .fc-event-time{max-width:100%;overflow:hidden}.fc-h-event .fc-event-title-container{flex-grow:1;flex-shrink:1;min-width:0}.fc-h-event .fc-event-title{display:inline-block;vertical-align:top;left:0;right:0;max-width:100%;overflow:hidden}.fc-h-event.fc-event-selected:before{top:-10px;bottom:-10px}.fc-direction-ltr .fc-daygrid-block-event:not(.fc-event-start),.fc-direction-rtl .fc-daygrid-block-event:not(.fc-event-end){border-top-left-radius:0;border-bottom-left-radius:0;border-left-width:0}.fc-direction-ltr .fc-daygrid-block-event:not(.fc-event-end),.fc-direction-rtl .fc-daygrid-block-event:not(.fc-event-start){border-top-right-radius:0;border-bottom-right-radius:0;border-right-width:0}.fc-h-event:not(.fc-event-selected) .fc-event-resizer{top:0;bottom:0;width:8px;width:var(--fc-event-resizer-thickness,8px)}.fc-direction-ltr .fc-h-event:not(.fc-event-selected) .fc-event-resizer-start,.fc-direction-rtl .fc-h-event:not(.fc-event-selected) .fc-event-resizer-end{cursor:w-resize;left:-4px;left:calc(-.5 * var(--fc-event-resizer-thickness,8px))}.fc-direction-ltr .fc-h-event:not(.fc-event-selected) .fc-event-resizer-end,.fc-direction-rtl .fc-h-event:not(.fc-event-selected) .fc-event-resizer-start{cursor:e-resize;right:-4px;right:calc(-.5 * var(--fc-event-resizer-thickness,8px))}.fc-h-event.fc-event-selected .fc-event-resizer{top:50%;margin-top:-4px;margin-top:calc(-.5 * var(--fc-event-resizer-dot-total-width,8px))}.fc-direction-ltr .fc-h-event.fc-event-selected .fc-event-resizer-start,.fc-direction-rtl .fc-h-event.fc-event-selected .fc-event-resizer-end{left:-4px;left:calc(-.5 * var(--fc-event-resizer-dot-total-width,8px))}.fc-direction-ltr .fc-h-event.fc-event-selected .fc-event-resizer-end,.fc-direction-rtl .fc-h-event.fc-event-selected .fc-event-resizer-start{right:-4px;right:calc(-.5 * var(--fc-event-resizer-dot-total-width,8px))}.fc .fc-popover{position:absolute;z-index:9999;box-shadow:0 2px 6px rgba(0,0,0,.15)}.fc .fc-popover-header{display:flex;flex-direction:row;justify-content:space-between;align-items:center;padding:3px 4px}.fc .fc-popover-title{margin:0 2px}.fc .fc-popover-close{cursor:pointer;opacity:.65;font-size:1.1em}.fc-theme-standard .fc-popover{border:1px solid #ddd;border:1px solid var(--fc-border-color,#ddd);background:var(--fc-page-bg-color,#fff)}.fc-theme-standard .fc-popover-header{background:rgba(208,208,208,.3);background:var(--fc-neutral-bg-color,rgba(208,208,208,.3))}:root{--fc-daygrid-event-dot-width:8px;--fc-list-event-dot-width:10px;--fc-list-event-hover-bg-color:#f5f5f5}.fc-daygrid-day-events:after,.fc-daygrid-day-events:before,.fc-daygrid-day-frame:after,.fc-daygrid-day-frame:before,.fc-daygrid-event-harness:after,.fc-daygrid-event-harness:before{content:"";clear:both;display:table}.fc .fc-daygrid-body{position:relative;z-index:1}.fc .fc-daygrid-day.fc-day-today{background-color:rgba(255,220,40,.15);background-color:var(--fc-today-bg-color,rgba(255,220,40,.15))}.fc .fc-daygrid-day-frame{position:relative;min-height:100%}.fc .fc-daygrid-day-top{display:flex;flex-direction:row-reverse}.fc .fc-day-other .fc-daygrid-day-top{opacity:.3}.fc .fc-daygrid-day-number{position:relative;z-index:4;padding:4px}.fc .fc-daygrid-day-events{margin-top:1px}.fc .fc-daygrid-body-balanced .fc-daygrid-day-events{position:absolute;left:0;right:0}.fc .fc-daygrid-body-unbalanced .fc-daygrid-day-events{position:relative;min-height:2em}.fc .fc-daygrid-body-natural .fc-daygrid-day-events{margin-bottom:1em}.fc .fc-daygrid-event-harness{position:relative}.fc .fc-daygrid-event-harness-abs{position:absolute;top:0;left:0;right:0}.fc .fc-daygrid-bg-harness{position:absolute;top:0;bottom:0}.fc .fc-daygrid-day-bg .fc-non-business{z-index:1}.fc .fc-daygrid-day-bg .fc-bg-event{z-index:2}.fc .fc-daygrid-day-bg .fc-highlight{z-index:3}.fc .fc-daygrid-event{z-index:6;margin-top:1px}.fc .fc-daygrid-event.fc-event-mirror{z-index:7}.fc .fc-daygrid-day-bottom{font-size:.85em;padding:2px 3px 0}.fc .fc-daygrid-day-bottom:before{content:"";clear:both;display:table}.fc .fc-daygrid-more-link{position:relative;z-index:4;cursor:pointer}.fc .fc-daygrid-week-number{position:absolute;z-index:5;top:0;padding:2px;min-width:1.5em;text-align:center;background-color:rgba(208,208,208,.3);background-color:var(--fc-neutral-bg-color,rgba(208,208,208,.3));color:grey;color:var(--fc-neutral-text-color,grey)}.fc .fc-more-popover .fc-popover-body{min-width:220px;padding:10px}.fc-direction-ltr .fc-daygrid-event.fc-event-start,.fc-direction-rtl .fc-daygrid-event.fc-event-end{margin-left:2px}.fc-direction-ltr .fc-daygrid-event.fc-event-end,.fc-direction-rtl .fc-daygrid-event.fc-event-start{margin-right:2px}.fc-direction-ltr .fc-daygrid-week-number{left:0;border-radius:0 0 3px}.fc-direction-rtl .fc-daygrid-week-number{right:0;border-radius:0 0 0 3px}.fc-liquid-hack .fc-daygrid-day-frame{position:static}.fc-daygrid-event{position:relative;white-space:nowrap;border-radius:3px;font-size:.85em;font-size:var(--fc-small-font-size,.85em)}.fc-daygrid-block-event .fc-event-time{font-weight:700}.fc-daygrid-block-event .fc-event-time,.fc-daygrid-block-event .fc-event-title{padding:1px}.fc-daygrid-dot-event{display:flex;align-items:center;padding:2px 0}.fc-daygrid-dot-event .fc-event-title{flex-grow:1;flex-shrink:1;min-width:0;overflow:hidden;font-weight:700}.fc-daygrid-dot-event.fc-event-mirror,.fc-daygrid-dot-event:hover{background:rgba(0,0,0,.1)}.fc-daygrid-dot-event.fc-event-selected:before{top:-10px;bottom:-10px}.fc-daygrid-event-dot{margin:0 4px;box-sizing:content-box;width:0;height:0;border:4px solid #3788d8;border:calc(var(--fc-daygrid-event-dot-width,8px)/ 2) solid var(--fc-event-border-color,#3788d8);border-radius:4px;border-radius:calc(var(--fc-daygrid-event-dot-width,8px)/ 2)}.fc-direction-ltr .fc-daygrid-event .fc-event-time{margin-right:3px}.fc-direction-rtl .fc-daygrid-event .fc-event-time{margin-left:3px}.fc-v-event{display:block;border:1px solid #3788d8;border:1px solid var(--fc-event-border-color,#3788d8);background-color:#3788d8;background-color:var(--fc-event-bg-color,#3788d8)}.fc-v-event .fc-event-main{color:#fff;color:var(--fc-event-text-color,#fff);height:100%}.fc-v-event .fc-event-main-frame{height:100%;display:flex;flex-direction:column}.fc-v-event .fc-event-time{flex-grow:0;flex-shrink:0;max-height:100%;overflow:hidden}.fc-v-event .fc-event-title-container{flex-grow:1;flex-shrink:1;min-height:0}.fc-v-event .fc-event-title{top:0;bottom:0;max-height:100%;overflow:hidden}.fc-v-event:not(.fc-event-start){border-top-width:0;border-top-left-radius:0;border-top-right-radius:0}.fc-v-event:not(.fc-event-end){border-bottom-width:0;border-bottom-left-radius:0;border-bottom-right-radius:0}.fc-v-event.fc-event-selected:before{left:-10px;right:-10px}.fc-v-event .fc-event-resizer-start{cursor:n-resize}.fc-v-event .fc-event-resizer-end{cursor:s-resize}.fc-v-event:not(.fc-event-selected) .fc-event-resizer{height:8px;height:var(--fc-event-resizer-thickness,8px);left:0;right:0}.fc-v-event:not(.fc-event-selected) .fc-event-resizer-start{top:-4px;top:calc(var(--fc-event-resizer-thickness,8px)/ -2)}.fc-v-event:not(.fc-event-selected) .fc-event-resizer-end{bottom:-4px;bottom:calc(var(--fc-event-resizer-thickness,8px)/ -2)}.fc-v-event.fc-event-selected .fc-event-resizer{left:50%;margin-left:-4px;margin-left:calc(var(--fc-event-resizer-dot-total-width,8px)/ -2)}.fc-v-event.fc-event-selected .fc-event-resizer-start{top:-4px;top:calc(var(--fc-event-resizer-dot-total-width,8px)/ -2)}.fc-v-event.fc-event-selected .fc-event-resizer-end{bottom:-4px;bottom:calc(var(--fc-event-resizer-dot-total-width,8px)/ -2)}.fc .fc-timegrid .fc-daygrid-body{z-index:2}.fc .fc-timegrid-axis-chunk>table,.fc .fc-timegrid-body,.fc .fc-timegrid-slots{position:relative;z-index:1}.fc .fc-timegrid-divider{padding:0 0 2px}.fc .fc-timegrid-body{min-height:100%}.fc .fc-timegrid-axis-chunk{position:relative}.fc .fc-timegrid-slot{height:1.5em;border-bottom:0}.fc .fc-timegrid-slot:empty:before{content:'\00a0'}.fc .fc-timegrid-slot-minor{border-top-style:dotted}.fc .fc-timegrid-slot-label-cushion{display:inline-block;white-space:nowrap}.fc .fc-timegrid-axis-cushion,.fc .fc-timegrid-slot-label-cushion{padding:0 4px}.fc .fc-timegrid-axis-frame-liquid{height:100%}.fc .fc-timegrid-axis-frame{overflow:hidden;display:flex;align-items:center;justify-content:flex-end}.fc .fc-timegrid-axis-cushion{max-width:60px;flex-shrink:0}.fc-direction-ltr .fc-timegrid-slot-label-frame{text-align:right}.fc-direction-rtl .fc-timegrid-slot-label-frame{text-align:left}.fc-liquid-hack .fc-timegrid-axis-frame-liquid{height:auto;position:absolute;top:0;right:0;bottom:0;left:0}.fc .fc-timegrid-col.fc-day-today{background-color:rgba(255,220,40,.15);background-color:var(--fc-today-bg-color,rgba(255,220,40,.15))}.fc-timegrid-more-link,.fc-timeline-more-link{background:var(--fc-more-link-bg-color,#d0d0d0);cursor:pointer}.fc .fc-timegrid-col-frame{min-height:100%;position:relative}.fc-media-screen.fc-liquid-hack .fc-timegrid-col-frame{height:auto;position:absolute;top:0;right:0;bottom:0;left:0}.fc-media-screen .fc-timegrid-cols{position:absolute;top:0;left:0;right:0;bottom:0}.fc-media-screen .fc-timegrid-cols>table{height:100%}.fc-media-screen .fc-timegrid-col-bg,.fc-media-screen .fc-timegrid-col-events,.fc-media-screen .fc-timegrid-now-indicator-container{position:absolute;top:0;left:0;right:0}.fc .fc-timegrid-col-bg{z-index:2}.fc .fc-timegrid-col-bg .fc-non-business{z-index:1}.fc .fc-timegrid-col-bg .fc-bg-event{z-index:2}.fc .fc-timegrid-col-bg .fc-highlight,.fc .fc-timegrid-col-events{z-index:3}.fc .fc-timegrid-bg-harness{position:absolute;left:0;right:0}.fc .fc-timegrid-now-indicator-container{bottom:0;overflow:hidden}.fc-direction-ltr .fc-timegrid-col-events{margin:0 2.5% 0 2px}.fc-direction-rtl .fc-timegrid-col-events{margin:0 2px 0 2.5%}.fc-timegrid-event-harness{position:absolute}.fc-timegrid-event-harness>.fc-timegrid-event{position:absolute;top:0;bottom:0;left:0;right:0}.fc-timegrid-event-harness-inset .fc-timegrid-event,.fc-timegrid-event.fc-event-mirror,.fc-timegrid-more-link{box-shadow:0 0 0 1px #fff;box-shadow:0 0 0 1px var(--fc-page-bg-color,#fff)}.fc-timegrid-event,.fc-timegrid-more-link{font-size:.85em;font-size:var(--fc-small-font-size,.85em);border-radius:3px}.fc-timegrid-event{margin-bottom:1px}.fc-timegrid-event .fc-event-main{padding:1px 1px 0}.fc-timegrid-event .fc-event-time{white-space:nowrap;font-size:.85em;font-size:var(--fc-small-font-size,.85em);margin-bottom:1px}.fc-timegrid-event-short .fc-event-main-frame{flex-direction:row;overflow:hidden}.fc-timegrid-event-short .fc-event-time:after{content:'\00a0-\00a0'}.fc-timegrid-event-short .fc-event-title{font-size:.85em;font-size:var(--fc-small-font-size,.85em)}.fc-timegrid-more-link{position:absolute;z-index:9999;color:inherit;color:var(--fc-more-link-text-color,inherit);margin-bottom:1px}.fc-timegrid-more-link-inner{padding:3px 2px;top:0}.fc-direction-ltr .fc-timegrid-more-link{right:0}.fc-direction-rtl .fc-timegrid-more-link{left:0}.fc .fc-timegrid-now-indicator-line{position:absolute;z-index:4;left:0;right:0;border-style:solid;border-color:red;border-color:var(--fc-now-indicator-color,red);border-width:1px 0 0}.fc .fc-timegrid-now-indicator-arrow{position:absolute;z-index:4;margin-top:-5px;border-style:solid;border-color:red;border-color:var(--fc-now-indicator-color,red)}.fc-direction-ltr .fc-timegrid-now-indicator-arrow{left:0;border-width:5px 0 5px 6px;border-top-color:transparent;border-bottom-color:transparent}.fc-direction-rtl .fc-timegrid-now-indicator-arrow{right:0;border-width:5px 6px 5px 0;border-top-color:transparent;border-bottom-color:transparent}.fc-theme-standard .fc-list{border:1px solid #ddd;border:1px solid var(--fc-border-color,#ddd)}.fc .fc-list-empty{background-color:rgba(208,208,208,.3);background-color:var(--fc-neutral-bg-color,rgba(208,208,208,.3));height:100%;display:flex;justify-content:center;align-items:center}.fc .fc-list-empty-cushion{margin:5em 0}.fc .fc-list-table{width:100%;border-style:hidden}.fc .fc-list-table tr>*{border-left:0;border-right:0}.fc .fc-list-sticky .fc-list-day>*{position:sticky;top:0;background:var(--fc-page-bg-color,#fff)}.fc .fc-list-table thead{position:absolute;left:-10000px}.fc .fc-list-table tbody>tr:first-child th{border-top:0}.fc .fc-list-table th{padding:0}.fc .fc-list-day-cushion,.fc .fc-list-table td{padding:8px 14px}.fc .fc-list-day-cushion:after{content:"";clear:both;display:table}.fc-theme-standard .fc-list-day-cushion{background-color:rgba(208,208,208,.3);background-color:var(--fc-neutral-bg-color,rgba(208,208,208,.3))}.fc-direction-ltr .fc-list-day-text,.fc-direction-rtl .fc-list-day-side-text{float:left}.fc-direction-ltr .fc-list-day-side-text,.fc-direction-rtl .fc-list-day-text{float:right}.fc-direction-ltr .fc-list-table .fc-list-event-graphic{padding-right:0}.fc-direction-rtl .fc-list-table .fc-list-event-graphic{padding-left:0}.fc .fc-list-event.fc-event-forced-url{cursor:pointer}.fc .fc-list-event:hover td{background-color:#f5f5f5;background-color:var(--fc-list-event-hover-bg-color,#f5f5f5)}.fc .fc-list-event-graphic,.fc .fc-list-event-time{white-space:nowrap;width:1px}.fc .fc-list-event-dot{display:inline-block;box-sizing:content-box;width:0;height:0;border:5px solid #3788d8;border:calc(var(--fc-list-event-dot-width,10px)/ 2) solid var(--fc-event-border-color,#3788d8);border-radius:5px;border-radius:calc(var(--fc-list-event-dot-width,10px)/ 2)}.fc .fc-list-event-title a{color:inherit}.fc .fc-list-event.fc-event-forced-url:hover a{text-decoration:underline}.fc-theme-bootstrap a:not([href]){color:inherit}.fc .fc-event,.fc .fc-scrollgrid table tr{-moz-column-break-inside:avoid;break-inside:avoid}.fc-media-print{display:block;max-width:100%}.fc-media-print .fc-bg-event,.fc-media-print .fc-non-business,.fc-media-print .fc-timegrid-axis-chunk,.fc-media-print .fc-timegrid-slots,.fc-media-print .fc-timeline-slots{display:none}.fc-media-print .fc-h-event,.fc-media-print .fc-toolbar button,.fc-media-print .fc-v-event{color:#000!important;background:#fff!important}.fc-media-print .fc-event,.fc-media-print .fc-event-main{color:#000!important}.fc-media-print .fc-timegrid-event{margin:.5em 0}.fc .fc-timeline-body{min-height:100%;position:relative;z-index:1}.fc .fc-timeline-slots{position:absolute;z-index:1;top:0;bottom:0}.fc .fc-timeline-slots>table{height:100%}.fc .fc-timeline-slot-minor{border-style:dotted}.fc .fc-timeline-slot-frame{display:flex;align-items:center;justify-content:center}.fc .fc-timeline-header-row-chrono .fc-timeline-slot-frame{justify-content:flex-start}.fc .fc-timeline-header-row:last-child .fc-timeline-slot-frame{overflow:hidden}.fc .fc-timeline-slot-cushion{padding:4px 5px;white-space:nowrap}.fc-direction-ltr .fc-timeline-slot{border-right:0!important}.fc-direction-rtl .fc-timeline-slot{border-left:0!important}.fc .fc-timeline-now-indicator-container{position:absolute;z-index:4;top:0;bottom:0;left:0;right:0;width:0}.fc .fc-timeline-now-indicator-arrow,.fc .fc-timeline-now-indicator-line{position:absolute;top:0;border-style:solid;border-color:red;border-color:var(--fc-now-indicator-color,red)}.fc .fc-timeline-now-indicator-arrow{margin:0 -6px;border-width:6px 5px 0;border-left-color:transparent;border-right-color:transparent}.fc .fc-timeline-now-indicator-line{margin:0 -1px;bottom:0;border-width:0 0 0 1px}.fc .fc-timeline-events{position:relative;z-index:3;width:0}.fc .fc-timeline-event-harness,.fc .fc-timeline-more-link{position:absolute;top:0}.fc-timeline-event{z-index:1;position:relative;display:flex;align-items:center;border-radius:0;padding:2px 1px;margin-bottom:1px;font-size:.85em;font-size:var(--fc-small-font-size,.85em)}.fc-timeline-event.fc-event-mirror{z-index:2}.fc-timeline-event .fc-event-main{flex-grow:1;flex-shrink:1;min-width:0}.fc-timeline-event .fc-event-time{font-weight:700}.fc-timeline-event .fc-event-time,.fc-timeline-event .fc-event-title{white-space:nowrap;padding:0 2px}.fc-direction-ltr .fc-timeline-event.fc-event-end,.fc-direction-ltr .fc-timeline-more-link{margin-right:1px}.fc-direction-rtl .fc-timeline-event.fc-event-end,.fc-direction-rtl .fc-timeline-more-link{margin-left:1px}.fc-timeline-overlap-disabled .fc-timeline-event{padding-top:5px;padding-bottom:5px;margin-bottom:0}.fc-timeline-event:not(.fc-event-end):after,.fc-timeline-event:not(.fc-event-start):before{content:"";flex-grow:0;flex-shrink:0;opacity:.5;width:0;height:0;margin:0 1px;border:5px solid #000;border-top-color:transparent;border-bottom-color:transparent}.fc-direction-ltr .fc-timeline-event:not(.fc-event-start):before,.fc-direction-rtl .fc-timeline-event:not(.fc-event-end):after{border-left:0}.fc-direction-ltr .fc-timeline-event:not(.fc-event-end):after,.fc-direction-rtl .fc-timeline-event:not(.fc-event-start):before{border-right:0}.fc-timeline-more-link{font-size:.85em;font-size:var(--fc-small-font-size,.85em);color:inherit;color:var(--fc-more-link-text-color,inherit);padding:1px}.fc-timeline-more-link-inner{display:inline-block;left:0;right:0;padding:2px}.fc .fc-timeline-bg{position:absolute;z-index:2;top:0;bottom:0;width:0;left:0;right:0}.fc .fc-timeline-bg .fc-non-business{z-index:1}.fc .fc-timeline-bg .fc-bg-event{z-index:2}.fc .fc-timeline-bg .fc-highlight{z-index:3}.fc .fc-timeline-bg-harness{position:absolute;top:0;bottom:0}.fc .fc-timeline-lane-frame,.fc-timeline-body-expandrows td.fc-timeline-lane{position:relative}.fc .fc-resource-timeline-divider{width:3px;cursor:col-resize}.fc .fc-resource-group{font-weight:inherit;text-align:inherit}.fc .fc-resource-timeline .fc-resource-group:not([rowspan]){background:rgba(208,208,208,.3);background:var(--fc-neutral-bg-color,rgba(208,208,208,.3))}.fc .fc-timeline-overlap-enabled .fc-timeline-lane-frame .fc-timeline-events{box-sizing:content-box;padding-bottom:10px}.fc-timeline-body-expandrows .fc-timeline-lane-frame{position:static}.fc-datagrid-cell-frame-liquid{height:100%}.fc-liquid-hack .fc-datagrid-cell-frame-liquid{height:auto;position:absolute;top:0;right:0;bottom:0;left:0}.fc .fc-datagrid-header .fc-datagrid-cell-frame{position:relative;display:flex;justify-content:flex-start;align-items:center}.fc .fc-datagrid-cell-resizer{position:absolute;z-index:1;top:0;bottom:0;width:5px;cursor:col-resize}.fc .fc-datagrid-cell-cushion{padding:8px;white-space:nowrap;overflow:hidden}.fc .fc-datagrid-expander{cursor:pointer;opacity:.65}.fc .fc-datagrid-expander .fc-icon{display:inline-block;width:1em}.fc .fc-datagrid-expander-placeholder{cursor:auto}.fc .fc-resource-timeline-flat .fc-datagrid-expander-placeholder{display:none}.fc-direction-ltr .fc-datagrid-cell-resizer{right:-3px}.fc-direction-rtl .fc-datagrid-cell-resizer{left:-3px}.fc-direction-ltr .fc-datagrid-expander{margin-right:3px}.fc-direction-rtl .fc-datagrid-expander{margin-left:3px}
diff --git a/theme/libs/fullcalendar/main.min.js b/theme/libs/fullcalendar/main.min.js
new file mode 100644
index 000000000..a3de058b3
--- /dev/null
+++ b/theme/libs/fullcalendar/main.min.js
@@ -0,0 +1,6 @@
+/*!
+FullCalendar Scheduler v5.10.1
+Docs & License: https://fullcalendar.io/scheduler
+(c) 2021 Adam Shaw
+*/
+var FullCalendar=function(e){"use strict";var t=function(e,n){return(t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n])})(e,n)};function n(e,n){if("function"!=typeof n&&null!==n)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");function r(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}var r=function(){return(r=Object.assign||function(e){for(var t,n=1,r=arguments.length;n3)for(n=[n],i=3;i0?g(v.type,v.props,v.key,null,v.__v):v)){if(v.__=n,v.__b=n.__b+1,null===(h=C[p])||h&&v.key==h.key&&v.type===h.type)C[p]=void 0;else for(f=0;f3;)n.pop()();if(n[1]>>1,1),t.i.removeChild(e)}}),W(v(oe,{context:t.context},e.__v),t.l)):t.l&&t.componentWillUnmount()}(ne.prototype=new y).__e=function(e){var t=this,n=te(t.__v),r=t.o.get(e);return r[0]++,function(o){var i=function(){t.props.revealOrder?(r.push(o),re(t,e,r)):o()};n?n(i):i()}},ne.prototype.render=function(e){this.u=null,this.o=new Map;var t=w(e.children);e.revealOrder&&"b"===e.revealOrder[0]&&t.reverse();for(var n=t.length;n--;)this.o.set(t[n],this.u=[1,0,this.u]);return e.children},ne.prototype.componentDidUpdate=ne.prototype.componentDidMount=function(){var e=this;this.o.forEach((function(t,n){re(e,n,t)}))};var ae="undefined"!=typeof Symbol&&Symbol.for&&Symbol.for("react.element")||60103,se=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|fill|flood|font|glyph(?!R)|horiz|marker(?!H|W|U)|overline|paint|stop|strikethrough|stroke|text(?!L)|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,le=function(e){return("undefined"!=typeof Symbol&&"symbol"==typeof Symbol()?/fil|che|rad/i:/fil|che|ra/i).test(e)};y.prototype.isReactComponent={},["componentWillMount","componentWillReceiveProps","componentWillUpdate"].forEach((function(e){Object.defineProperty(y.prototype,e,{configurable:!0,get:function(){return this["UNSAFE_"+e]},set:function(t){Object.defineProperty(this,e,{configurable:!0,writable:!0,value:t})}})}));var ue=i.event;function ce(){}function de(){return this.cancelBubble}function pe(){return this.defaultPrevented}i.event=function(e){return ue&&(e=ue(e)),e.persist=ce,e.isPropagationStopped=de,e.isDefaultPrevented=pe,e.nativeEvent=e};var fe={configurable:!0,get:function(){return this.class}},he=i.vnode;i.vnode=function(e){var t=e.type,n=e.props,r=n;if("string"==typeof t){for(var o in r={},n){var i=n[o];"value"===o&&"defaultValue"in n&&null==i||("defaultValue"===o&&"value"in n&&null==n.value?o="value":"download"===o&&!0===i?i="":/ondoubleclick/i.test(o)?o="ondblclick":/^onchange(textarea|input)/i.test(o+t)&&!le(n.type)?o="oninput":/^on(Ani|Tra|Tou|BeforeInp)/.test(o)?o=o.toLowerCase():se.test(o)?o=o.replace(/[A-Z0-9]/,"-$&").toLowerCase():null===i&&(i=void 0),r[o]=i)}"select"==t&&r.multiple&&Array.isArray(r.value)&&(r.value=w(n.children).forEach((function(e){e.props.selected=-1!=r.value.indexOf(e.props.value)}))),"select"==t&&null!=r.defaultValue&&(r.value=w(n.children).forEach((function(e){e.props.selected=r.multiple?-1!=r.defaultValue.indexOf(e.props.value):r.defaultValue==e.props.value}))),e.props=r}t&&n.class!=n.className&&(fe.enumerable="className"in n,null!=n.className&&(r.class=n.className),Object.defineProperty(r,"className",fe)),e.$$typeof=ae,he&&he(e)};var ve=i.__r;i.__r=function(e){ve&&ve(e)},"object"==typeof performance&&"function"==typeof performance.now&&performance.now.bind(performance);var ge="undefined"!=typeof globalThis?globalThis:window;ge.FullCalendarVDom?console.warn("FullCalendar VDOM already loaded"):ge.FullCalendarVDom={Component:y,createElement:v,render:W,createRef:function(){return{current:null}},Fragment:m,createContext:function(e){var t=function(e,t){var n={__c:t="__cC"+u++,__:e,Consumer:function(e,t){return e.children(t)},Provider:function(e){var n,r;return this.getChildContext||(n=[],(r={})[t]=this,this.getChildContext=function(){return r},this.shouldComponentUpdate=function(e){this.props.value!==e.value&&n.some(b)},this.sub=function(e){n.push(e);var t=e.componentWillUnmount;e.componentWillUnmount=function(){n.splice(n.indexOf(e),1),t&&t.call(e)}}),e.children}};return n.Provider.__=n.Consumer.contextType=n}(e),n=t.Provider;return t.Provider=function(){var e=this,t=!this.getChildContext,r=n.apply(this,arguments);if(t){var o=[];this.shouldComponentUpdate=function(t){e.props.value!==t.value&&o.forEach((function(e){e.context=t.value,e.forceUpdate()}))},this.sub=function(e){o.push(e);var t=e.componentWillUnmount;e.componentWillUnmount=function(){o.splice(o.indexOf(e),1),t&&t.call(e)}}}return r},t},createPortal:function(e,t){return v(ie,{__v:e,i:t})},flushToDom:function(){var e=i.debounceRendering,t=[];function n(e){t.push(e)}i.debounceRendering=n,W(v(me,{}),document.createElement("div"));for(;t.length;)t.shift()();i.debounceRendering=e},unmountComponentAtNode:function(e){W(null,e)}};var me=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return n(t,e),t.prototype.render=function(){return v("div",{})},t.prototype.componentDidMount=function(){this.setState({})},t}(y);var ye=function(){function e(e,t){this.context=e,this.internalEventSource=t}return e.prototype.remove=function(){this.context.dispatch({type:"REMOVE_EVENT_SOURCE",sourceId:this.internalEventSource.sourceId})},e.prototype.refetch=function(){this.context.dispatch({type:"FETCH_EVENT_SOURCES",sourceIds:[this.internalEventSource.sourceId],isRefetch:!0})},Object.defineProperty(e.prototype,"id",{get:function(){return this.internalEventSource.publicId},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"url",{get:function(){return this.internalEventSource.meta.url},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"format",{get:function(){return this.internalEventSource.meta.format},enumerable:!1,configurable:!0}),e}();function Se(e){e.parentNode&&e.parentNode.removeChild(e)}function Ee(e,t){if(e.closest)return e.closest(t);if(!document.documentElement.contains(e))return null;do{if(be(e,t))return e;e=e.parentElement||e.parentNode}while(null!==e&&1===e.nodeType);return null}function be(e,t){return(e.matches||e.matchesSelector||e.msMatchesSelector).call(e,t)}function Ce(e,t){for(var n=e instanceof HTMLElement?[e]:e,r=[],o=0;o=0;i-=1){var a=e[i][r];if("object"==typeof a&&a)o.unshift(a);else if(void 0!==a){n[r]=a;break}}o.length&&(n[r]=Et(o))}for(i=e.length-1;i>=0;i-=1){var s=e[i];for(var l in s)l in n||(n[l]=s[l])}return n}function bt(e,t){var n={};for(var r in e)t(e[r],r)&&(n[r]=e[r]);return n}function Ct(e,t){var n={};for(var r in e)n[r]=t(e[r],r);return n}function Dt(e){for(var t={},n=0,r=e;n10&&(null==t?r=r.replace("Z",""):0!==t&&(r=r.replace("Z",Zt(t,!0)))),r}function qt(e){return e.toISOString().replace(/T.*$/,"")}function Yt(e){return Xe(e.getUTCHours(),2)+":"+Xe(e.getUTCMinutes(),2)+":"+Xe(e.getUTCSeconds(),2)}function Zt(e,t){void 0===t&&(t=!1);var n=e<0?"-":"+",r=Math.abs(e),o=Math.floor(r/60),i=Math.round(r%60);return t?n+Xe(o,2)+":"+Xe(i,2):"GMT"+n+o+(i?":"+Xe(i,2):"")}function Xt(e,t){for(var n=0,r=0;r1)||"numeric"!==o.year&&"2-digit"!==o.year||"numeric"!==o.month&&"2-digit"!==o.month||"numeric"!==o.day&&"2-digit"!==o.day||(s=1);var l=this.format(e,n),u=this.format(t,n);if(l===u)return l;var c=cn(function(e,t){var n={};for(var r in e)(!(r in nn)||nn[r]<=t)&&(n[r]=e[r]);return n}(o,s),i,n),d=c(e),p=c(t),f=function(e,t,n,r){var o=0;for(;o=Vt(t)&&(r=nt(r,1))}return e.start&&(n=ut(e.start),r&&r<=n&&(r=nt(n,1))),{start:n,end:r}}function Yn(e){var t=qn(e);return it(t.start,t.end)>1}function Zn(e,t,n,r){return"year"===r?Ht(n.diffWholeYears(e,t),"year"):"month"===r?Ht(n.diffWholeMonths(e,t),"month"):at(e,t)}function Xn(e,t){var n,r,o=[],i=t.start;for(e.sort(Kn),n=0;ni&&o.push({start:i,end:r.start}),r.end>i&&(i=r.end);return it.start)&&(null===e.start||null===t.end||e.start=e.start)&&(null===e.end||null!==t.end&&t.end<=e.end)}function tr(e,t){return(null===e.start||t>=e.start)&&(null===e.end||t=(n||t.end),isToday:t&&tr(t,r.start)}}function vr(e){var t=["fc-event"];return e.isMirror&&t.push("fc-event-mirror"),e.isDraggable&&t.push("fc-event-draggable"),(e.isStartResizable||e.isEndResizable)&&t.push("fc-event-resizable"),e.isDragging&&t.push("fc-event-dragging"),e.isResizing&&t.push("fc-event-resizing"),e.isSelected&&t.push("fc-event-selected"),e.isStart&&t.push("fc-event-start"),e.isEnd&&t.push("fc-event-end"),e.isPast&&t.push("fc-event-past"),e.isToday&&t.push("fc-event-today"),e.isFuture&&t.push("fc-event-future"),t}function gr(e){return e.instance?e.instance.instanceId:e.def.defId+":"+e.range.start.toISOString()}function mr(e,t){var n=e.eventRange,r=n.def,o=n.instance,i=r.url;if(i)return{href:i};var a=t.emitter,s=t.options.eventInteractive;return null==s&&null==(s=r.interactive)&&(s=Boolean(a.hasHandlers("eventClick"))),s?Ae((function(e){a.trigger("eventClick",{el:e.target,event:new Ar(t,r,o),jsEvent:e,view:t.viewApi})})):{}}var yr={start:wn,end:wn,allDay:Boolean};function Sr(e,t,n){var o=function(e,t){var n=Rn(e,yr),o=n.refined,i=n.extra,a=o.start?t.createMarkerMeta(o.start):null,s=o.end?t.createMarkerMeta(o.end):null,l=o.allDay;null==l&&(l=a&&a.isTimeUnspecified&&(!s||s.isTimeUnspecified));return r({range:{start:a?a.marker:null,end:s?s.marker:null},allDay:l},i)}(e,t),i=o.range;if(!i.start)return null;if(!i.end){if(null==n)return null;i.end=t.add(i.start,n)}return o}function Er(e,t){return Jn(e.range,t.range)&&e.allDay===t.allDay&&function(e,t){for(var n in t)if("range"!==n&&"allDay"!==n&&e[n]!==t[n])return!1;for(var n in e)if(!(n in t))return!1;return!0}(e,t)}function br(e,t,n){return r(r({},Cr(e,t,n)),{timeZone:t.timeZone})}function Cr(e,t,n){return{start:t.toDate(e.start),end:t.toDate(e.end),startStr:t.formatIso(e.start,{omitTime:n}),endStr:t.formatIso(e.end,{omitTime:n})}}function Dr(e,t,n){var r=Vn({editable:!1},n),o=Gn(r.refined,r.extra,"",e.allDay,!0,n);return{def:o,ui:sr(o,t),instance:yt(o.defId,e.range),range:e.range,isStart:!0,isEnd:!0}}function Rr(e,t,n){n.emitter.trigger("select",r(r({},wr(e,n)),{jsEvent:t?t.origEvent:null,view:n.viewApi||n.calendarApi.view}))}function wr(e,t){for(var n,o,i={},a=0,s=t.pluginHooks.dateSpanTransforms;a=0;r-=1){var o=n[r].parseMeta(e);if(o)return{sourceDefId:r,meta:o}}return null}(i,t);if(s)return{_raw:e,isFetching:!1,latestFetchId:"",fetchRange:null,defaultAllDay:i.defaultAllDay,eventDataTransform:i.eventDataTransform,success:i.success,failure:i.failure,publicId:i.id||"",sourceId:Le(),sourceDefId:s.sourceDefId,meta:s.meta,ui:On(i,t),extendedProps:a}}return null}function Nr(e){return r(r(r({},Nn),Ir),e.pluginHooks.eventSourceRefiners)}function Hr(e,t){return"function"==typeof e&&(e=e()),null==e?t.createNowMarker():t.createMarker(e)}var Or=function(){function e(){}return e.prototype.getCurrentData=function(){return this.currentDataManager.getCurrentData()},e.prototype.dispatch=function(e){return this.currentDataManager.dispatch(e)},Object.defineProperty(e.prototype,"view",{get:function(){return this.getCurrentData().viewApi},enumerable:!1,configurable:!0}),e.prototype.batchRendering=function(e){e()},e.prototype.updateSize=function(){this.trigger("_resize",!0)},e.prototype.setOption=function(e,t){this.dispatch({type:"SET_OPTION",optionName:e,rawOptionValue:t})},e.prototype.getOption=function(e){return this.currentDataManager.currentCalendarOptionsInput[e]},e.prototype.getAvailableLocaleCodes=function(){return Object.keys(this.getCurrentData().availableRawLocales)},e.prototype.on=function(e,t){var n=this.currentDataManager;n.currentCalendarOptionsRefiners[e]?n.emitter.on(e,t):console.warn("Unknown listener name '"+e+"'")},e.prototype.off=function(e,t){this.currentDataManager.emitter.off(e,t)},e.prototype.trigger=function(e){for(var t,n=[],r=1;r=1?Math.min(o,i):o}(e,this.weekDow,this.weekDoy)},e.prototype.format=function(e,t,n){return void 0===n&&(n={}),t.format({marker:e,timeZoneOffset:null!=n.forcedTzo?n.forcedTzo:this.offsetForMarker(e)},this)},e.prototype.formatRange=function(e,t,n,r){return void 0===r&&(r={}),r.isEndExclusive&&(t=rt(t,-1)),n.formatRange({marker:e,timeZoneOffset:null!=r.forcedStartTzo?r.forcedStartTzo:this.offsetForMarker(e)},{marker:t,timeZoneOffset:null!=r.forcedEndTzo?r.forcedEndTzo:this.offsetForMarker(t)},this,r.defaultSeparator)},e.prototype.formatIso=function(e,t){void 0===t&&(t={});var n=null;return t.omitTimeZoneOffset||(n=null!=t.forcedTzo?t.forcedTzo:this.offsetForMarker(e)),jt(e,n,t.omitTime)},e.prototype.timestampToMarker=function(e){return"local"===this.timeZone?vt(pt(new Date(e))):"UTC"!==this.timeZone&&this.namedTimeZoneImpl?vt(this.namedTimeZoneImpl.timestampToArray(e)):new Date(e)},e.prototype.offsetForMarker=function(e){return"local"===this.timeZone?-ft(ht(e)).getTimezoneOffset():"UTC"===this.timeZone?0:this.namedTimeZoneImpl?this.namedTimeZoneImpl.offsetForArray(ht(e)):null},e.prototype.toDate=function(e,t){return"local"===this.timeZone?ft(ht(e)):"UTC"===this.timeZone?new Date(e.valueOf()):this.namedTimeZoneImpl?new Date(e.valueOf()-1e3*this.namedTimeZoneImpl.offsetForArray(ht(e))*60):new Date(e.valueOf()-(t||0))},e}(),jr=[],qr={code:"en",week:{dow:0,doy:4},direction:"ltr",buttonText:{prev:"prev",next:"next",prevYear:"prev year",nextYear:"next year",year:"year",today:"today",month:"month",week:"week",day:"day",list:"list"},weekText:"W",weekTextLong:"Week",closeHint:"Close",timeHint:"Time",eventHint:"Event",allDayText:"all-day",moreLinkText:"more",noEventsText:"No events to display"},Yr=r(r({},qr),{buttonHints:{prev:"Previous $0",next:"Next $0",today:function(e,t){return"day"===t?"Today":"This "+e}},viewHint:"$0 view",navLinkHint:"Go to $0",moreLinkHint:function(e){return"Show "+e+" more event"+(1===e?"":"s")}});function Zr(e){for(var t=e.length>0?e[0].code:"en",n=jr.concat(e),r={en:Yr},o=0,i=n;o0;o-=1){var i=r.slice(0,o).join("-");if(t[i])return t[i]}return null}(n,t)||Yr;return Kr(e,n,r)}(e,t):Kr(e.code,[e.code],e)}function Kr(e,t,n){var r=Et([qr,n],["buttonText"]);delete r.code;var o=r.week;return delete r.week,{codeArg:e,codes:t,week:o,simpleNumberFormat:new Intl.NumberFormat(e),options:r}}function $r(e){var t=Xr(e.locale||"en",Zr([]).map);return new Gr(r(r({timeZone:mn.timeZone,calendarSystem:"gregory"},e),{locale:t}))}var Jr,Qr={startTime:"09:00",endTime:"17:00",daysOfWeek:[1,2,3,4,5],display:"inverse-background",classNames:"fc-non-business",groupId:"_businessHours"};function eo(e,t){return Tn(function(e){var t;t=!0===e?[{}]:Array.isArray(e)?e.filter((function(e){return e.daysOfWeek})):"object"==typeof e&&e?[e]:[];return t=t.map((function(e){return r(r({},Qr),e)}))}(e),null,t)}function to(e,t){return e.left>=t.left&&e.left=t.top&&e.top |
",e.querySelector("table").style.height="100px",e.querySelector("div").style.height="100%",document.body.appendChild(e);var t=e.querySelector("div").offsetHeight>0;return document.body.removeChild(e),t}()),Jr}var lo={defs:{},instances:{}},uo=function(){function e(){this.getKeysForEventDefs=$t(this._getKeysForEventDefs),this.splitDateSelection=$t(this._splitDateSpan),this.splitEventStore=$t(this._splitEventStore),this.splitIndividualUi=$t(this._splitIndividualUi),this.splitEventDrag=$t(this._splitInteraction),this.splitEventResize=$t(this._splitInteraction),this.eventUiBuilders={}}return e.prototype.splitProps=function(e){var t=this,n=this.getKeyInfo(e),r=this.getKeysForEventDefs(e.eventStore),o=this.splitDateSelection(e.dateSelection),i=this.splitIndividualUi(e.eventUiBases,r),a=this.splitEventStore(e.eventStore,r),s=this.splitEventDrag(e.eventDrag),l=this.splitEventResize(e.eventResize),u={};for(var c in this.eventUiBuilders=Ct(n,(function(e,n){return t.eventUiBuilders[n]||$t(co)})),n){var d=n[c],p=a[c]||lo,f=this.eventUiBuilders[c];u[c]={businessHours:d.businessHours||e.businessHours,dateSelection:o[c]||null,eventStore:p,eventUiBases:f(e.eventUiBases[""],d.ui,i[c]),eventSelection:p.instances[e.eventSelection]?e.eventSelection:"",eventDrag:s[c]||null,eventResize:l[c]||null}}return u},e.prototype._splitDateSpan=function(e){var t={};if(e)for(var n=0,r=this.getKeysForDateSpan(e);n
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+