serves as a min-height
+ }
+ }, arg.tableColGroupNode, createElement('tbody', {}, 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++) {
+ colNodes.push(createElement("col", { style: {
+ width: colProps.width === 'shrink' ? sanitizeShrinkWidth(shrinkWidth) : (colProps.width || ''),
+ minWidth: colProps.minWidth || ''
+ } }));
+ }
+ }
+ return createElement.apply(void 0, __spreadArrays(['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
+ _this.renderMicroColGroup = memoize(renderMicroColGroup); // yucky to memoize VNodes, but much more efficient for consumers
+ _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);
+ // 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, configI, microColGroupNode));
+ configI++;
+ }
+ while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'body') {
+ bodySectionNodes.push(this.renderSection(currentConfig, configI, microColGroupNode));
+ configI++;
+ }
+ while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'footer') {
+ footSectionNodes.push(this.renderSection(currentConfig, configI, microColGroupNode));
+ configI++;
+ }
+ // 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();
+ return createElement('table', {
+ className: classNames.join(' '),
+ style: { height: props.height }
+ }, Boolean(!isBuggy && headSectionNodes.length) && createElement.apply(void 0, __spreadArrays(['thead', {}], headSectionNodes)), Boolean(!isBuggy && bodySectionNodes.length) && createElement.apply(void 0, __spreadArrays(['tbody', {}], bodySectionNodes)), Boolean(!isBuggy && footSectionNodes.length) && createElement.apply(void 0, __spreadArrays(['tfoot', {}], footSectionNodes)), isBuggy && createElement.apply(void 0, __spreadArrays(['tbody', {}], headSectionNodes, bodySectionNodes, footSectionNodes)));
+ };
+ SimpleScrollGrid.prototype.renderSection = function (sectionConfig, sectionI, microColGroupNode) {
+ if ('outerContent' in sectionConfig) {
+ return (createElement(Fragment, { key: sectionConfig.key }, sectionConfig.outerContent));
+ }
+ return (createElement("tr", { key: sectionConfig.key, className: getSectionClassNames(sectionConfig, this.props.liquid).join(' ') }, this.renderChunkTd(sectionConfig, sectionI, microColGroupNode, sectionConfig.chunk)));
+ };
+ SimpleScrollGrid.prototype.renderChunkTd = function (sectionConfig, sectionI, microColGroupNode, chunkConfig) {
+ 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 content = renderChunkContent(sectionConfig, chunkConfig, {
+ tableColGroupNode: microColGroupNode,
+ tableMinWidth: '',
+ clientWidth: scrollerClientWidths[sectionI] !== undefined ? scrollerClientWidths[sectionI] : null,
+ clientHeight: scrollerClientHeights[sectionI] !== undefined ? scrollerClientHeights[sectionI] : null,
+ expandRows: sectionConfig.expandRows,
+ syncRowHeights: false,
+ rowSyncHeights: [],
+ reportRowHeightChange: function () { }
+ });
+ return (createElement("td", { ref: chunkConfig.elRef },
+ createElement("div", { className: 'fc-scroller-harness' + (isLiquid ? ' fc-scroller-harness-liquid' : '') },
+ createElement(Scroller, { ref: this.scrollerRefs.createRef(sectionI), elRef: this.scrollerElRefs.createRef(sectionI), overflowY: overflowY, overflowX: !props.liquid ? 'visible' : 'hidden' /* natural height? */, maxHeight: sectionConfig.maxHeight, liquid: isLiquid, liquidIsAbsolute: true /* because its within a harness */ }, content))));
+ };
+ SimpleScrollGrid.prototype._handleScrollerEl = function (scrollerEl, key) {
+ var sectionI = parseInt(key, 10);
+ var chunkConfig = this.props.sections[sectionI].chunk;
+ setRef(chunkConfig.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 sectionCnt = this.props.sections.length;
+ var _a = this, scrollerRefs = _a.scrollerRefs, scrollerElRefs = _a.scrollerElRefs;
+ var forceYScrollbars = false;
+ var scrollerClientWidths = {};
+ var scrollerClientHeights = {};
+ for (var sectionI = 0; sectionI < sectionCnt; sectionI++) { // along edge
+ var scroller = scrollerRefs.currentMap[sectionI];
+ if (scroller && scroller.needsYScrolling()) {
+ forceYScrollbars = true;
+ break;
+ }
+ }
+ for (var sectionI = 0; sectionI < sectionCnt; sectionI++) { // along edge
+ var scrollerEl = scrollerElRefs.currentMap[sectionI];
+ if (scrollerEl) {
+ var harnessEl = scrollerEl.parentNode; // TODO: weird way to get this. need harness b/c doesn't include table borders
+ scrollerClientWidths[sectionI] = 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[sectionI] = Math.floor(harnessEl.getBoundingClientRect().height // never has horizontal scrollbars
+ );
+ }
+ }
+ return { forceYScrollbars: forceYScrollbars, scrollerClientWidths: scrollerClientWidths, scrollerClientHeights: scrollerClientHeights };
+ };
+ return SimpleScrollGrid;
+ }(BaseComponent));
+ SimpleScrollGrid.addStateEquality({
+ scrollerClientWidths: isPropsEqual,
+ scrollerClientHeights: isPropsEqual
+ });
+
+ 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, 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)),
+ 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(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")))));
+ }
+ function getSegAnchorAttrs(seg) {
+ var url = seg.eventRange.def.url;
+ return url ? { href: url } : {};
+ }
+
+ 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 DayCellRoot = /** @class */ (function (_super) {
+ __extends(DayCellRoot, _super);
+ function DayCellRoot() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.refineHookProps = memoizeObjArg(refineHookProps);
+ _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));
+ 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 = refineHookProps({
+ 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 refineHookProps(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);
+ }
+
+ function renderFill(fillType) {
+ return (createElement("div", { className: "fc-" + fillType }));
+ }
+ var BgEvent = function (props) { return (createElement(EventRoot, { defaultContent: renderInnerContent$1, seg: props.seg /* uselesss i think */, timeText: '' /* weird */, 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$1(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$1, didMount: options.weekNumberDidMount, willUnmount: options.weekNumberWillUnmount }, props.children));
+ })); };
+ function renderInner$1(innerProps) {
+ return innerProps.text;
+ }
+
+ // exports
+ // --------------------------------------------------------------------------------------------------
+ var version = '5.3.2'; // 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;
+ render(null, _this.el);
+ _this.setClassNames([]);
+ _this.setHeight('');
+ }
+ flushToDom$1();
+ };
+ _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++;
+ }
+ 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$1();
+ };
+ 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 // useCapture
+ );
+ }
+ };
+ 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);
+ }
+ else {
+ 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++;
+ setTimeout(function () {
+ ignoreMouseDepth--;
+ }, config.touchMouseIgnoreWait);
+ }
+ // We want to attach touchmove as early as possible for Safari
+ // ----------------------------------------------------------------------------------------------------
+ function listenerCreated() {
+ if (!(listenerCnt++)) {
+ window.addEventListener('touchmove', onWindowTouchMove, { passive: false });
+ }
+ }
+ function listenerDestroyed() {
+ 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;
+ 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) {
+ if (this.isEnabled) {
+ this.scrollCaches = this.buildCaches();
+ 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 () {
+ return this.queryScrollEls().map(function (el) {
+ if (el === window) {
+ return new WindowScrollGeomCache(false); // false = don't listen to user-generated scrolls
+ }
+ else {
+ return new ElementScrollGeomCache(el, false); // false = don't listen to user-generated scrolls
+ }
+ });
+ };
+ AutoScroller.prototype.queryScrollEls = function () {
+ 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(document.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;
+ // 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.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) // bound with args
+ );
+ };
+ 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 (el) {
+ return new ElementScrollGeomCache(el, true); // listen=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);
+ _this.emitter.trigger('pointerdown', ev); // TODO: fire this before computing processFirstCoord, so listeners can cancel. this gets fired by almost every handler :(
+ }
+ 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 !== document) {
+ 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);
+ var dateProfile = component.context.getCurrentData().dateProfile;
+ if (hit &&
+ (
+ // make sure the hit is within activeRange, meaning it's not a deal cell
+ rangeContainsRange(dateProfile.activeRange, hit.dateSpan.range)) &&
+ (!bestHit || hit.layer > bestHit.layer)) {
+ // 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(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) {
+ dragSelection = joinHitsIntoSelection(_this.hitDragging.initialHit, hit, context.pluginHooks.dateSelectionTransformers);
+ if (!dragSelection || !_this.component.isDateSelectionValid(dragSelection)) {
+ 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(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;
+ }
+ else 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$1(component) :
+ null;
+ 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) {
+ var receivingComponent = hit.component;
+ receivingContext = receivingComponent.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 (!receivingComponent.isInteractionValid(interaction)) {
+ 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 || !document.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.component.context.viewApi }));
+ receivingContext_1.emitter.trigger('eventReceive', __assign(__assign({}, eventAddArg), { draggedEl: ev.subjectEl, view: finalHit.component.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.component.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.component.context.dateEnv, hit0.component === hit1.component ?
+ hit0.component.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$1(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) {
+ mutation = computeMutation(initialHit, hit, ev.subjectEl.classList.contains('fc-event-resizer-start'), eventInstance.range, context.pluginHooks.eventResizeJoinTransforms);
+ }
+ if (mutation) {
+ mutatedRelevantEvents = applyMutationToEventStore(relevantEvents, context.getCurrentData().eventUiBases, mutation, context);
+ interaction.mutatedEvents = mutatedRelevantEvents;
+ if (!_this.component.isInteractionValid(interaction)) {
+ 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, transforms) {
+ var dateEnv = hit0.component.context.dateEnv;
+ var date0 = hit0.dateSpan.range.start;
+ var date1 = hit1.dateSpan.range.start;
+ var delta = diffDates(date0, date1, dateEnv, hit0.component.largeUnit);
+ var props = {};
+ for (var _i = 0, transforms_1 = transforms; _i < transforms_1.length; _i++) {
+ var transform = transforms_1[_i];
+ var res = transform(hit0, hit1);
+ if (res === false) {
+ return null;
+ }
+ else if (res) {
+ __assign(props, res);
+ }
+ }
+ if (isFromStart) {
+ if (dateEnv.add(instanceRange.start, delta) < instanceRange.end) {
+ props.startDelta = delta;
+ return props;
+ }
+ }
+ else {
+ if (dateEnv.add(instanceRange.end, delta) > instanceRange.start) {
+ props.endDelta = delta;
+ return props;
+ }
+ }
+ 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 = pev.origEvent.target;
+ _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 LISTENER_REFINERS = {
+ 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.component.context;
+ if (_this.canDropElOnCalendar(ev.subjectEl, receivingContext)) {
+ droppableEvent = computeEventForDateSpan(hit.dateSpan, _this.dragMeta, receivingContext);
+ interaction.mutatedEvents = eventTupleToStore(droppableEvent);
+ isInvalid = !isInteractionValid(interaction, 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.component.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);
+ }
+ else if (typeof this.suppliedDragMeta === 'function') {
+ return parseDragMeta(this.suppliedDragMeta(subjectEl));
+ }
+ else {
+ 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);
+ }
+ else 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);
+ }
+ 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 ?
+ 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);
+ }
+ ThirdPartyDraggable.prototype.destroy = function () {
+ this.dragging.destroy();
+ };
+ return ThirdPartyDraggable;
+ }());
+
+ var interactionPlugin = createPlugin({
+ componentInteractions: [DateClicking, DateSelecting, EventDragging, EventResizing],
+ calendarInteractions: [UnselectAuto],
+ elementDraggingImpl: FeaturefulElementDragging,
+ listenerRefiners: LISTENER_REFINERS
+ });
+
+ /* 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, 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, colGroups: [{ cols: [{ span: colCnt, minWidth: dayMinWidth }] }], sections: sections }))); }));
+ };
+ return TableView;
+ }(DateComponent));
+
+ function splitSegsByRow(segs, rowCnt) {
+ var byRow = [];
+ for (var i = 0; i < rowCnt; i++) {
+ 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++) {
+ 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++) {
+ byRow[i] = null;
+ }
+ }
+ else {
+ for (var i = 0; i < rowCnt; i++) {
+ 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 DEFAULT_WEEK_NUM_FORMAT = createFormatter({ week: 'narrow' });
+ var TableCell = /** @class */ (function (_super) {
+ __extends(TableCell, _super);
+ function TableCell() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.handleRootEl = function (el) {
+ _this.rootEl = el;
+ setRef(_this.props.elRef, el);
+ };
+ _this.handleMoreLinkClick = function (ev) {
+ var props = _this.props;
+ if (props.onMoreClick) {
+ var allSegs = props.segsByEachCol;
+ var hiddenSegs = allSegs.filter(function (seg) { return props.segIsHidden[seg.eventRange.instance.instanceId]; });
+ props.onMoreClick({
+ date: props.date,
+ allSegs: allSegs,
+ hiddenSegs: hiddenSegs,
+ moreCnt: props.moreCnt,
+ dayEl: _this.rootEl,
+ ev: ev
+ });
+ }
+ };
+ return _this;
+ }
+ TableCell.prototype.render = function () {
+ var _this = this;
+ var _a = this.context, options = _a.options, viewApi = _a.viewApi;
+ var props = this.props;
+ var date = props.date, dateProfile = props.dateProfile;
+ var hookProps = {
+ num: props.moreCnt,
+ text: props.buildMoreLinkText(props.moreCnt),
+ view: viewApi
+ };
+ var navLinkAttrs = options.navLinks
+ ? { 'data-navlink': buildNavLinkData(date, 'week'), tabIndex: 0 }
+ : {};
+ return (createElement(DayCellRoot, { date: date, dateProfile: dateProfile, todayRange: props.todayRange, showDayNumber: props.showDayNumber, extraHookProps: props.extraHookProps, elRef: this.handleRootEl }, function (rootElRef, classNames, rootDataAttrs, isDisabled) { return (createElement("td", __assign({ ref: rootElRef, className: ['fc-daygrid-day'].concat(classNames, props.extraClassNames || []).join(' ') }, rootDataAttrs, props.extraDataAttrs),
+ 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 }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("a", __assign({ ref: rootElRef, className: ['fc-daygrid-week-number'].concat(classNames).join(' ') }, navLinkAttrs), innerContent)); }),
+ !isDisabled &&
+ createElement(TableCellTop, { date: date, dateProfile: dateProfile, showDayNumber: props.showDayNumber, forceDayTop: props.forceDayTop, todayRange: props.todayRange, extraHookProps: props.extraHookProps }),
+ createElement("div", { className: 'fc-daygrid-day-events', ref: props.fgContentElRef, style: { paddingBottom: props.fgPaddingBottom } },
+ props.fgContent,
+ Boolean(props.moreCnt) &&
+ createElement("div", { className: 'fc-daygrid-day-bottom', style: { marginTop: props.moreMarginTop } },
+ createElement(RenderHook, { hookProps: hookProps, classNames: options.moreLinkClassNames, content: options.moreLinkContent, defaultContent: renderMoreLinkInner, didMount: options.moreLinkDidMount, willUnmount: options.moreLinkWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("a", { onClick: _this.handleMoreLinkClick, ref: rootElRef, className: ['fc-daygrid-more-link'].concat(classNames).join(' ') }, innerContent)); }))),
+ createElement("div", { className: 'fc-daygrid-day-bg' }, props.bgContent)))); }));
+ };
+ return TableCell;
+ }(DateComponent));
+ function renderTopInner(props) {
+ return props.dayNumberText;
+ }
+ function renderMoreLinkInner(props) {
+ return props.text;
+ }
+ 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 = this.context.options.navLinks
+ ? { 'data-navlink': buildNavLinkData(props.date), tabIndex: 0 }
+ : {};
+ 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({ className: 'fc-daygrid-day-number' }, navLinkAttrs), innerContent || createElement(Fragment, null, "\u00A0")))); }));
+ };
+ return TableCellTop;
+ }(BaseComponent));
+
+ 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 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$2, 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$1(props.seg)), innerContent)); }));
+ };
+ return TableListItemEvent;
+ }(BaseComponent));
+ function renderInnerContent$2(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"))));
+ }
+ function getSegAnchorAttrs$1(seg) {
+ var url = seg.eventRange.def.url;
+ return url ? { href: url } : {};
+ }
+
+ 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));
+
+ function computeFgSegPlacement(// for one row. TODO: print mode?
+ cellModels, segs, dayMaxEvents, dayMaxEventRows, eventHeights, maxContentHeight, colCnt, eventOrderSpecs) {
+ var colPlacements = []; // if event spans multiple cols, its present in each col
+ var moreCnts = []; // by-col
+ var segIsHidden = {};
+ var segTops = {}; // always populated for each seg
+ var segMarginTops = {}; // simetimes populated for each seg
+ var moreTops = {};
+ var paddingBottoms = {}; // for each cell's inner-wrapper div
+ for (var i = 0; i < colCnt; i++) {
+ colPlacements.push([]);
+ moreCnts.push(0);
+ }
+ segs = sortEventSegs(segs, eventOrderSpecs);
+ for (var _i = 0, segs_1 = segs; _i < segs_1.length; _i++) {
+ var seg = segs_1[_i];
+ var instanceId = seg.eventRange.instance.instanceId;
+ var eventHeight = eventHeights[instanceId + ':' + seg.firstCol];
+ placeSeg(seg, eventHeight || 0); // will keep colPlacements sorted by top
+ }
+ if (dayMaxEvents === true || dayMaxEventRows === true) {
+ limitByMaxHeight(moreCnts, segIsHidden, colPlacements, maxContentHeight); // populates moreCnts/segIsHidden
+ }
+ else if (typeof dayMaxEvents === 'number') {
+ limitByMaxEvents(moreCnts, segIsHidden, colPlacements, dayMaxEvents); // populates moreCnts/segIsHidden
+ }
+ else if (typeof dayMaxEventRows === 'number') {
+ limitByMaxRows(moreCnts, segIsHidden, colPlacements, dayMaxEventRows); // populates moreCnts/segIsHidden
+ }
+ // computes segTops/segMarginTops/moreTops/paddingBottoms
+ for (var col = 0; col < colCnt; col++) {
+ var placements = colPlacements[col];
+ var currentNonAbsBottom = 0;
+ var currentAbsHeight = 0;
+ for (var _a = 0, placements_1 = placements; _a < placements_1.length; _a++) {
+ var placement = placements_1[_a];
+ var seg = placement.seg;
+ if (!segIsHidden[seg.eventRange.instance.instanceId]) {
+ segTops[seg.eventRange.instance.instanceId] = placement.top; // from top of container
+ if (seg.firstCol === seg.lastCol && seg.isStart && seg.isEnd) { // TODO: simpler way? NOT DRY
+ segMarginTops[seg.eventRange.instance.instanceId] =
+ placement.top - currentNonAbsBottom; // from previous seg bottom
+ currentAbsHeight = 0;
+ currentNonAbsBottom = placement.bottom;
+ }
+ else { // multi-col event, abs positioned
+ currentAbsHeight = placement.bottom - currentNonAbsBottom;
+ }
+ }
+ }
+ if (currentAbsHeight) {
+ if (moreCnts[col]) {
+ moreTops[col] = currentAbsHeight;
+ }
+ else {
+ paddingBottoms[col] = currentAbsHeight;
+ }
+ }
+ }
+ function placeSeg(seg, segHeight) {
+ if (!tryPlaceSegAt(seg, segHeight, 0)) {
+ for (var col = seg.firstCol; col <= seg.lastCol; col++) {
+ for (var _i = 0, _a = colPlacements[col]; _i < _a.length; _i++) { // will repeat multi-day segs!!!!!!! bad!!!!!!
+ var placement = _a[_i];
+ if (tryPlaceSegAt(seg, segHeight, placement.bottom)) {
+ return;
+ }
+ }
+ }
+ }
+ }
+ function tryPlaceSegAt(seg, segHeight, top) {
+ if (canPlaceSegAt(seg, segHeight, top)) {
+ for (var col = seg.firstCol; col <= seg.lastCol; col++) {
+ var placements = colPlacements[col];
+ var insertionIndex = 0;
+ while (insertionIndex < placements.length &&
+ top >= placements[insertionIndex].top) {
+ insertionIndex++;
+ }
+ placements.splice(insertionIndex, 0, {
+ seg: seg,
+ top: top,
+ bottom: top + segHeight
+ });
+ }
+ return true;
+ }
+ else {
+ return false;
+ }
+ }
+ function canPlaceSegAt(seg, segHeight, top) {
+ for (var col = seg.firstCol; col <= seg.lastCol; col++) {
+ for (var _i = 0, _a = colPlacements[col]; _i < _a.length; _i++) {
+ var placement = _a[_i];
+ if (top < placement.bottom && top + segHeight > placement.top) { // collide?
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ // what does this do!?
+ for (var instanceIdAndFirstCol in eventHeights) {
+ if (!eventHeights[instanceIdAndFirstCol]) {
+ segIsHidden[instanceIdAndFirstCol.split(':')[0]] = true;
+ }
+ }
+ var segsByFirstCol = colPlacements.map(extractFirstColSegs); // operates on the sorted cols
+ var segsByEachCol = colPlacements.map(function (placements, col) {
+ var segs = extractAllColSegs(placements);
+ segs = resliceDaySegs(segs, cellModels[col].date, col);
+ return segs;
+ });
+ return {
+ segsByFirstCol: segsByFirstCol,
+ segsByEachCol: segsByEachCol,
+ segIsHidden: segIsHidden,
+ segTops: segTops,
+ segMarginTops: segMarginTops,
+ moreCnts: moreCnts,
+ moreTops: moreTops,
+ paddingBottoms: paddingBottoms
+ };
+ }
+ function extractFirstColSegs(oneColPlacements, col) {
+ var segs = [];
+ for (var _i = 0, oneColPlacements_1 = oneColPlacements; _i < oneColPlacements_1.length; _i++) {
+ var placement = oneColPlacements_1[_i];
+ if (placement.seg.firstCol === col) {
+ segs.push(placement.seg);
+ }
+ }
+ return segs;
+ }
+ function extractAllColSegs(oneColPlacements) {
+ var segs = [];
+ for (var _i = 0, oneColPlacements_2 = oneColPlacements; _i < oneColPlacements_2.length; _i++) {
+ var placement = oneColPlacements_2[_i];
+ segs.push(placement.seg);
+ }
+ return segs;
+ }
+ function limitByMaxHeight(hiddenCnts, segIsHidden, colPlacements, maxContentHeight) {
+ limitEvents(hiddenCnts, segIsHidden, colPlacements, true, function (placement) {
+ return placement.bottom <= maxContentHeight;
+ });
+ }
+ function limitByMaxEvents(hiddenCnts, segIsHidden, colPlacements, dayMaxEvents) {
+ limitEvents(hiddenCnts, segIsHidden, colPlacements, false, function (placement, levelIndex) {
+ return levelIndex < dayMaxEvents;
+ });
+ }
+ function limitByMaxRows(hiddenCnts, segIsHidden, colPlacements, dayMaxEventRows) {
+ limitEvents(hiddenCnts, segIsHidden, colPlacements, true, function (placement, levelIndex) {
+ return levelIndex < dayMaxEventRows;
+ });
+ }
+ /*
+ populates the given hiddenCnts/segIsHidden, which are supplied empty.
+ TODO: return them instead
+ */
+ function limitEvents(hiddenCnts, segIsHidden, colPlacements, _moreLinkConsumesLevel, isPlacementInBounds) {
+ var colCnt = hiddenCnts.length;
+ var segIsVisible = {}; // TODO: instead, use segIsHidden with true/false?
+ var visibleColPlacements = []; // will mirror colPlacements
+ for (var col = 0; col < colCnt; col++) {
+ visibleColPlacements.push([]);
+ }
+ for (var col = 0; col < colCnt; col++) {
+ var placements = colPlacements[col];
+ var level = 0;
+ for (var _i = 0, placements_2 = placements; _i < placements_2.length; _i++) {
+ var placement = placements_2[_i];
+ if (isPlacementInBounds(placement, level)) {
+ recordVisible(placement);
+ }
+ else {
+ recordHidden(placement, level, _moreLinkConsumesLevel);
+ }
+ // only considered a level if the seg had height
+ if (placement.top !== placement.bottom) {
+ level++;
+ }
+ }
+ }
+ function recordVisible(placement) {
+ var seg = placement.seg;
+ var instanceId = seg.eventRange.instance.instanceId;
+ if (!segIsVisible[instanceId]) {
+ segIsVisible[instanceId] = true;
+ for (var col = seg.firstCol; col <= seg.lastCol; col++) {
+ visibleColPlacements[col].push(placement);
+ }
+ }
+ }
+ function recordHidden(placement, currentLevel, moreLinkConsumesLevel) {
+ var seg = placement.seg;
+ var instanceId = seg.eventRange.instance.instanceId;
+ if (!segIsHidden[instanceId]) {
+ segIsHidden[instanceId] = true;
+ for (var col = seg.firstCol; col <= seg.lastCol; col++) {
+ var hiddenCnt = ++hiddenCnts[col];
+ if (moreLinkConsumesLevel && hiddenCnt === 1) {
+ var doomedLevel = currentLevel - 1;
+ while (visibleColPlacements[col].length > doomedLevel) {
+ recordHidden(visibleColPlacements[col].pop(), // removes
+ visibleColPlacements[col].length, // will execute after the pop. will be the index of the removed placement
+ false);
+ }
+ }
+ }
+ }
+ }
+ }
+ // Given the events within an array of segment objects, reslice them to be in a single day
+ function resliceDaySegs(segs, dayDate, colIndex) {
+ var dayStart = dayDate;
+ var dayEnd = addDays(dayStart, 1);
+ var dayRange = { start: dayStart, end: dayEnd };
+ var newSegs = [];
+ for (var _i = 0, segs_2 = segs; _i < segs_2.length; _i++) {
+ var seg = segs_2[_i];
+ var eventRange = seg.eventRange;
+ var origRange = eventRange.range;
+ var slicedRange = intersectRanges(origRange, dayRange);
+ if (slicedRange) {
+ newSegs.push(__assign(__assign({}, seg), { firstCol: colIndex, lastCol: colIndex, 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() }));
+ }
+ }
+ return newSegs;
+ }
+
+ 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,
+ segHeights: {}
+ };
+ return _this;
+ }
+ TableRow.prototype.render = function () {
+ var _this = this;
+ var _a = this, props = _a.props, state = _a.state, context = _a.context;
+ 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(props.cells, props.fgEventSegs, props.dayMaxEvents, props.dayMaxEventRows, state.segHeights, state.maxContentHeight, colCnt, context.options.eventOrder), paddingBottoms = _b.paddingBottoms, segsByFirstCol = _b.segsByFirstCol, segsByEachCol = _b.segsByEachCol, segIsHidden = _b.segIsHidden, segTops = _b.segTops, segMarginTops = _b.segMarginTops, moreCnts = _b.moreCnts, moreTops = _b.moreTops;
+ var selectedInstanceHash = // TODO: messy way to compute this
+ (props.eventDrag && props.eventDrag.affectedInstances) ||
+ (props.eventResize && props.eventResize.affectedInstances) ||
+ {};
+ return (createElement("tr", { ref: this.rootElRef },
+ props.renderIntro && props.renderIntro(),
+ props.cells.map(function (cell, col) {
+ var normalFgNodes = _this.renderFgSegs(segsByFirstCol[col], segIsHidden, segTops, segMarginTops, selectedInstanceHash, props.todayRange);
+ var mirrorFgNodes = _this.renderFgSegs(mirrorSegsByCol[col], {}, segTops, // use same tops as real rendering
+ {}, {}, props.todayRange, Boolean(props.eventDrag), Boolean(props.eventResize), false // date-selecting (because mirror is never drawn for date selection)
+ );
+ 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, extraHookProps: cell.extraHookProps, extraDataAttrs: cell.extraDataAttrs, extraClassNames: cell.extraClassNames, moreCnt: moreCnts[col], buildMoreLinkText: props.buildMoreLinkText, onMoreClick: props.onMoreClick, segIsHidden: segIsHidden, moreMarginTop: moreTops[col] /* rename */, segsByEachCol: segsByEachCol[col], fgPaddingBottom: paddingBottoms[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;
+ }
+ else if (props.eventResize && props.eventResize.segs.length) { // messy check
+ return props.eventResize.segs;
+ }
+ else {
+ return props.dateSelectionSegs;
+ }
+ };
+ TableRow.prototype.getMirrorSegs = function () {
+ var props = this.props;
+ if (props.eventResize && props.eventResize.segs.length) { // messy check
+ return props.eventResize.segs;
+ }
+ else {
+ return [];
+ }
+ };
+ TableRow.prototype.renderFgSegs = function (segs, segIsHidden, // does NOT mean display:hidden
+ segTops, segMarginTops, selectedInstanceHash, todayRange, 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 nodes = [];
+ if (framePositions) {
+ for (var _i = 0, segs_1 = segs; _i < segs_1.length; _i++) {
+ var seg = segs_1[_i];
+ var instanceId = seg.eventRange.instance.instanceId;
+ var isMirror = isDragging || isResizing || isDateSelecting;
+ var isSelected = selectedInstanceHash[instanceId];
+ var isInvisible = segIsHidden[instanceId] || isSelected;
+ var isAbsolute = segIsHidden[instanceId] || isMirror || seg.firstCol !== seg.lastCol || !seg.isStart || !seg.isEnd; // TODO: simpler way? NOT DRY
+ var marginTop = void 0;
+ var top_1 = void 0;
+ var left = void 0;
+ var right = void 0;
+ if (isAbsolute) {
+ top_1 = segTops[instanceId];
+ 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];
+ }
+ }
+ else {
+ marginTop = segMarginTops[instanceId];
+ }
+ /*
+ known bug: events that are force to be list-item but span multiple days still take up space in later columns
+ */
+ nodes.push(createElement("div", { className: 'fc-daygrid-event-harness' + (isAbsolute ? ' fc-daygrid-event-harness-abs' : ''), key: instanceId, ref: isMirror ? null : this.segHarnessRefs.createRef(instanceId + ':' + seg.firstCol) /* in print mode when in mult cols, could collide */, style: {
+ visibility: isInvisible ? 'hidden' : '',
+ marginTop: marginTop || '',
+ top: top_1 || '',
+ 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_2 = segs; _i < segs_2.length; _i++) {
+ var seg = segs_2[_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, __spreadArrays([Fragment, {}], nodes));
+ };
+ TableRow.prototype.updateSizing = function (isExternalSizingChange) {
+ var _a = this, props = _a.props, frameElRefs = _a.frameElRefs;
+ if (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 limitByContentHeight = props.dayMaxEvents === true || props.dayMaxEventRows === true;
+ this.setState({
+ segHeights: this.computeSegHeights(),
+ maxContentHeight: limitByContentHeight ? this.computeMaxContentHeight() : null
+ });
+ }
+ };
+ TableRow.prototype.computeSegHeights = function () {
+ return mapHash(this.segHarnessRefs.currentMap, function (eventHarnessEl) { return (eventHarnessEl.getBoundingClientRect().height); });
+ };
+ 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({
+ segHeights: isPropsEqual
+ });
+
+ var PADDING_FROM_VIEWPORT = 10;
+ var SCROLL_DEBOUNCE = 10;
+ var Popover = /** @class */ (function (_super) {
+ __extends(Popover, _super);
+ function Popover() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.repositioner = new DelayedRunner(_this.updateSize.bind(_this));
+ _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) {
+ var onClose = _this.props.onClose;
+ // only hide the popover if the click happened outside the popover
+ if (onClose && !_this.rootEl.contains(ev.target)) {
+ onClose();
+ }
+ };
+ _this.handleDocumentScroll = function () {
+ _this.repositioner.request(SCROLL_DEBOUNCE);
+ };
+ _this.handleCloseClick = function () {
+ var onClose = _this.props.onClose;
+ if (onClose) {
+ onClose();
+ }
+ };
+ return _this;
+ }
+ Popover.prototype.render = function () {
+ var theme = this.context.theme;
+ var props = this.props;
+ var classNames = [
+ 'fc-popover',
+ theme.getClass('popover')
+ ].concat(props.extraClassNames || []);
+ return (createElement("div", __assign({ className: classNames.join(' ') }, props.extraAttrs, { ref: this.handleRootEl }),
+ createElement("div", { className: 'fc-popover-header ' + theme.getClass('popoverHeader') },
+ createElement("span", { className: 'fc-popover-title' }, props.title),
+ createElement("span", { className: 'fc-popover-close ' + theme.getIconClass('close'), onClick: this.handleCloseClick })),
+ createElement("div", { className: 'fc-popover-body ' + theme.getClass('popoverContent') }, props.children)));
+ };
+ Popover.prototype.componentDidMount = function () {
+ document.addEventListener('mousedown', this.handleDocumentMousedown);
+ document.addEventListener('scroll', this.handleDocumentScroll);
+ this.updateSize();
+ };
+ Popover.prototype.componentWillUnmount = function () {
+ document.removeEventListener('mousedown', this.handleDocumentMousedown);
+ document.removeEventListener('scroll', this.handleDocumentScroll);
+ };
+ // TODO: adjust on window resize
+ /*
+ NOTE: the popover is position:fixed, so coordinates are relative to the viewport
+ NOTE: the PARENT calls this as well, on window resize. we would have wanted to use the repositioner,
+ but need to ensure that all other components have updated size first (for alignmentEl)
+ */
+ Popover.prototype.updateSize = function () {
+ var _a = this.props, alignmentEl = _a.alignmentEl, topAlignmentEl = _a.topAlignmentEl;
+ var rootEl = this.rootEl;
+ if (!rootEl) {
+ return; // not sure why this was null, but we shouldn't let external components call updateSize() anyway
+ }
+ var dims = rootEl.getBoundingClientRect(); // only used for width,height
+ var alignment = alignmentEl.getBoundingClientRect();
+ var top = topAlignmentEl ? topAlignmentEl.getBoundingClientRect().top : alignment.top;
+ top = Math.min(top, window.innerHeight - dims.height - PADDING_FROM_VIEWPORT);
+ top = Math.max(top, PADDING_FROM_VIEWPORT);
+ var left;
+ if (this.context.isRtl) {
+ left = alignment.right - dims.width;
+ }
+ else {
+ left = alignment.left;
+ }
+ left = Math.min(left, window.innerWidth - dims.width - PADDING_FROM_VIEWPORT);
+ left = Math.max(left, PADDING_FROM_VIEWPORT);
+ applyStyle(rootEl, { top: top, left: left });
+ };
+ return Popover;
+ }(BaseComponent));
+
+ var MorePopover = /** @class */ (function (_super) {
+ __extends(MorePopover, _super);
+ function MorePopover() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.handlePopoverEl = function (popoverEl) {
+ _this.popoverEl = popoverEl;
+ if (popoverEl) {
+ _this.context.registerInteractiveComponent(_this, {
+ el: popoverEl,
+ 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 date = props.date, hiddenInstances = props.hiddenInstances, todayRange = props.todayRange, dateProfile = props.dateProfile, selectedInstanceId = props.selectedInstanceId;
+ var title = dateEnv.format(date, options.dayPopoverFormat);
+ return (createElement(DayCellRoot, { date: date, dateProfile: dateProfile, todayRange: todayRange, elRef: this.handlePopoverEl }, function (rootElRef, dayClassNames, dataAttrs) { return (createElement(Popover, { elRef: rootElRef, title: title, extraClassNames: ['fc-more-popover'].concat(dayClassNames), extraAttrs: dataAttrs, onClose: props.onCloseClick, alignmentEl: props.alignmentEl, topAlignmentEl: props.topAlignmentEl },
+ createElement(DayCellContent, { date: date, dateProfile: dateProfile, todayRange: todayRange }, function (innerElRef, innerContent) { return (innerContent &&
+ createElement("div", { className: 'fc-more-popover-misc', ref: innerElRef }, innerContent)); }),
+ props.segs.map(function (seg) {
+ var instanceId = seg.eventRange.instance.instanceId;
+ return (createElement("div", { className: 'fc-daygrid-event-harness', key: instanceId, style: {
+ visibility: hiddenInstances[instanceId] ? 'hidden' : ''
+ } }, hasListItemDisplay(seg) ?
+ createElement(TableListItemEvent, __assign({ seg: seg, isDragging: false, isSelected: instanceId === selectedInstanceId, defaultDisplayEventEnd: false }, getSegMeta(seg, todayRange))) :
+ createElement(TableBlockEvent, __assign({ seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: instanceId === selectedInstanceId, defaultDisplayEventEnd: false }, getSegMeta(seg, todayRange)))));
+ }))); }));
+ };
+ MorePopover.prototype.queryHit = function (positionLeft, positionTop, elWidth, elHeight) {
+ var date = this.props.date;
+ if (positionLeft < elWidth && positionTop < elHeight) {
+ return {
+ component: this,
+ dateSpan: {
+ allDay: true,
+ range: { start: date, end: addDays(date, 1) }
+ },
+ dayEl: this.popoverEl,
+ rect: {
+ left: 0,
+ top: 0,
+ right: elWidth,
+ bottom: elHeight
+ },
+ layer: 1
+ };
+ }
+ };
+ MorePopover.prototype.isPopover = function () {
+ return true; // gross
+ };
+ return MorePopover;
+ }(DateComponent));
+
+ 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.buildBuildMoreLinkText = memoize(buildBuildMoreLinkText);
+ _this.rowRefs = new RefMap();
+ _this.state = {
+ morePopoverState: null
+ };
+ _this.handleRootEl = function (rootEl) {
+ _this.rootEl = rootEl;
+ setRef(_this.props.elRef, rootEl);
+ };
+ _this.handleMoreLinkClick = function (arg) {
+ var context = _this.context;
+ var dateEnv = context.dateEnv;
+ var clickOption = context.options.moreLinkClick;
+ function segForPublic(seg) {
+ var _a = seg.eventRange, def = _a.def, instance = _a.instance, range = _a.range;
+ return {
+ event: new EventApi(context, def, instance),
+ start: dateEnv.toDate(range.start),
+ end: dateEnv.toDate(range.end),
+ isStart: seg.isStart,
+ isEnd: seg.isEnd
+ };
+ }
+ if (typeof clickOption === 'function') {
+ clickOption = clickOption({
+ date: dateEnv.toDate(arg.date),
+ allDay: true,
+ allSegs: arg.allSegs.map(segForPublic),
+ hiddenSegs: arg.hiddenSegs.map(segForPublic),
+ jsEvent: arg.ev,
+ view: context.viewApi
+ }); // hack to handle void
+ }
+ if (!clickOption || clickOption === 'popover') {
+ _this.setState({
+ morePopoverState: __assign(__assign({}, arg), { currentFgEventSegs: _this.props.fgEventSegs })
+ });
+ }
+ else if (typeof clickOption === 'string') { // a view name
+ context.calendarApi.zoomTo(arg.date, clickOption);
+ }
+ };
+ _this.handleMorePopoverClose = function () {
+ _this.setState({
+ morePopoverState: null
+ });
+ };
+ 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 morePopoverState = this.state.morePopoverState;
+ 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 buildMoreLinkText = this.buildBuildMoreLinkText(this.context.options.moreLinkText);
+ 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", { className: 'fc-scrollgrid-sync-table', style: {
+ width: props.clientWidth,
+ minWidth: props.tableMinWidth,
+ height: expandRows ? props.clientHeight : ''
+ } },
+ props.colGroupNode,
+ createElement("tbody", null, 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, buildMoreLinkText: buildMoreLinkText, onMoreClick: _this.handleMoreLinkClick })); }))),
+ (!props.forPrint && morePopoverState && morePopoverState.currentFgEventSegs === props.fgEventSegs) && // clear popover on event mod
+ createElement(MorePopover, { date: morePopoverState.date, dateProfile: dateProfile, segs: morePopoverState.allSegs, alignmentEl: morePopoverState.dayEl, topAlignmentEl: rowCnt === 1 ? props.headerAlignElRef.current : null, onCloseClick: _this.handleMorePopoverClose, selectedInstanceId: props.eventSelection, hiddenInstances: // yuck
+ (props.eventDrag ? props.eventDrag.affectedInstances : null) ||
+ (props.eventResize ? props.eventResize.affectedInstances : null) ||
+ {}, todayRange: todayRange }))); })));
+ };
+ // 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 // vertical
+ );
+ this.colPositions = new PositionCache(this.rootEl, this.rowRefs.currentMap[0].getCellEls(), // cell els in first row
+ true, // horizontal
+ false);
+ };
+ Table.prototype.positionToHit = function (leftPosition, topPosition) {
+ var _a = this, colPositions = _a.colPositions, rowPositions = _a.rowPositions;
+ var col = colPositions.leftToIndex(leftPosition);
+ var row = rowPositions.topToIndex(topPosition);
+ if (row != null && col != null) {
+ return {
+ row: row,
+ col: col,
+ dateSpan: {
+ range: this.getCellRange(row, col),
+ allDay: true
+ },
+ dayEl: this.getCellEl(row, col),
+ relativeRect: {
+ left: colPositions.lefts[col],
+ right: colPositions.rights[col],
+ top: rowPositions.tops[row],
+ bottom: rowPositions.bottoms[row]
+ }
+ };
+ }
+ };
+ 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 buildBuildMoreLinkText(moreLinkTextInput) {
+ if (typeof moreLinkTextInput === 'function') {
+ return moreLinkTextInput;
+ }
+ else {
+ return function (num) {
+ return "+" + num + " " + moreLinkTextInput;
+ };
+ }
+ }
+ function isSegAllDay(seg) {
+ return seg.eventRange.def.allDay;
+ }
+
+ 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();
+ _this.handleRootEl = function (rootEl) {
+ if (rootEl) {
+ _this.context.registerInteractiveComponent(_this, { el: rootEl });
+ }
+ else {
+ _this.context.unregisterInteractiveComponent(_this);
+ }
+ };
+ return _this;
+ }
+ DayTable.prototype.render = function () {
+ var _a = this, props = _a.props, context = _a.context;
+ return (createElement(Table, __assign({ ref: this.tableRef, elRef: this.handleRootEl }, 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 })));
+ };
+ DayTable.prototype.prepareHits = function () {
+ this.tableRef.current.prepareHits();
+ };
+ DayTable.prototype.queryHit = function (positionLeft, positionTop) {
+ var rawHit = this.tableRef.current.positionToHit(positionLeft, positionTop);
+ if (rawHit) {
+ return {
+ component: this,
+ dateSpan: rawHit.dateSpan,
+ dayEl: rawHit.dayEl,
+ rect: {
+ left: rawHit.relativeRect.left,
+ right: rawHit.relativeRect.right,
+ top: rawHit.relativeRect.top,
+ bottom: rawHit.relativeRect.bottom
+ },
+ layer: 0
+ };
+ }
+ };
+ return DayTable;
+ }(DateComponent));
+ 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 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 OPTION_REFINERS = {
+ moreLinkClick: identity,
+ moreLinkClassNames: identity,
+ moreLinkContent: identity,
+ moreLinkDidMount: identity,
+ moreLinkWillUnmount: identity,
+ };
+
+ var dayGridPlugin = createPlugin({
+ initialView: 'dayGridMonth',
+ optionRefiners: OPTION_REFINERS,
+ 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'];
+ }
+ else {
+ return ['timed'];
+ }
+ };
+ AllDaySplitter.prototype.getKeysForEventDef = function (eventDef) {
+ if (!eventDef.allDay) {
+ return ['timed'];
+ }
+ else if (hasBgRendering(eventDef)) {
+ return ['timed', 'allDay'];
+ }
+ else {
+ return ['allDay'];
+ }
+ };
+ return AllDaySplitter;
+ }(Splitter));
+
+ var TimeColsSlatsCoords = /** @class */ (function () {
+ function TimeColsSlatsCoords(positions, dateProfile, slatMetas) {
+ this.positions = positions;
+ this.dateProfile = dateProfile;
+ this.slatMetas = slatMetas;
+ }
+ 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));
+ }
+ }
+ };
+ // 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, slatMetas = _a.slatMetas;
+ var len = positions.els.length;
+ var slotDurationMs = slatMetas[1].date.valueOf() - slatMetas[0].date.valueOf(); // we assume dates are uniform
+ var slatCoverage = (duration.milliseconds - asRoughMs(dateProfile.slotMinTime)) / slotDurationMs; // floating-point value of # of slots covered
+ 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;
+ }());
+
+ // potential nice values for the slot-duration and interval-duration
+ // from largest to smallest
+ var STOCK_SUB_DURATIONS = [
+ { hours: 1 },
+ { minutes: 30 },
+ { minutes: 15 },
+ { seconds: 30 },
+ { seconds: 15 }
+ ];
+ /*
+ 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", { className: 'fc-timegrid-slots', ref: this.rootElRef },
+ createElement("table", { 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 props = this.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 // vertical
+ ), this.props.dateProfile, props.slatMetas));
+ }
+ }
+ };
+ return TimeColsSlats;
+ }(BaseComponent));
+ function collectSlatEls(elMap, slatMetas) {
+ return slatMetas.map(function (slatMeta) { return elMap[slatMeta.key]; });
+ }
+ 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));
+ 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 }));
+ }
+ else {
+ 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;
+ }
+ 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.length - 1; i >= 0; i--) {
+ labelInterval = createDuration(STOCK_SUB_DURATIONS[i]);
+ slotsPerLabel = wholeDivideDurations(labelInterval, slotDuration);
+ if (slotsPerLabel !== null && slotsPerLabel > 1) {
+ return labelInterval;
+ }
+ }
+ return slotDuration; // fall back
+ }
+
+ var DEFAULT_WEEK_NUM_FORMAT$1 = 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 (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 = (options.navLinks && dayCnt === 1) // only do in day views (to avoid doing in week views that dont need it)
+ ? { 'data-navlink': buildNavLinkData(range.start, 'week'), tabIndex: 0 }
+ : {};
+ if (options.weekNumbers) {
+ return (createElement(WeekNumberRoot, { date: range.start, defaultFormat: DEFAULT_WEEK_NUM_FORMAT$1 }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("th", { ref: rootElRef, 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", { 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, didMount: options.allDayDidMount, willUnmount: options.allDayWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("td", { ref: rootElRef, 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", { 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, cols: [{ width: 'shrink' }], sections: sections }))); }));
+ };
+ TimeColsView.prototype.renderHScrollLayout = function (headerRowContent, allDayContent, timeContent, colCnt, dayMinWidth, slatMetas, slatCoords // yuck
+ ) {
+ 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", null, _this.renderHeadAxis(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", null, _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", { 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) {
+ // TODO: make this now-indicator arrow more DRY with TimeColsContent
+ return (createElement("div", { className: 'fc-timegrid-axis-chunk' },
+ createElement("table", { 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, 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(hookProps) {
+ return hookProps.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));
+
+ function splitSegsByCol(segs, colCnt) {
+ var segsByCol = [];
+ var i;
+ for (i = 0; i < colCnt; i++) {
+ segsByCol.push([]);
+ }
+ if (segs) {
+ for (i = 0; i < segs.length; i++) {
+ segsByCol[segs[i].col].push(segs[i]);
+ }
+ }
+ return segsByCol;
+ }
+ function splitInteractionByCol(ui, colCnt) {
+ var byRow = [];
+ if (!ui) {
+ for (var i = 0; i < colCnt; i++) {
+ byRow[i] = null;
+ }
+ }
+ else {
+ for (var i = 0; i < colCnt; i++) {
+ 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;
+ }
+
+ // UNFORTUNATELY, assigns results to the top/bottom/level/forwardCoord/backwardCoord props of the actual segs.
+ // TODO: return hash (by instanceId) of results
+ function computeSegCoords(segs, dayDate, slatCoords, eventMinHeight, eventOrderSpecs) {
+ computeSegVerticals(segs, dayDate, slatCoords, eventMinHeight);
+ return computeSegHorizontals(segs, eventOrderSpecs); // requires top/bottom from computeSegVerticals
+ }
+ // For each segment in an array, computes and assigns its top and bottom properties
+ function computeSegVerticals(segs, dayDate, slatCoords, eventMinHeight) {
+ for (var _i = 0, segs_1 = segs; _i < segs_1.length; _i++) {
+ var seg = segs_1[_i];
+ seg.top = slatCoords.computeDateTop(seg.start, dayDate);
+ seg.bottom = Math.max(seg.top + (eventMinHeight || 0), // yuck
+ slatCoords.computeDateTop(seg.end, dayDate));
+ }
+ }
+ // Given an array of segments that are all in the same column, sets the backwardCoord and forwardCoord on each.
+ // Assumed the segs are already ordered.
+ // NOTE: Also reorders the given array by date!
+ function computeSegHorizontals(segs, eventOrderSpecs) {
+ // IMPORTANT TO CLEAR OLD RESULTS :(
+ for (var _i = 0, segs_2 = segs; _i < segs_2.length; _i++) {
+ var seg = segs_2[_i];
+ seg.level = null;
+ seg.forwardCoord = null;
+ seg.backwardCoord = null;
+ seg.forwardPressure = null;
+ }
+ segs = sortEventSegs(segs, eventOrderSpecs);
+ var level0;
+ var levels = buildSlotSegLevels(segs);
+ computeForwardSlotSegs(levels);
+ if ((level0 = levels[0])) {
+ for (var _a = 0, level0_1 = level0; _a < level0_1.length; _a++) {
+ var seg = level0_1[_a];
+ computeSlotSegPressures(seg);
+ }
+ for (var _b = 0, level0_2 = level0; _b < level0_2.length; _b++) {
+ var seg = level0_2[_b];
+ computeSegForwardBack(seg, 0, 0, eventOrderSpecs);
+ }
+ }
+ return segs;
+ }
+ // Builds an array of segments "levels". The first level will be the leftmost tier of segments if the calendar is
+ // left-to-right, or the rightmost if the calendar is right-to-left. Assumes the segments are already ordered by date.
+ function buildSlotSegLevels(segs) {
+ var levels = [];
+ var i;
+ var seg;
+ var j;
+ for (i = 0; i < segs.length; i++) {
+ seg = segs[i];
+ // go through all the levels and stop on the first level where there are no collisions
+ for (j = 0; j < levels.length; j++) {
+ if (!computeSlotSegCollisions(seg, levels[j]).length) {
+ break;
+ }
+ }
+ seg.level = j;
+ (levels[j] || (levels[j] = [])).push(seg);
+ }
+ return levels;
+ }
+ // Find all the segments in `otherSegs` that vertically collide with `seg`.
+ // Append into an optionally-supplied `results` array and return.
+ function computeSlotSegCollisions(seg, otherSegs, results) {
+ if (results === void 0) { results = []; }
+ for (var i = 0; i < otherSegs.length; i++) {
+ if (isSlotSegCollision(seg, otherSegs[i])) {
+ results.push(otherSegs[i]);
+ }
+ }
+ return results;
+ }
+ // Do these segments occupy the same vertical space?
+ function isSlotSegCollision(seg1, seg2) {
+ return seg1.bottom > seg2.top && seg1.top < seg2.bottom;
+ }
+ // For every segment, figure out the other segments that are in subsequent
+ // levels that also occupy the same vertical space. Accumulate in seg.forwardSegs
+ function computeForwardSlotSegs(levels) {
+ var i;
+ var level;
+ var j;
+ var seg;
+ var k;
+ for (i = 0; i < levels.length; i++) {
+ level = levels[i];
+ for (j = 0; j < level.length; j++) {
+ seg = level[j];
+ seg.forwardSegs = [];
+ for (k = i + 1; k < levels.length; k++) {
+ computeSlotSegCollisions(seg, levels[k], seg.forwardSegs);
+ }
+ }
+ }
+ }
+ // Figure out which path forward (via seg.forwardSegs) results in the longest path until
+ // the furthest edge is reached. The number of segments in this path will be seg.forwardPressure
+ function computeSlotSegPressures(seg) {
+ var forwardSegs = seg.forwardSegs;
+ var forwardPressure = 0;
+ var i;
+ var forwardSeg;
+ if (seg.forwardPressure == null) { // not already computed
+ for (i = 0; i < forwardSegs.length; i++) {
+ forwardSeg = forwardSegs[i];
+ // figure out the child's maximum forward path
+ computeSlotSegPressures(forwardSeg);
+ // either use the existing maximum, or use the child's forward pressure
+ // plus one (for the forwardSeg itself)
+ forwardPressure = Math.max(forwardPressure, 1 + forwardSeg.forwardPressure);
+ }
+ seg.forwardPressure = forwardPressure;
+ }
+ }
+ // Calculate seg.forwardCoord and seg.backwardCoord for the segment, where both values range
+ // from 0 to 1. If the calendar is left-to-right, the seg.backwardCoord maps to "left" and
+ // seg.forwardCoord maps to "right" (via percentage). Vice-versa if the calendar is right-to-left.
+ //
+ // The segment might be part of a "series", which means consecutive segments with the same pressure
+ // who's width is unknown until an edge has been hit. `seriesBackwardPressure` is the number of
+ // segments behind this one in the current series, and `seriesBackwardCoord` is the starting
+ // coordinate of the first segment in the series.
+ function computeSegForwardBack(seg, seriesBackwardPressure, seriesBackwardCoord, eventOrderSpecs) {
+ var forwardSegs = seg.forwardSegs;
+ var i;
+ if (seg.forwardCoord == null) { // not already computed
+ if (!forwardSegs.length) {
+ // if there are no forward segments, this segment should butt up against the edge
+ seg.forwardCoord = 1;
+ }
+ else {
+ // sort highest pressure first
+ sortForwardSegs(forwardSegs, eventOrderSpecs);
+ // this segment's forwardCoord will be calculated from the backwardCoord of the
+ // highest-pressure forward segment.
+ computeSegForwardBack(forwardSegs[0], seriesBackwardPressure + 1, seriesBackwardCoord, eventOrderSpecs);
+ seg.forwardCoord = forwardSegs[0].backwardCoord;
+ }
+ // calculate the backwardCoord from the forwardCoord. consider the series
+ seg.backwardCoord = seg.forwardCoord -
+ (seg.forwardCoord - seriesBackwardCoord) / // available width for series
+ (seriesBackwardPressure + 1); // # of segments in the series
+ // use this segment's coordinates to computed the coordinates of the less-pressurized
+ // forward segments
+ for (i = 0; i < forwardSegs.length; i++) {
+ computeSegForwardBack(forwardSegs[i], 0, seg.forwardCoord, eventOrderSpecs);
+ }
+ }
+ }
+ function sortForwardSegs(forwardSegs, eventOrderSpecs) {
+ var objs = forwardSegs.map(buildTimeGridSegCompareObj);
+ var specs = [
+ // put higher-pressure first
+ { field: 'forwardPressure', order: -1 },
+ // put segments that are closer to initial edge first (and favor ones with no coords yet)
+ { field: 'backwardCoord', order: 1 }
+ ].concat(eventOrderSpecs);
+ objs.sort(function (obj0, obj1) {
+ return compareByFieldSpecs(obj0, obj1, specs);
+ });
+ return objs.map(function (c) {
+ return c._seg;
+ });
+ }
+ function buildTimeGridSegCompareObj(seg) {
+ var obj = buildSegCompareObj(seg);
+ obj.forwardPressure = seg.forwardPressure;
+ obj.backwardCoord = seg.backwardCoord;
+ return obj;
+ }
+
+ var DEFAULT_TIME_FORMAT = 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.isCondensed) {
+ classNames.push('fc-timegrid-event-condensed');
+ }
+ return (createElement(StandardEvent, __assign({}, this.props, { defaultTimeFormat: DEFAULT_TIME_FORMAT, extraClassNames: classNames })));
+ };
+ return TimeColEvent;
+ }(BaseComponent));
+
+ config.timeGridEventCondensedHeight = 30;
+ var TimeCol = /** @class */ (function (_super) {
+ __extends(TimeCol, _super);
+ function TimeCol() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ 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) ||
+ {};
+ 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, 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(props.fgEventSegs, interactionAffectedInstances)),
+ createElement("div", { className: 'fc-timegrid-col-events' }, _this.renderFgSegs(mirrorSegs, {}, Boolean(props.eventDrag), Boolean(props.eventResize), Boolean(isSelectMirror)
+ // TODO: pass in left/right instead of using only computeSegTopBottomCss
+ )),
+ 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 (segs, segIsInvisible, isDragging, isResizing, isDateSelecting) {
+ var props = this.props;
+ if (props.forPrint) {
+ return this.renderPrintFgSegs(segs);
+ }
+ else if (props.slatCoords) {
+ return this.renderPositionedFgSegs(segs, segIsInvisible, isDragging, isResizing, isDateSelecting);
+ }
+ };
+ TimeCol.prototype.renderPrintFgSegs = function (segs) {
+ var _a = this, props = _a.props, context = _a.context;
+ // not DRY
+ segs = sortEventSegs(segs, context.options.eventOrder);
+ return segs.map(function (seg) { return (createElement("div", { className: 'fc-timegrid-event-harness', key: seg.eventRange.instance.instanceId },
+ createElement(TimeColEvent, __assign({ seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, isCondensed: false }, getSegMeta(seg, props.todayRange, props.nowDate))))); });
+ };
+ TimeCol.prototype.renderPositionedFgSegs = function (segs, segIsInvisible, isDragging, isResizing, isDateSelecting) {
+ var _this = this;
+ var _a = this, context = _a.context, props = _a.props;
+ // assigns TO THE SEGS THEMSELVES
+ // also, receives resorted array
+ segs = computeSegCoords(segs, props.date, props.slatCoords, context.options.eventMinHeight, context.options.eventOrder);
+ return segs.map(function (seg) {
+ var instanceId = seg.eventRange.instance.instanceId;
+ var isMirror = isDragging || isResizing || isDateSelecting;
+ var positionCss = isMirror ? __assign({ left: 0, right: 0 }, _this.computeSegTopBottomCss(seg)) :
+ _this.computeFgSegPositionCss(seg);
+ return (createElement("div", { className: 'fc-timegrid-event-harness' + (seg.level > 0 ? ' fc-timegrid-event-harness-inset' : ''), key: instanceId, style: __assign({ visibility: segIsInvisible[instanceId] ? 'hidden' : '' }, positionCss) },
+ createElement(TimeColEvent, __assign({ seg: seg, isDragging: isDragging, isResizing: isResizing, isDateSelecting: isDateSelecting, isSelected: instanceId === props.eventSelection, isCondensed: (seg.bottom - seg.top) < config.timeGridEventCondensedHeight }, getSegMeta(seg, props.todayRange, props.nowDate)))));
+ });
+ };
+ TimeCol.prototype.renderFillSegs = function (segs, fillType) {
+ var _this = this;
+ var _a = this, context = _a.context, props = _a.props;
+ if (!props.slatCoords) {
+ return;
+ }
+ // BAD: assigns TO THE SEGS THEMSELVES
+ computeSegVerticals(segs, props.date, props.slatCoords, context.options.eventMinHeight);
+ var children = segs.map(function (seg) { return (createElement("div", { key: buildEventRangeKey(seg.eventRange), className: 'fc-timegrid-bg-harness', style: _this.computeSegTopBottomCss(seg) }, 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;
+ }
+ return segs.map(function (seg, i) { return (createElement(NowIndicatorRoot, { isAxis: false, date: date, key: i /* key doesn't matter. will only ever be one */ }, 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.computeFgSegPositionCss = function (seg) {
+ var _a = this.context, isRtl = _a.isRtl, options = _a.options;
+ var shouldOverlap = options.slotEventOverlap;
+ var backwardCoord = seg.backwardCoord; // the left side if LTR. the right side if RTL. floating-point
+ var forwardCoord = seg.forwardCoord; // 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)
+ forwardCoord = Math.min(1, backwardCoord + (forwardCoord - backwardCoord) * 2);
+ }
+ if (isRtl) {
+ left = 1 - forwardCoord;
+ right = backwardCoord;
+ }
+ else {
+ left = backwardCoord;
+ right = 1 - forwardCoord;
+ }
+ var props = {
+ zIndex: seg.level + 1,
+ left: left * 100 + '%',
+ right: right * 100 + '%'
+ };
+ if (shouldOverlap && seg.forwardPressure) {
+ // 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 __assign(__assign({}, props), this.computeSegTopBottomCss(seg));
+ };
+ TimeCol.prototype.computeSegTopBottomCss = function (seg) {
+ return {
+ top: seg.top,
+ bottom: -seg.bottom
+ };
+ };
+ return TimeCol;
+ }(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 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", { style: {
+ minWidth: props.tableMinWidth,
+ width: props.clientWidth
+ } },
+ props.tableColGroupNode,
+ createElement("tbody", null,
+ createElement("tr", null,
+ props.axis &&
+ createElement("td", { 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, 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(this.cellElRefs.currentMap, props.cells), true, // horizontal
+ false));
+ }
+ };
+ return TimeColsContent;
+ }(BaseComponent));
+ function collectCellEls(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.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++;
+ } // to overcome top border that slots beyond the first have. looks better
+ onScrollTopRequest(top_1);
+ }
+ return true;
+ }
+ };
+ _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: props.rootElRef, 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.positionToHit = 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 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 {
+ col: colIndex,
+ dateSpan: {
+ range: { start: start, end: end },
+ allDay: false
+ },
+ dayEl: colCoords.els[colIndex],
+ relativeRect: {
+ left: colCoords.lefts[colIndex],
+ right: colCoords.rights[colIndex],
+ top: slatTop,
+ bottom: slatTop + slatHeight
+ }
+ };
+ }
+ };
+ return TimeCols;
+ }(BaseComponent));
+ 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 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();
+ _this.handleRootEl = function (rootEl) {
+ if (rootEl) {
+ _this.context.registerInteractiveComponent(_this, { el: rootEl });
+ }
+ else {
+ _this.context.unregisterInteractiveComponent(_this);
+ }
+ };
+ 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, rootElRef: _this.handleRootEl }, _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 }))); }));
+ };
+ DayTimeCols.prototype.queryHit = function (positionLeft, positionTop) {
+ var rawHit = this.timeColsRef.current.positionToHit(positionLeft, positionTop);
+ if (rawHit) {
+ return {
+ component: this,
+ dateSpan: rawHit.dateSpan,
+ dayEl: rawHit.dayEl,
+ rect: {
+ left: rawHit.relativeRect.left,
+ right: rawHit.relativeRect.right,
+ top: rawHit.relativeRect.top,
+ bottom: rawHit.relativeRect.bottom
+ },
+ layer: 0
+ };
+ }
+ };
+ 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;
+ }
+ 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++) {
+ 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 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$1 = {
+ allDaySlot: Boolean
+ };
+
+ var timeGridPlugin = createPlugin({
+ initialView: 'timeGridWeek',
+ optionRefiners: OPTION_REFINERS$1,
+ 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() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ListViewHeaderRow.prototype.render = function () {
+ var _a = this.props, dayDate = _a.dayDate, todayRange = _a.todayRange;
+ var _b = this.context, theme = _b.theme, dateEnv = _b.dateEnv, options = _b.options, viewApi = _b.viewApi;
+ var dayMeta = getDateMeta(dayDate, todayRange);
+ var text = options.listDayFormat ? dateEnv.format(dayDate, options.listDayFormat) : ''; // will ever be falsy?
+ var sideText = options.listDaySideFormat ? dateEnv.format(dayDate, options.listDaySideFormat) : ''; // will ever be falsy? also, BAD NAME "alt"
+ var navLinkData = options.navLinks
+ ? buildNavLinkData(dayDate)
+ : null;
+ var hookProps = __assign({ date: dateEnv.toDate(dayDate), view: viewApi, text: text,
+ sideText: sideText,
+ navLinkData: navLinkData }, 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$4, 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", { colSpan: 3 },
+ createElement("div", { className: 'fc-list-day-cushion ' + theme.getClass('tableCellShaded'), ref: innerElRef }, innerContent)))); }));
+ };
+ return ListViewHeaderRow;
+ }(BaseComponent));
+ function renderInnerContent$4(props) {
+ var navLinkAttrs = props.navLinkData // is there a type for this?
+ ? { 'data-navlink': props.navLinkData, tabIndex: 0 }
+ : {};
+ return (createElement(Fragment, null,
+ props.text &&
+ createElement("a", __assign({ className: 'fc-list-day-text' }, navLinkAttrs), props.text),
+ props.sideText &&
+ createElement("a", __assign({ className: 'fc-list-day-side-text' }, navLinkAttrs), 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;
+ 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: renderEventInnerContent, 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),
+ createElement("td", { className: 'fc-list-event-graphic' },
+ createElement("span", { className: 'fc-list-event-dot', style: { borderColor: hookProps.borderColor || hookProps.backgroundColor } })),
+ createElement("td", { className: 'fc-list-event-title', ref: innerElRef }, innerContent))); }));
+ };
+ return ListViewEventRow;
+ }(BaseComponent));
+ function renderEventInnerContent(props) {
+ var event = props.event;
+ var url = event.url;
+ var anchorAttrs = url ? { href: url } : {};
+ return (createElement("a", __assign({}, anchorAttrs), event.title));
+ }
+ function buildTimeContent(seg, timeFormat, context) {
+ 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$1, didMount: options.allDayDidMount, willUnmount: options.allDayWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement("td", { className: ['fc-list-event-time'].concat(classNames).join(' '), ref: rootElRef }, innerContent)); }));
+ }
+ else {
+ return (createElement("td", { className: 'fc-list-event-time' }, timeText));
+ }
+ }
+ return null;
+ }
+ function renderAllDayInner$1(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.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 segsByDay = groupSegsByDay(allSegs); // sparse array
+ return (createElement(NowTimer, { unit: 'day' }, function (nowDate, todayRange) {
+ var innerNodes = [];
+ for (var dayIndex = 0; dayIndex < segsByDay.length; dayIndex++) {
+ var daySegs = segsByDay[dayIndex];
+ if (daySegs) { // sparse array, so might be undefined
+ var dayStr = dayDates[dayIndex].toISOString();
+ // append a day header
+ innerNodes.push(createElement(ListViewHeaderRow, { key: dayStr, 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 }, getSegMeta(seg, todayRange, nowDate))));
+ }
+ }
+ }
+ return (createElement("table", { className: 'fc-list-table ' + theme.getClass('table') },
+ 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++) {
+ 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++) {
+ seg = segs[i];
+ (segsByDay[seg.dayIndex] || (segsByDay[seg.dayIndex] = []))
+ .push(seg);
+ }
+ return segsByDay;
+ }
+
+ var OPTION_REFINERS$2 = {
+ 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$2,
+ 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$3 = {
+ googleCalendarApiKey: String
+ };
+
+ var EVENT_SOURCE_REFINERS$1 = {
+ googleCalendarApiKey: String,
+ googleCalendarId: String,
+ googleCalendarApiBase: String,
+ extraParams: identity
+ };
+
+ // TODO: expose somehow
+ var API_BASE = 'https://www.googleapis.com/calendar/v3/calendars';
+ var eventSourceDef$3 = {
+ 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;
+ }
+ else if ((match = /^https:\/\/www.googleapis.com\/calendar\/v3\/calendars\/([^/]*)/.exec(url)) ||
+ (match = /^https?:\/\/www.google.com\/calendar\/feeds\/([^/]*)/.exec(url))) {
+ return decodeURIComponent(match[1]);
+ }
+ }
+ 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
+ };
+ }
+ // 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$3],
+ optionRefiners: OPTION_REFINERS$3,
+ eventSourceRefiners: EVENT_SOURCE_REFINERS$1
+ });
+
+ globalPlugins.push(interactionPlugin, dayGridPlugin, timeGridPlugin, listPlugin, plugin, googleCalendarPlugin);
+
+ 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.DateComponent = DateComponent;
+ exports.DateEnv = DateEnv;
+ exports.DateProfileGenerator = DateProfileGenerator;
+ exports.DayCellContent = DayCellContent;
+ exports.DayCellRoot = DayCellRoot;
+ exports.DayGridView = DayTableView;
+ exports.DayHeader = DayHeader;
+ 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.MountHook = MountHook;
+ exports.NamedTimeZoneImpl = NamedTimeZoneImpl;
+ exports.NowIndicatorRoot = NowIndicatorRoot;
+ exports.NowTimer = NowTimer;
+ exports.PointerDragging = PointerDragging;
+ exports.PositionCache = PositionCache;
+ exports.RefMap = RefMap;
+ exports.RenderHook = RenderHook;
+ exports.ScrollController = ScrollController;
+ exports.ScrollResponder = ScrollResponder;
+ exports.Scroller = Scroller;
+ exports.SimpleScrollGrid = SimpleScrollGrid;
+ exports.Slicer = Slicer;
+ exports.Splitter = Splitter;
+ 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.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.buildClassNameNormalizer = buildClassNameNormalizer;
+ exports.buildDayRanges = buildDayRanges;
+ exports.buildDayTableModel = buildDayTableModel;
+ exports.buildEventApis = buildEventApis;
+ exports.buildEventRangeKey = buildEventRangeKey;
+ exports.buildHashFromArray = buildHashFromArray;
+ exports.buildNavLinkData = buildNavLinkData;
+ exports.buildSegCompareObj = buildSegCompareObj;
+ exports.buildSegTimeText = buildSegTimeText;
+ exports.buildSlatMetas = buildSlatMetas;
+ exports.buildTimeColsModel = buildTimeColsModel;
+ exports.collectFromHash = collectFromHash;
+ exports.combineEventUis = combineEventUis;
+ exports.compareByFieldSpec = compareByFieldSpec;
+ exports.compareByFieldSpecs = compareByFieldSpecs;
+ exports.compareNumbers = compareNumbers;
+ exports.compareObjs = compareObjs;
+ 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.createContext = createContext$1;
+ exports.createDuration = createDuration;
+ exports.createElement = createElement;
+ exports.createEmptyEventStore = createEmptyEventStore;
+ exports.createEventInstance = createEventInstance;
+ exports.createEventUi = createEventUi;
+ exports.createFormatter = createFormatter;
+ exports.createPlugin = createPlugin;
+ 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.flexibleCompare = flexibleCompare;
+ exports.flushToDom = flushToDom$1;
+ 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.getElSeg = getElSeg;
+ exports.getEventClassNames = getEventClassNames;
+ exports.getIsRtlScrollbarOnLeft = getIsRtlScrollbarOnLeft;
+ exports.getRectCenter = getRectCenter;
+ exports.getRelevantEvents = getRelevantEvents;
+ exports.getScrollGridClassNames = getScrollGridClassNames;
+ exports.getScrollbarWidths = getScrollbarWidths;
+ exports.getSectionClassNames = getSectionClassNames;
+ exports.getSectionHasLiquidHeight = getSectionHasLiquidHeight;
+ exports.getSegMeta = getSegMeta;
+ exports.getSlotClassNames = getSlotClassNames;
+ exports.getStickyFooterScrollbar = getStickyFooterScrollbar;
+ exports.getStickyHeaderDates = getStickyHeaderDates;
+ exports.getUnequalProps = getUnequalProps;
+ exports.globalLocales = globalLocales;
+ exports.globalPlugins = globalPlugins;
+ exports.greatestDurationDenominator = greatestDurationDenominator;
+ 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.isArraysEqual = isArraysEqual;
+ exports.isColPropsEqual = isColPropsEqual;
+ exports.isDateSpansEqual = isDateSpansEqual;
+ exports.isInt = isInt;
+ exports.isInteractionValid = isInteractionValid;
+ exports.isMultiDayRange = isMultiDayRange;
+ exports.isPropsEqual = isPropsEqual;
+ exports.isPropsValid = isPropsValid;
+ exports.isValidDate = isValidDate;
+ 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.sliceEventStore = sliceEventStore;
+ exports.sliceEvents = sliceEvents;
+ exports.sortEventSegs = sortEventSegs;
+ exports.startOfDay = startOfDay;
+ exports.translateRect = translateRect;
+ exports.triggerDateSelect = triggerDateSelect;
+ exports.unpromisify = unpromisify;
+ exports.version = version;
+ exports.whenTransitionDone = whenTransitionDone;
+ exports.wholeDivideDurations = wholeDivideDurations;
+
+ return exports;
+
+}({}));
diff --git a/static/fullcalendar/main.min.css b/static/fullcalendar/main.min.css
new file mode 100644
index 0000000..48a87a8
--- /dev/null
+++ b/static/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;text-align:center}.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;font-weight:400}.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{height:auto}.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:-webkit-sticky;position:sticky;z-index:2}.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:-webkit-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{box-shadow:0 2px 5px rgba(0,0,0,.2)}.fc-event-selected:before{content:"";position:absolute;z-index:3;top:0;left:0;right:0;bottom:0}.fc-event-selected: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(var(--fc-event-resizer-thickness,8px)/ -2)}.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(var(--fc-event-resizer-thickness,8px)/ -2)}.fc-h-event.fc-event-selected .fc-event-resizer{top:50%;margin-top:-4px;margin-top:calc(var(--fc-event-resizer-dot-total-width,8px)/ -2)}.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(var(--fc-event-resizer-dot-total-width,8px)/ -2)}.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(var(--fc-event-resizer-dot-total-width,8px)/ -2)}:root{--fc-daygrid-event-dot-width:8px;--fc-list-event-dot-width:10px;--fc-list-event-hover-bg-color:#f5f5f5}.fc .fc-popover{position:fixed;top:0;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))}.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;margin:2px 3px 0}.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{z-index:8}.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 .fc-timegrid-col-frame{min-height:100%;position:relative}.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-media-screen .fc-timegrid-event-harness{position:absolute}.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-inset .fc-timegrid-event,.fc-timegrid-event.fc-event-mirror{box-shadow:0 0 0 1px #fff;box-shadow:0 0 0 1px var(--fc-page-bg-color,#fff)}.fc-timegrid-event{font-size:.85em;font-size:var(--fc-small-font-size,.85em);border-radius:3px}.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-condensed .fc-event-main-frame{flex-direction:row;overflow:hidden}.fc-timegrid-event-condensed .fc-event-time:after{content:'\00a0-\00a0'}.fc-timegrid-event-condensed .fc-event-title{font-size:.85em;font-size:var(--fc-small-font-size,.85em)}.fc-media-screen .fc-timegrid-event{position:absolute;top:0;bottom:1px;left:0;right: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:-webkit-sticky;position:sticky;top:0;background:var(--fc-page-bg-color,#fff)}.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}
\ No newline at end of file
diff --git a/static/fullcalendar/main.min.js b/static/fullcalendar/main.min.js
new file mode 100644
index 0000000..055eb02
--- /dev/null
+++ b/static/fullcalendar/main.min.js
@@ -0,0 +1,6 @@
+/*!
+FullCalendar v5.3.2
+Docs & License: https://fullcalendar.io/
+(c) 2020 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)t.hasOwnProperty(n)&&(e[n]=t[n])})(e,n)};function n(e,n){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],r=3;r=0;i--){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]=Ne(o))}for(i=e.length-1;i>=0;i--){var s=e[i];for(var l in s)l in n||(n[l]=s[l])}return n}function He(e,t){var n={};for(var r in e)t(e[r],r)&&(n[r]=e[r]);return n}function Oe(e,t){var n={};for(var r in e)n[r]=t(e[r],r);return n}function Ae(e){for(var t={},n=0,r=e;n1)||"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=vt(function(e,t){var n={};for(var r in e)(!(r in lt)||lt[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=$e(t)&&(r=ve(r,1))}return e.start&&(n=be(e.start),r&&r<=n&&(r=ve(n,1))),{start:n,end:r}}function $t(e){var t=Jt(e);return ye(t.start,t.end)>1}function Qt(e,t,n,r){return"year"===r?Ye(n.diffWholeYears(e,t),"year"):"month"===r?Ye(n.diffWholeMonths(e,t),"month"):Ee(e,t)}function en(e,t){var n,r,o=[],i=t.start;for(e.sort(tn),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 sn(e,t){return(null===e.start||t>=e.start)&&(null===e.end||t=(n||t.end),isToday:t&&sn(t,r.start)}}function Dn(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 bn(e){return e.instance?e.instance.instanceId:e.def.defId+":"+e.range.start.toISOString()}var Cn={start:_t,end:_t,allDay:Boolean};function wn(e,t,n){var o=function(e,t){var n=xt(e,Cn),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 Rn(e,t){return rn(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 Tn(e,t,n){return r(r({},kn(e,t,n)),{timeZone:t.timeZone})}function kn(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 Mn(e,t,n){var r=Yt({editable:!1},n),o=Xt(r.refined,r.extra,"",e.allDay,!0,n);return{def:o,ui:fn(o,t),instance:Ie(o.defId,e.range),range:e.range,isStart:!0,isEnd:!0}}function xn(e,t,n){n.emitter.trigger("select",r(r({},_n(e,n)),{jsEvent:t?t.origEvent:null,view:n.viewApi||n.calendarApi.view}))}function _n(e,t){for(var n,o,i={},a=0,s=t.pluginHooks.dateSpanTransforms;a=0;r--){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:$(),sourceDefId:s.sourceDefId,meta:s.meta,ui:Wt(i,t),extendedProps:a}}return null}function Ln(e){return r(r(r({},Lt),An),e.pluginHooks.eventSourceRefiners)}function Wn(e,t){return"function"==typeof e&&(e=e()),null==e?t.createNowMarker():t.createMarker(e)}var Vn=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=ge(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)),function(e,t,n){void 0===n&&(n=!1);var r=e.toISOString();return r=r.replace(".000",""),n&&(r=r.replace("T00:00:00Z","")),r.length>10&&(null==t?r=r.replace("Z",""):0!==t&&(r=r.replace("Z",rt(t,!0)))),r}(e,n,t.omitTime)},e.prototype.timestampToMarker=function(e){return"local"===this.timeZone?Me(Re(new Date(e))):"UTC"!==this.timeZone&&this.namedTimeZoneImpl?Me(this.namedTimeZoneImpl.timestampToArray(e)):new Date(e)},e.prototype.offsetForMarker=function(e){return"local"===this.timeZone?-Te(ke(e)).getTimezoneOffset():"UTC"===this.timeZone?0:this.namedTimeZoneImpl?this.namedTimeZoneImpl.offsetForArray(ke(e)):null},e.prototype.toDate=function(e,t){return"local"===this.timeZone?Te(ke(e)):"UTC"===this.timeZone?new Date(e.valueOf()):this.namedTimeZoneImpl?new Date(e.valueOf()-1e3*this.namedTimeZoneImpl.offsetForArray(ke(e))*60):new Date(e.valueOf()-(t||0))},e}(),Kn=[],Jn={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",allDayText:"all-day",moreLinkText:"more",noEventsText:"No events to display"};function $n(e){for(var t=e.length>0?e[0].code:"en",n=Kn.concat(e),r={en:Jn},o=0,i=n;o0;o--){var i=r.slice(0,o).join("-");if(t[i])return t[i]}return null}(n,t)||Jn;return er(e,n,r)}(e,t):er(e.code,[e.code],e)}function er(e,t,n){var r=Ne([Jn,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 tr(e){var t=Qn(e.locale||"en",$n([]).map);return new Xn(r(r({timeZone:bt.timeZone,calendarSystem:"gregory"},e),{locale:t}))}var nr,rr={startTime:"09:00",endTime:"17:00",daysOfWeek:[1,2,3,4,5],display:"inverse-background",classNames:"fc-non-business",groupId:"_businessHours"};function or(e,t){return It(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({},rr),e)}))}(e),null,t)}function ir(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}()),nr}var dr={defs:{},instances:{}},pr=function(){function e(){this.getKeysForEventDefs=it(this._getKeysForEventDefs),this.splitDateSelection=it(this._splitDateSpan),this.splitEventStore=it(this._splitEventStore),this.splitIndividualUi=it(this._splitIndividualUi),this.splitEventDrag=it(this._splitInteraction),this.splitEventResize=it(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=Oe(n,(function(e,n){return t.eventUiBuilders[n]||it(fr)})),n){var d=n[c],p=a[c]||dr,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
+ 
+ Démonstrateur Pilotage
+ 
+ 
Hint
+1,3: 
News
+1,4: 
Details
+5,7: 
Access
+4,5: 
Access
+1,5:  ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAHBJREFUeNpidHB2ZyAGsACxDRBPIKCuA6TwCBB/h2rABu4A8SYmKCcXiP/iUFgAxL9gCi8A8SwsirZCMQMTkmANEH9E4v+CmsaArvAdyNFI/FlQ92EoBIE+qCRIUz168DBgsU4OqhinQpgHMABAgAEALY4XLIsJ20oAAAAASUVORK5CYII=' :
+ IMAGE_PATH + '/dropdown.png') + ')
';
+ mxUtils.setOpacity(arrow, 70);
+
+ var symbol = elt.getElementsByTagName('div')[0];
+
+ if (symbol != null)
+ {
+ symbol.style.paddingRight = '6px';
+ symbol.style.marginLeft = '4px';
+ symbol.style.marginTop = '-1px';
+ symbol.style.display = (mxClient.IS_QUIRKS) ? 'inline' : 'inline-block';
+ mxUtils.setOpacity(symbol, 60);
+ }
+
+ mxUtils.setOpacity(elt, 100);
+ elt.style.border = '1px solid #a0a0a0';
+ elt.style.backgroundColor = this.buttonBackgroundColor;
+ elt.style.backgroundImage = 'none';
+ elt.style.width = 'auto';
+ elt.className += ' geColorBtn';
+ mxUtils.setPrefixedStyle(elt.style, 'borderRadius', '3px');
+
+ elt.appendChild(arrow);
+
+ return symbol;
+};
+
+/**
+ *
+ */
+BaseFormatPanel.prototype.addUnitInput = function(container, unit, right, width, update, step, marginTop, disableFocus, isFloat)
+{
+ marginTop = (marginTop != null) ? marginTop : 0;
+
+ var input = document.createElement('input');
+ input.style.position = 'absolute';
+ input.style.textAlign = 'right';
+ input.style.marginTop = '-2px';
+ input.style.right = (right + 12) + 'px';
+ input.style.width = width + 'px';
+ container.appendChild(input);
+
+ var stepper = this.createStepper(input, update, step, null, disableFocus, null, isFloat);
+ stepper.style.marginTop = (marginTop - 2) + 'px';
+ stepper.style.right = right + 'px';
+ container.appendChild(stepper);
+
+ return input;
+};
+
+/**
+ *
+ */
+BaseFormatPanel.prototype.createRelativeOption = function(label, key, width, handler, init)
+{
+ width = (width != null) ? width : 44;
+
+ var graph = this.editorUi.editor.graph;
+ var div = this.createPanel();
+ div.style.paddingTop = '10px';
+ div.style.paddingBottom = '10px';
+ mxUtils.write(div, label);
+ div.style.fontWeight = 'bold';
+
+ var update = mxUtils.bind(this, function(evt)
+ {
+ if (handler != null)
+ {
+ handler(input);
+ }
+ else
+ {
+ var value = parseInt(input.value);
+ value = Math.min(100, Math.max(0, (isNaN(value)) ? 100 : value));
+ var state = graph.view.getState(graph.getSelectionCell());
+
+ if (state != null && value != mxUtils.getValue(state.style, key, 100))
+ {
+ // Removes entry in style (assumes 100 is default for relative values)
+ if (value == 100)
+ {
+ value = null;
+ }
+
+ graph.setCellStyles(key, value, graph.getSelectionCells());
+ this.editorUi.fireEvent(new mxEventObject('styleChanged', 'keys', [key],
+ 'values', [value], 'cells', graph.getSelectionCells()));
+ }
+
+ input.value = ((value != null) ? value : '100') + ' %';
+ }
+
+ mxEvent.consume(evt);
+ });
+
+ var input = this.addUnitInput(div, '%', 20, width, update, 10, -15, handler != null);
+
+ if (key != null)
+ {
+ var listener = mxUtils.bind(this, function(sender, evt, force)
+ {
+ if (force || input != document.activeElement)
+ {
+ var ss = this.format.getSelectionState();
+ var tmp = parseInt(mxUtils.getValue(ss.style, key, 100));
+ input.value = (isNaN(tmp)) ? '' : tmp + ' %';
+ }
+ });
+
+ mxEvent.addListener(input, 'keydown', function(e)
+ {
+ if (e.keyCode == 13)
+ {
+ graph.container.focus();
+ mxEvent.consume(e);
+ }
+ else if (e.keyCode == 27)
+ {
+ listener(null, null, true);
+ graph.container.focus();
+ mxEvent.consume(e);
+ }
+ });
+
+ graph.getModel().addListener(mxEvent.CHANGE, listener);
+ this.listeners.push({destroy: function() { graph.getModel().removeListener(listener); }});
+ listener();
+ }
+
+ mxEvent.addListener(input, 'blur', update);
+ mxEvent.addListener(input, 'change', update);
+
+ if (init != null)
+ {
+ init(input);
+ }
+
+ return div;
+};
+
+/**
+ *
+ */
+BaseFormatPanel.prototype.addLabel = function(div, title, right, width)
+{
+ width = (width != null) ? width : 61;
+
+ var label = document.createElement('div');
+ mxUtils.write(label, title);
+ label.style.position = 'absolute';
+ label.style.right = right + 'px';
+ label.style.width = width + 'px';
+ label.style.marginTop = '6px';
+ label.style.textAlign = 'center';
+ div.appendChild(label);
+};
+
+/**
+ *
+ */
+BaseFormatPanel.prototype.addKeyHandler = function(input, listener)
+{
+ mxEvent.addListener(input, 'keydown', mxUtils.bind(this, function(e)
+ {
+ if (e.keyCode == 13)
+ {
+ this.editorUi.editor.graph.container.focus();
+ mxEvent.consume(e);
+ }
+ else if (e.keyCode == 27)
+ {
+ if (listener != null)
+ {
+ listener(null, null, true);
+ }
+
+ this.editorUi.editor.graph.container.focus();
+ mxEvent.consume(e);
+ }
+ }));
+};
+
+/**
+ *
+ */
+BaseFormatPanel.prototype.styleButtons = function(elts)
+{
+ for (var i = 0; i < elts.length; i++)
+ {
+ mxUtils.setPrefixedStyle(elts[i].style, 'borderRadius', '3px');
+ mxUtils.setOpacity(elts[i], 100);
+ elts[i].style.border = '1px solid #a0a0a0';
+ elts[i].style.padding = '4px';
+ elts[i].style.paddingTop = '3px';
+ elts[i].style.paddingRight = '1px';
+ elts[i].style.margin = '1px';
+ elts[i].style.width = '24px';
+ elts[i].style.height = '20px';
+ elts[i].className += ' geColorBtn';
+ }
+};
+
+/**
+ * Adds the label menu items to the given menu and parent.
+ */
+BaseFormatPanel.prototype.destroy = function()
+{
+ if (this.listeners != null)
+ {
+ for (var i = 0; i < this.listeners.length; i++)
+ {
+ this.listeners[i].destroy();
+ }
+
+ this.listeners = null;
+ }
+};
+
+/**
+ * Adds the label menu items to the given menu and parent.
+ */
+ArrangePanel = function(format, editorUi, container)
+{
+ BaseFormatPanel.call(this, format, editorUi, container);
+ this.init();
+};
+
+mxUtils.extend(ArrangePanel, BaseFormatPanel);
+
+/**
+ * Adds the label menu items to the given menu and parent.
+ */
+ArrangePanel.prototype.init = function()
+{
+ var graph = this.editorUi.editor.graph;
+ var ss = this.format.getSelectionState();
+
+ this.container.appendChild(this.addLayerOps(this.createPanel()));
+ // Special case that adds two panels
+ this.addGeometry(this.container);
+ this.addEdgeGeometry(this.container);
+
+ if (!ss.containsLabel || ss.edges.length == 0)
+ {
+ this.container.appendChild(this.addAngle(this.createPanel()));
+ }
+
+ if (!ss.containsLabel && ss.edges.length == 0 &&
+ ss.style.shape != 'rectangle' &&
+ ss.style.shape != 'label')
+ {
+ this.container.appendChild(this.addFlip(this.createPanel()));
+ }
+
+ if (ss.vertices.length > 1)
+ {
+ this.container.appendChild(this.addAlign(this.createPanel()));
+ this.container.appendChild(this.addDistribute(this.createPanel()));
+ }
+ else if (ss.vertices.length == 1 && ss.edges.length == 0 &&
+ (graph.isTable(ss.vertices[0]) ||
+ graph.isTableRow(ss.vertices[0]) ||
+ graph.isTableCell(ss.vertices[0])))
+ {
+ this.container.appendChild(this.addTable(this.createPanel()));
+ }
+
+ this.container.appendChild(this.addGroupOps(this.createPanel()));
+
+ if (ss.containsLabel)
+ {
+ // Adds functions from hidden style format panel
+ var span = document.createElement('div');
+ span.style.width = '100%';
+ span.style.marginTop = '0px';
+ span.style.fontWeight = 'bold';
+ span.style.padding = '10px 0 0 18px';
+ mxUtils.write(span, mxResources.get('style'));
+ this.container.appendChild(span);
+
+ new StyleFormatPanel(this.format, this.editorUi, this.container);
+ }
+};
+
+/**
+ *
+ */
+ArrangePanel.prototype.addTable = function(div)
+{
+ var ui = this.editorUi;
+ var editor = ui.editor;
+ var graph = editor.graph;
+ var ss = this.format.getSelectionState();
+ div.style.paddingTop = '6px';
+ div.style.paddingBottom = '10px';
+
+ var span = document.createElement('div');
+ span.style.marginTop = '2px';
+ span.style.marginBottom = '8px';
+ span.style.fontWeight = 'bold';
+ mxUtils.write(span, mxResources.get('table'));
+ div.appendChild(span);
+
+ var panel = document.createElement('div');
+ panel.style.position = 'relative';
+ panel.style.paddingLeft = '0px';
+ panel.style.borderWidth = '0px';
+ panel.className = 'geToolbarContainer';
+
+ var btns = [
+ ui.toolbar.addButton('geSprite-insertcolumnbefore', mxResources.get('insertColumnBefore'),
+ mxUtils.bind(this, function()
+ {
+ try
+ {
+ graph.insertTableColumn(ss.vertices[0], true);
+ }
+ catch (e)
+ {
+ ui.handleError(e);
+ }
+ }), panel),
+ ui.toolbar.addButton('geSprite-insertcolumnafter', mxResources.get('insertColumnAfter'),
+ mxUtils.bind(this, function()
+ {
+ try
+ {
+ graph.insertTableColumn(ss.vertices[0], false);
+ }
+ catch (e)
+ {
+ ui.handleError(e);
+ }
+ }), panel),
+ ui.toolbar.addButton('geSprite-deletecolumn', mxResources.get('deleteColumn'),
+ mxUtils.bind(this, function()
+ {
+ try
+ {
+ graph.deleteTableColumn(ss.vertices[0]);
+ }
+ catch (e)
+ {
+ ui.handleError(e);
+ }
+ }), panel),
+ ui.toolbar.addButton('geSprite-insertrowbefore', mxResources.get('insertRowBefore'),
+ mxUtils.bind(this, function()
+ {
+ try
+ {
+ graph.insertTableRow(ss.vertices[0], true);
+ }
+ catch (e)
+ {
+ ui.handleError(e);
+ }
+ }), panel),
+ ui.toolbar.addButton('geSprite-insertrowafter', mxResources.get('insertRowAfter'),
+ mxUtils.bind(this, function()
+ {
+ try
+ {
+ graph.insertTableRow(ss.vertices[0], false);
+ }
+ catch (e)
+ {
+ ui.handleError(e);
+ }
+ }), panel),
+ ui.toolbar.addButton('geSprite-deleterow', mxResources.get('deleteRow'),
+ mxUtils.bind(this, function()
+ {
+ try
+ {
+ graph.deleteTableRow(ss.vertices[0]);
+ }
+ catch (e)
+ {
+ ui.handleError(e);
+ }
+ }), panel)];
+ this.styleButtons(btns);
+ div.appendChild(panel);
+ btns[2].style.marginRight = '9px';
+
+ return div;
+};
+
+/**
+ *
+ */
+ArrangePanel.prototype.addLayerOps = function(div)
+{
+ var ui = this.editorUi;
+
+ var btn = mxUtils.button(mxResources.get('toFront'), function(evt)
+ {
+ ui.actions.get('toFront').funct();
+ })
+
+ btn.setAttribute('title', mxResources.get('toFront') + ' (' + this.editorUi.actions.get('toFront').shortcut + ')');
+ btn.style.width = '100px';
+ btn.style.marginRight = '2px';
+ div.appendChild(btn);
+
+ var btn = mxUtils.button(mxResources.get('toBack'), function(evt)
+ {
+ ui.actions.get('toBack').funct();
+ })
+
+ btn.setAttribute('title', mxResources.get('toBack') + ' (' + this.editorUi.actions.get('toBack').shortcut + ')');
+ btn.style.width = '100px';
+ div.appendChild(btn);
+
+ return div;
+};
+
+/**
+ *
+ */
+ArrangePanel.prototype.addGroupOps = function(div)
+{
+ var ui = this.editorUi;
+ var graph = ui.editor.graph;
+ var cell = graph.getSelectionCell();
+ var ss = this.format.getSelectionState();
+ var count = 0;
+ var btn = null;
+
+ div.style.paddingTop = '8px';
+ div.style.paddingBottom = '6px';
+
+ if (graph.getSelectionCount() > 1)
+ {
+ btn = mxUtils.button(mxResources.get('group'), function(evt)
+ {
+ ui.actions.get('group').funct();
+ })
+
+ btn.setAttribute('title', mxResources.get('group') + ' (' + this.editorUi.actions.get('group').shortcut + ')');
+ btn.style.width = '202px';
+ btn.style.marginBottom = '2px';
+ div.appendChild(btn);
+ count++;
+ }
+ else if (graph.getSelectionCount() == 1 && !graph.getModel().isEdge(cell) && !graph.isSwimlane(cell) &&
+ graph.getModel().getChildCount(cell) > 0)
+ {
+ btn = mxUtils.button(mxResources.get('ungroup'), function(evt)
+ {
+ ui.actions.get('ungroup').funct();
+ })
+
+ btn.setAttribute('title', mxResources.get('ungroup') + ' (' +
+ this.editorUi.actions.get('ungroup').shortcut + ')');
+ btn.style.width = '202px';
+ btn.style.marginBottom = '2px';
+ div.appendChild(btn);
+ count++;
+ }
+
+ if (ss.vertices.length > 0)
+ {
+ if (count > 0)
+ {
+ mxUtils.br(div);
+ count = 0;
+ }
+
+ var btn = mxUtils.button(mxResources.get('copySize'), function(evt)
+ {
+ ui.actions.get('copySize').funct();
+ });
+
+ btn.setAttribute('title', mxResources.get('copySize') + ' (' +
+ this.editorUi.actions.get('copySize').shortcut + ')');
+ btn.style.width = '202px';
+ btn.style.marginBottom = '2px';
+
+ div.appendChild(btn);
+ count++;
+
+ if (ui.copiedSize != null)
+ {
+ var btn2 = mxUtils.button(mxResources.get('pasteSize'), function(evt)
+ {
+ ui.actions.get('pasteSize').funct();
+ });
+
+ btn2.setAttribute('title', mxResources.get('pasteSize') + ' (' +
+ this.editorUi.actions.get('pasteSize').shortcut + ')');
+
+ div.appendChild(btn2);
+ count++;
+
+ btn.style.width = '100px';
+ btn.style.marginBottom = '2px';
+ btn2.style.width = '100px';
+ btn2.style.marginBottom = '2px';
+ }
+ }
+
+ if (graph.getSelectionCount() == 1 && graph.getModel().isVertex(cell) &&
+ graph.getModel().isVertex(graph.getModel().getParent(cell)))
+ {
+ if (count > 0)
+ {
+ mxUtils.br(div);
+ }
+
+ btn = mxUtils.button(mxResources.get('removeFromGroup'), function(evt)
+ {
+ ui.actions.get('removeFromGroup').funct();
+ })
+
+ btn.setAttribute('title', mxResources.get('removeFromGroup'));
+ btn.style.width = '202px';
+ btn.style.marginBottom = '2px';
+ div.appendChild(btn);
+ count++;
+ }
+ else if (graph.getSelectionCount() > 0)
+ {
+ if (count > 0)
+ {
+ mxUtils.br(div);
+ }
+
+ btn = mxUtils.button(mxResources.get('clearWaypoints'), mxUtils.bind(this, function(evt)
+ {
+ this.editorUi.actions.get('clearWaypoints').funct();
+ }));
+
+ btn.setAttribute('title', mxResources.get('clearWaypoints') + ' (' + this.editorUi.actions.get('clearWaypoints').shortcut + ')');
+ btn.style.width = '202px';
+ btn.style.marginBottom = '2px';
+ div.appendChild(btn);
+
+ count++;
+ }
+
+ if (graph.getSelectionCount() == 1)
+ {
+ if (count > 0)
+ {
+ mxUtils.br(div);
+ }
+
+ btn = mxUtils.button(mxResources.get('editData'), mxUtils.bind(this, function(evt)
+ {
+ this.editorUi.actions.get('editData').funct();
+ }));
+
+ btn.setAttribute('title', mxResources.get('editData') + ' (' + this.editorUi.actions.get('editData').shortcut + ')');
+ btn.style.width = '100px';
+ btn.style.marginBottom = '2px';
+ div.appendChild(btn);
+ count++;
+
+ btn = mxUtils.button(mxResources.get('editLink'), mxUtils.bind(this, function(evt)
+ {
+ this.editorUi.actions.get('editLink').funct();
+ }));
+
+ btn.setAttribute('title', mxResources.get('editLink'));
+ btn.style.width = '100px';
+ btn.style.marginLeft = '2px';
+ btn.style.marginBottom = '2px';
+ div.appendChild(btn);
+ count++;
+ }
+
+ if (count == 0)
+ {
+ div.style.display = 'none';
+ }
+
+ return div;
+};
+
+/**
+ *
+ */
+ArrangePanel.prototype.addAlign = function(div)
+{
+ var graph = this.editorUi.editor.graph;
+ div.style.paddingTop = '6px';
+ div.style.paddingBottom = '12px';
+ div.appendChild(this.createTitle(mxResources.get('align')));
+
+ var stylePanel = document.createElement('div');
+ stylePanel.style.position = 'relative';
+ stylePanel.style.paddingLeft = '0px';
+ stylePanel.style.borderWidth = '0px';
+ stylePanel.className = 'geToolbarContainer';
+
+ if (mxClient.IS_QUIRKS)
+ {
+ div.style.height = '60px';
+ }
+
+ var left = this.editorUi.toolbar.addButton('geSprite-alignleft', mxResources.get('left'),
+ function() { graph.alignCells(mxConstants.ALIGN_LEFT); }, stylePanel);
+ var center = this.editorUi.toolbar.addButton('geSprite-aligncenter', mxResources.get('center'),
+ function() { graph.alignCells(mxConstants.ALIGN_CENTER); }, stylePanel);
+ var right = this.editorUi.toolbar.addButton('geSprite-alignright', mxResources.get('right'),
+ function() { graph.alignCells(mxConstants.ALIGN_RIGHT); }, stylePanel);
+
+ var top = this.editorUi.toolbar.addButton('geSprite-aligntop', mxResources.get('top'),
+ function() { graph.alignCells(mxConstants.ALIGN_TOP); }, stylePanel);
+ var middle = this.editorUi.toolbar.addButton('geSprite-alignmiddle', mxResources.get('middle'),
+ function() { graph.alignCells(mxConstants.ALIGN_MIDDLE); }, stylePanel);
+ var bottom = this.editorUi.toolbar.addButton('geSprite-alignbottom', mxResources.get('bottom'),
+ function() { graph.alignCells(mxConstants.ALIGN_BOTTOM); }, stylePanel);
+
+ this.styleButtons([left, center, right, top, middle, bottom]);
+ right.style.marginRight = '6px';
+ div.appendChild(stylePanel);
+
+ return div;
+};
+
+/**
+ *
+ */
+ArrangePanel.prototype.addFlip = function(div)
+{
+ var ui = this.editorUi;
+ var editor = ui.editor;
+ var graph = editor.graph;
+ div.style.paddingTop = '6px';
+ div.style.paddingBottom = '10px';
+
+ var span = document.createElement('div');
+ span.style.marginTop = '2px';
+ span.style.marginBottom = '8px';
+ span.style.fontWeight = 'bold';
+ mxUtils.write(span, mxResources.get('flip'));
+ div.appendChild(span);
+
+ var btn = mxUtils.button(mxResources.get('horizontal'), function(evt)
+ {
+ graph.toggleCellStyles(mxConstants.STYLE_FLIPH, false);
+ })
+
+ btn.setAttribute('title', mxResources.get('horizontal'));
+ btn.style.width = '100px';
+ btn.style.marginRight = '2px';
+ div.appendChild(btn);
+
+ var btn = mxUtils.button(mxResources.get('vertical'), function(evt)
+ {
+ graph.toggleCellStyles(mxConstants.STYLE_FLIPV, false);
+ })
+
+ btn.setAttribute('title', mxResources.get('vertical'));
+ btn.style.width = '100px';
+ div.appendChild(btn);
+
+ return div;
+};
+
+/**
+ *
+ */
+ArrangePanel.prototype.addDistribute = function(div)
+{
+ var ui = this.editorUi;
+ var editor = ui.editor;
+ var graph = editor.graph;
+ div.style.paddingTop = '6px';
+ div.style.paddingBottom = '12px';
+
+ div.appendChild(this.createTitle(mxResources.get('distribute')));
+
+ var btn = mxUtils.button(mxResources.get('horizontal'), function(evt)
+ {
+ graph.distributeCells(true);
+ })
+
+ btn.setAttribute('title', mxResources.get('horizontal'));
+ btn.style.width = '100px';
+ btn.style.marginRight = '2px';
+ div.appendChild(btn);
+
+ var btn = mxUtils.button(mxResources.get('vertical'), function(evt)
+ {
+ graph.distributeCells(false);
+ })
+
+ btn.setAttribute('title', mxResources.get('vertical'));
+ btn.style.width = '100px';
+ div.appendChild(btn);
+
+ return div;
+};
+
+/**
+ *
+ */
+ArrangePanel.prototype.addAngle = function(div)
+{
+ var ui = this.editorUi;
+ var editor = ui.editor;
+ var graph = editor.graph;
+ var ss = this.format.getSelectionState();
+
+ div.style.paddingBottom = '8px';
+
+ var span = document.createElement('div');
+ span.style.position = 'absolute';
+ span.style.width = '70px';
+ span.style.marginTop = '0px';
+ span.style.fontWeight = 'bold';
+
+ var input = null;
+ var update = null;
+ var btn = null;
+
+ if (ss.edges.length == 0)
+ {
+ mxUtils.write(span, mxResources.get('angle'));
+ div.appendChild(span);
+
+ input = this.addUnitInput(div, '°', 20, 44, function()
+ {
+ update.apply(this, arguments);
+ });
+
+ mxUtils.br(div);
+ div.style.paddingTop = '10px';
+ }
+ else
+ {
+ div.style.paddingTop = '8px';
+ }
+
+ if (!ss.containsLabel)
+ {
+ var label = mxResources.get('reverse');
+
+ if (ss.vertices.length > 0 && ss.edges.length > 0)
+ {
+ label = mxResources.get('turn') + ' / ' + label;
+ }
+ else if (ss.vertices.length > 0)
+ {
+ label = mxResources.get('turn');
+ }
+
+ btn = mxUtils.button(label, function(evt)
+ {
+ ui.actions.get('turn').funct(evt);
+ })
+
+ btn.setAttribute('title', label + ' (' + this.editorUi.actions.get('turn').shortcut + ')');
+ btn.style.width = '202px';
+ div.appendChild(btn);
+
+ if (input != null)
+ {
+ btn.style.marginTop = '8px';
+ }
+ }
+
+ if (input != null)
+ {
+ var listener = mxUtils.bind(this, function(sender, evt, force)
+ {
+ if (force || document.activeElement != input)
+ {
+ ss = this.format.getSelectionState();
+ var tmp = parseFloat(mxUtils.getValue(ss.style, mxConstants.STYLE_ROTATION, 0));
+ input.value = (isNaN(tmp)) ? '' : tmp + '°';
+ }
+ });
+
+ update = this.installInputHandler(input, mxConstants.STYLE_ROTATION, 0, 0, 360, '°', null, true);
+ this.addKeyHandler(input, listener);
+
+ graph.getModel().addListener(mxEvent.CHANGE, listener);
+ this.listeners.push({destroy: function() { graph.getModel().removeListener(listener); }});
+ listener();
+ }
+
+ return div;
+};
+
+BaseFormatPanel.prototype.getUnit = function()
+{
+ var unit = this.editorUi.editor.graph.view.unit;
+
+ switch(unit)
+ {
+ case mxConstants.POINTS:
+ return 'pt';
+ case mxConstants.INCHES:
+ return '"';
+ case mxConstants.MILLIMETERS:
+ return 'mm';
+ }
+};
+
+BaseFormatPanel.prototype.inUnit = function(pixels)
+{
+ return this.editorUi.editor.graph.view.formatUnitText(pixels);
+};
+
+BaseFormatPanel.prototype.fromUnit = function(value)
+{
+ var unit = this.editorUi.editor.graph.view.unit;
+
+ switch(unit)
+ {
+ case mxConstants.POINTS:
+ return value;
+ case mxConstants.INCHES:
+ return value * mxConstants.PIXELS_PER_INCH;
+ case mxConstants.MILLIMETERS:
+ return value * mxConstants.PIXELS_PER_MM;
+ }
+};
+
+BaseFormatPanel.prototype.isFloatUnit = function()
+{
+ return this.editorUi.editor.graph.view.unit != mxConstants.POINTS;
+};
+
+BaseFormatPanel.prototype.getUnitStep = function()
+{
+ var unit = this.editorUi.editor.graph.view.unit;
+
+ switch(unit)
+ {
+ case mxConstants.POINTS:
+ return 1;
+ case mxConstants.INCHES:
+ return 0.1;
+ case mxConstants.MILLIMETERS:
+ return 0.5;
+ }
+};
+
+/**
+ *
+ */
+ArrangePanel.prototype.addGeometry = function(container)
+{
+ var panel = this;
+ var ui = this.editorUi;
+ var graph = ui.editor.graph;
+ var rect = this.format.getSelectionState();
+
+ var div = this.createPanel();
+ div.style.paddingBottom = '8px';
+
+ var span = document.createElement('div');
+ span.style.position = 'absolute';
+ span.style.width = '50px';
+ span.style.marginTop = '0px';
+ span.style.fontWeight = 'bold';
+ mxUtils.write(span, mxResources.get('size'));
+ div.appendChild(span);
+
+ var widthUpdate, heightUpdate, leftUpdate, topUpdate;
+ var width = this.addUnitInput(div, this.getUnit(), 84, 44, function()
+ {
+ widthUpdate.apply(this, arguments);
+ }, this.getUnitStep(), null, null, this.isFloatUnit());
+ var height = this.addUnitInput(div, this.getUnit(), 20, 44, function()
+ {
+ heightUpdate.apply(this, arguments);
+ }, this.getUnitStep(), null, null, this.isFloatUnit());
+
+ var autosizeBtn = document.createElement('div');
+ autosizeBtn.className = 'geSprite geSprite-fit';
+ autosizeBtn.setAttribute('title', mxResources.get('autosize') + ' (' + this.editorUi.actions.get('autosize').shortcut + ')');
+ autosizeBtn.style.position = 'relative';
+ autosizeBtn.style.cursor = 'pointer';
+ autosizeBtn.style.marginTop = '-3px';
+ autosizeBtn.style.border = '0px';
+ autosizeBtn.style.left = '52px';
+ mxUtils.setOpacity(autosizeBtn, 50);
+
+ mxEvent.addListener(autosizeBtn, 'mouseenter', function()
+ {
+ mxUtils.setOpacity(autosizeBtn, 100);
+ });
+
+ mxEvent.addListener(autosizeBtn, 'mouseleave', function()
+ {
+ mxUtils.setOpacity(autosizeBtn, 50);
+ });
+
+ mxEvent.addListener(autosizeBtn, 'click', function()
+ {
+ ui.actions.get('autosize').funct();
+ });
+
+ div.appendChild(autosizeBtn);
+ this.addLabel(div, mxResources.get('width'), 84);
+ this.addLabel(div, mxResources.get('height'), 20);
+ mxUtils.br(div);
+
+ var wrapper = document.createElement('div');
+ wrapper.style.paddingTop = '8px';
+ wrapper.style.paddingRight = '20px';
+ wrapper.style.whiteSpace = 'nowrap';
+ wrapper.style.textAlign = 'right';
+ var opt = this.createCellOption(mxResources.get('constrainProportions'),
+ mxConstants.STYLE_ASPECT, null, 'fixed', 'null');
+ opt.style.width = '100%';
+ wrapper.appendChild(opt);
+ div.appendChild(wrapper);
+
+ var constrainCheckbox = opt.getElementsByTagName('input')[0];
+ this.addKeyHandler(width, listener);
+ this.addKeyHandler(height, listener);
+
+ widthUpdate = this.addGeometryHandler(width, function(geo, value)
+ {
+ if (geo.width > 0)
+ {
+ var value = Math.max(1, panel.fromUnit(value));
+
+ if (constrainCheckbox.checked)
+ {
+ geo.height = Math.round((geo.height * value * 100) / geo.width) / 100;
+ }
+
+ geo.width = value;
+ }
+ });
+ heightUpdate = this.addGeometryHandler(height, function(geo, value)
+ {
+ if (geo.height > 0)
+ {
+ var value = Math.max(1, panel.fromUnit(value));
+
+ if (constrainCheckbox.checked)
+ {
+ geo.width = Math.round((geo.width * value * 100) / geo.height) / 100;
+ }
+
+ geo.height = value;
+ }
+ });
+
+ container.appendChild(div);
+
+ var div2 = this.createPanel();
+ div2.style.paddingBottom = '30px';
+
+ var span = document.createElement('div');
+ span.style.position = 'absolute';
+ span.style.width = '70px';
+ span.style.marginTop = '0px';
+ span.style.fontWeight = 'bold';
+ mxUtils.write(span, mxResources.get('position'));
+ div2.appendChild(span);
+
+ var left = this.addUnitInput(div2, this.getUnit(), 84, 44, function()
+ {
+ leftUpdate.apply(this, arguments);
+ }, this.getUnitStep(), null, null, this.isFloatUnit());
+ var top = this.addUnitInput(div2, this.getUnit(), 20, 44, function()
+ {
+ topUpdate.apply(this, arguments);
+ }, this.getUnitStep(), null, null, this.isFloatUnit());
+
+ mxUtils.br(div2);
+ this.addLabel(div2, mxResources.get('left'), 84);
+ this.addLabel(div2, mxResources.get('top'), 20);
+
+ var listener = mxUtils.bind(this, function(sender, evt, force)
+ {
+ rect = this.format.getSelectionState();
+
+ if (!rect.containsLabel && rect.vertices.length == graph.getSelectionCount() &&
+ rect.width != null && rect.height != null)
+ {
+ div.style.display = '';
+
+ if (force || document.activeElement != width)
+ {
+ width.value = this.inUnit(rect.width) + ((rect.width == '') ? '' : ' ' + this.getUnit());
+ }
+
+ if (force || document.activeElement != height)
+ {
+ height.value = this.inUnit(rect.height) + ((rect.height == '') ? '' : ' ' + this.getUnit());
+ }
+ }
+ else
+ {
+ div.style.display = 'none';
+ }
+
+ if (rect.vertices.length == graph.getSelectionCount() &&
+ rect.x != null && rect.y != null)
+ {
+ div2.style.display = '';
+
+ if (force || document.activeElement != left)
+ {
+ left.value = this.inUnit(rect.x) + ((rect.x == '') ? '' : ' ' + this.getUnit());
+ }
+
+ if (force || document.activeElement != top)
+ {
+ top.value = this.inUnit(rect.y) + ((rect.y == '') ? '' : ' ' + this.getUnit());
+ }
+ }
+ else
+ {
+ div2.style.display = 'none';
+ }
+ });
+
+ this.addKeyHandler(left, listener);
+ this.addKeyHandler(top, listener);
+
+ graph.getModel().addListener(mxEvent.CHANGE, listener);
+ this.listeners.push({destroy: function() { graph.getModel().removeListener(listener); }});
+ listener();
+
+ leftUpdate = this.addGeometryHandler(left, function(geo, value)
+ {
+ value = panel.fromUnit(value);
+
+ if (geo.relative)
+ {
+ geo.offset.x = value;
+ }
+ else
+ {
+ geo.x = value;
+ }
+ });
+ topUpdate = this.addGeometryHandler(top, function(geo, value)
+ {
+ value = panel.fromUnit(value);
+
+ if (geo.relative)
+ {
+ geo.offset.y = value;
+ }
+ else
+ {
+ geo.y = value;
+ }
+ });
+
+ container.appendChild(div2);
+};
+
+/**
+ *
+ */
+ArrangePanel.prototype.addGeometryHandler = function(input, fn)
+{
+ var ui = this.editorUi;
+ var graph = ui.editor.graph;
+ var initialValue = null;
+ var panel = this;
+
+ function update(evt)
+ {
+ if (input.value != '')
+ {
+ var value = parseFloat(input.value);
+
+ if (isNaN(value))
+ {
+ input.value = initialValue + ' ' + panel.getUnit();
+ }
+ else if (value != initialValue)
+ {
+ graph.getModel().beginUpdate();
+ try
+ {
+ var cells = graph.getSelectionCells();
+
+ for (var i = 0; i < cells.length; i++)
+ {
+ if (graph.getModel().isVertex(cells[i]))
+ {
+ var geo = graph.getCellGeometry(cells[i]);
+
+ if (geo != null)
+ {
+ geo = geo.clone();
+ fn(geo, value);
+
+ var state = graph.view.getState(cells[i]);
+
+ if (state != null && graph.isRecursiveVertexResize(state))
+ {
+ graph.resizeChildCells(cells[i], geo);
+ }
+
+ graph.getModel().setGeometry(cells[i], geo);
+ graph.constrainChildCells(cells[i]);
+ }
+ }
+ }
+ }
+ finally
+ {
+ graph.getModel().endUpdate();
+ }
+
+ initialValue = value;
+ input.value = value + ' ' + panel.getUnit();
+ }
+ }
+
+ mxEvent.consume(evt);
+ };
+
+ mxEvent.addListener(input, 'blur', update);
+ mxEvent.addListener(input, 'change', update);
+ mxEvent.addListener(input, 'focus', function()
+ {
+ initialValue = input.value;
+ });
+
+ return update;
+};
+
+ArrangePanel.prototype.addEdgeGeometryHandler = function(input, fn)
+{
+ var ui = this.editorUi;
+ var graph = ui.editor.graph;
+ var initialValue = null;
+
+ function update(evt)
+ {
+ if (input.value != '')
+ {
+ var value = parseFloat(input.value);
+
+ if (isNaN(value))
+ {
+ input.value = initialValue + ' pt';
+ }
+ else if (value != initialValue)
+ {
+ graph.getModel().beginUpdate();
+ try
+ {
+ var cells = graph.getSelectionCells();
+
+ for (var i = 0; i < cells.length; i++)
+ {
+ if (graph.getModel().isEdge(cells[i]))
+ {
+ var geo = graph.getCellGeometry(cells[i]);
+
+ if (geo != null)
+ {
+ geo = geo.clone();
+ fn(geo, value);
+
+ graph.getModel().setGeometry(cells[i], geo);
+ }
+ }
+ }
+ }
+ finally
+ {
+ graph.getModel().endUpdate();
+ }
+
+ initialValue = value;
+ input.value = value + ' pt';
+ }
+ }
+
+ mxEvent.consume(evt);
+ };
+
+ mxEvent.addListener(input, 'blur', update);
+ mxEvent.addListener(input, 'change', update);
+ mxEvent.addListener(input, 'focus', function()
+ {
+ initialValue = input.value;
+ });
+
+ return update;
+};
+
+/**
+ *
+ */
+ArrangePanel.prototype.addEdgeGeometry = function(container)
+{
+ var ui = this.editorUi;
+ var graph = ui.editor.graph;
+ var rect = this.format.getSelectionState();
+
+ var div = this.createPanel();
+
+ var span = document.createElement('div');
+ span.style.position = 'absolute';
+ span.style.width = '70px';
+ span.style.marginTop = '0px';
+ span.style.fontWeight = 'bold';
+ mxUtils.write(span, mxResources.get('width'));
+ div.appendChild(span);
+
+ var widthUpdate, xtUpdate, ytUpdate, xsUpdate, ysUpdate;
+ var width = this.addUnitInput(div, 'pt', 20, 44, function()
+ {
+ widthUpdate.apply(this, arguments);
+ });
+
+ mxUtils.br(div);
+ this.addKeyHandler(width, listener);
+
+ function widthUpdate(evt)
+ {
+ // Maximum stroke width is 999
+ var value = parseInt(width.value);
+ value = Math.min(999, Math.max(1, (isNaN(value)) ? 1 : value));
+
+ if (value != mxUtils.getValue(rect.style, 'width', mxCellRenderer.defaultShapes['flexArrow'].prototype.defaultWidth))
+ {
+ graph.setCellStyles('width', value, graph.getSelectionCells());
+ ui.fireEvent(new mxEventObject('styleChanged', 'keys', ['width'],
+ 'values', [value], 'cells', graph.getSelectionCells()));
+ }
+
+ width.value = value + ' pt';
+ mxEvent.consume(evt);
+ };
+
+ mxEvent.addListener(width, 'blur', widthUpdate);
+ mxEvent.addListener(width, 'change', widthUpdate);
+
+ container.appendChild(div);
+
+ var divs = this.createPanel();
+ divs.style.paddingBottom = '30px';
+
+ var span = document.createElement('div');
+ span.style.position = 'absolute';
+ span.style.width = '70px';
+ span.style.marginTop = '0px';
+ span.style.fontWeight = 'bold';
+ mxUtils.write(span, 'Start');
+ divs.appendChild(span);
+
+ var xs = this.addUnitInput(divs, 'pt', 84, 44, function()
+ {
+ xsUpdate.apply(this, arguments);
+ });
+ var ys = this.addUnitInput(divs, 'pt', 20, 44, function()
+ {
+ ysUpdate.apply(this, arguments);
+ });
+
+ mxUtils.br(divs);
+ this.addLabel(divs, mxResources.get('left'), 84);
+ this.addLabel(divs, mxResources.get('top'), 20);
+ container.appendChild(divs);
+ this.addKeyHandler(xs, listener);
+ this.addKeyHandler(ys, listener);
+
+ var divt = this.createPanel();
+ divt.style.paddingBottom = '30px';
+
+ var span = document.createElement('div');
+ span.style.position = 'absolute';
+ span.style.width = '70px';
+ span.style.marginTop = '0px';
+ span.style.fontWeight = 'bold';
+ mxUtils.write(span, 'End');
+ divt.appendChild(span);
+
+ var xt = this.addUnitInput(divt, 'pt', 84, 44, function()
+ {
+ xtUpdate.apply(this, arguments);
+ });
+ var yt = this.addUnitInput(divt, 'pt', 20, 44, function()
+ {
+ ytUpdate.apply(this, arguments);
+ });
+
+ mxUtils.br(divt);
+ this.addLabel(divt, mxResources.get('left'), 84);
+ this.addLabel(divt, mxResources.get('top'), 20);
+ container.appendChild(divt);
+ this.addKeyHandler(xt, listener);
+ this.addKeyHandler(yt, listener);
+
+ var listener = mxUtils.bind(this, function(sender, evt, force)
+ {
+ rect = this.format.getSelectionState();
+ var cell = graph.getSelectionCell();
+
+ if (rect.style.shape == 'link' || rect.style.shape == 'flexArrow')
+ {
+ div.style.display = '';
+
+ if (force || document.activeElement != width)
+ {
+ var value = mxUtils.getValue(rect.style, 'width',
+ mxCellRenderer.defaultShapes['flexArrow'].prototype.defaultWidth);
+ width.value = value + ' pt';
+ }
+ }
+ else
+ {
+ div.style.display = 'none';
+ }
+
+ if (graph.getSelectionCount() == 1 && graph.model.isEdge(cell))
+ {
+ var geo = graph.model.getGeometry(cell);
+
+ if (geo.sourcePoint != null && graph.model.getTerminal(cell, true) == null)
+ {
+ xs.value = geo.sourcePoint.x;
+ ys.value = geo.sourcePoint.y;
+ }
+ else
+ {
+ divs.style.display = 'none';
+ }
+
+ if (geo.targetPoint != null && graph.model.getTerminal(cell, false) == null)
+ {
+ xt.value = geo.targetPoint.x;
+ yt.value = geo.targetPoint.y;
+ }
+ else
+ {
+ divt.style.display = 'none';
+ }
+ }
+ else
+ {
+ divs.style.display = 'none';
+ divt.style.display = 'none';
+ }
+ });
+
+ xsUpdate = this.addEdgeGeometryHandler(xs, function(geo, value)
+ {
+ geo.sourcePoint.x = value;
+ });
+
+ ysUpdate = this.addEdgeGeometryHandler(ys, function(geo, value)
+ {
+ geo.sourcePoint.y = value;
+ });
+
+ xtUpdate = this.addEdgeGeometryHandler(xt, function(geo, value)
+ {
+ geo.targetPoint.x = value;
+ });
+
+ ytUpdate = this.addEdgeGeometryHandler(yt, function(geo, value)
+ {
+ geo.targetPoint.y = value;
+ });
+
+ graph.getModel().addListener(mxEvent.CHANGE, listener);
+ this.listeners.push({destroy: function() { graph.getModel().removeListener(listener); }});
+ listener();
+};
+
+/**
+ * Adds the label menu items to the given menu and parent.
+ */
+TextFormatPanel = function(format, editorUi, container)
+{
+ BaseFormatPanel.call(this, format, editorUi, container);
+ this.init();
+};
+
+mxUtils.extend(TextFormatPanel, BaseFormatPanel);
+
+/**
+ * Adds the label menu items to the given menu and parent.
+ */
+TextFormatPanel.prototype.init = function()
+{
+ this.container.style.borderBottom = 'none';
+ this.addFont(this.container);
+};
+
+/**
+ * Adds the label menu items to the given menu and parent.
+ */
+TextFormatPanel.prototype.addFont = function(container)
+{
+ var ui = this.editorUi;
+ var editor = ui.editor;
+ var graph = editor.graph;
+ var ss = this.format.getSelectionState();
+
+ var title = this.createTitle(mxResources.get('font'));
+ title.style.paddingLeft = '18px';
+ title.style.paddingTop = '10px';
+ title.style.paddingBottom = '6px';
+ container.appendChild(title);
+
+ var stylePanel = this.createPanel();
+ stylePanel.style.paddingTop = '2px';
+ stylePanel.style.paddingBottom = '2px';
+ stylePanel.style.position = 'relative';
+ stylePanel.style.marginLeft = '-2px';
+ stylePanel.style.borderWidth = '0px';
+ stylePanel.className = 'geToolbarContainer';
+
+ if (mxClient.IS_QUIRKS)
+ {
+ stylePanel.style.display = 'block';
+ }
+
+ if (graph.cellEditor.isContentEditing())
+ {
+ var cssPanel = stylePanel.cloneNode();
+
+ var cssMenu = this.editorUi.toolbar.addMenu(mxResources.get('style'),
+ mxResources.get('style'), true, 'formatBlock', cssPanel, null, true);
+ cssMenu.style.color = 'rgb(112, 112, 112)';
+ cssMenu.style.whiteSpace = 'nowrap';
+ cssMenu.style.overflow = 'hidden';
+ cssMenu.style.margin = '0px';
+ this.addArrow(cssMenu);
+ cssMenu.style.width = '192px';
+ cssMenu.style.height = '15px';
+
+ var arrow = cssMenu.getElementsByTagName('div')[0];
+ arrow.style.cssFloat = 'right';
+ container.appendChild(cssPanel);
+ }
+
+ container.appendChild(stylePanel);
+
+ var colorPanel = this.createPanel();
+ colorPanel.style.marginTop = '8px';
+ colorPanel.style.borderTop = '1px solid #c0c0c0';
+ colorPanel.style.paddingTop = '6px';
+ colorPanel.style.paddingBottom = '6px';
+
+ var fontMenu = this.editorUi.toolbar.addMenu('Helvetica', mxResources.get('fontFamily'),
+ true, 'fontFamily', stylePanel, null, true);
+ fontMenu.style.color = 'rgb(112, 112, 112)';
+ fontMenu.style.whiteSpace = 'nowrap';
+ fontMenu.style.overflow = 'hidden';
+ fontMenu.style.margin = '0px';
+
+ this.addArrow(fontMenu);
+ fontMenu.style.width = '192px';
+ fontMenu.style.height = '15px';
+
+ var stylePanel2 = stylePanel.cloneNode(false);
+ stylePanel2.style.marginLeft = '-3px';
+ var fontStyleItems = this.editorUi.toolbar.addItems(['bold', 'italic', 'underline'], stylePanel2, true);
+ fontStyleItems[0].setAttribute('title', mxResources.get('bold') + ' (' + this.editorUi.actions.get('bold').shortcut + ')');
+ fontStyleItems[1].setAttribute('title', mxResources.get('italic') + ' (' + this.editorUi.actions.get('italic').shortcut + ')');
+ fontStyleItems[2].setAttribute('title', mxResources.get('underline') + ' (' + this.editorUi.actions.get('underline').shortcut + ')');
+
+ var verticalItem = this.editorUi.toolbar.addItems(['vertical'], stylePanel2, true)[0];
+
+ if (mxClient.IS_QUIRKS)
+ {
+ mxUtils.br(container);
+ }
+
+ container.appendChild(stylePanel2);
+
+ this.styleButtons(fontStyleItems);
+ this.styleButtons([verticalItem]);
+
+ var stylePanel3 = stylePanel.cloneNode(false);
+ stylePanel3.style.marginLeft = '-3px';
+ stylePanel3.style.paddingBottom = '0px';
+
+ // Helper function to return a wrapper function does not pass any arguments
+ var callFn = function(fn)
+ {
+ return function()
+ {
+ return fn();
+ };
+ };
+
+ var left = this.editorUi.toolbar.addButton('geSprite-left', mxResources.get('left'),
+ (graph.cellEditor.isContentEditing()) ?
+ function(evt)
+ {
+ graph.cellEditor.alignText(mxConstants.ALIGN_LEFT, evt);
+ } : callFn(this.editorUi.menus.createStyleChangeFunction([mxConstants.STYLE_ALIGN], [mxConstants.ALIGN_LEFT])), stylePanel3);
+ var center = this.editorUi.toolbar.addButton('geSprite-center', mxResources.get('center'),
+ (graph.cellEditor.isContentEditing()) ?
+ function(evt)
+ {
+ graph.cellEditor.alignText(mxConstants.ALIGN_CENTER, evt);
+ } : callFn(this.editorUi.menus.createStyleChangeFunction([mxConstants.STYLE_ALIGN], [mxConstants.ALIGN_CENTER])), stylePanel3);
+ var right = this.editorUi.toolbar.addButton('geSprite-right', mxResources.get('right'),
+ (graph.cellEditor.isContentEditing()) ?
+ function(evt)
+ {
+ graph.cellEditor.alignText(mxConstants.ALIGN_RIGHT, evt);
+ } : callFn(this.editorUi.menus.createStyleChangeFunction([mxConstants.STYLE_ALIGN], [mxConstants.ALIGN_RIGHT])), stylePanel3);
+
+ this.styleButtons([left, center, right]);
+
+ // Quick hack for strikethrough
+ // TODO: Add translations and toggle state
+ if (graph.cellEditor.isContentEditing())
+ {
+ var strike = this.editorUi.toolbar.addButton('geSprite-removeformat', mxResources.get('strikethrough'),
+ function()
+ {
+ document.execCommand('strikeThrough', false, null);
+ }, stylePanel2);
+ this.styleButtons([strike]);
+
+ strike.firstChild.style.background = 'url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCI+PGRlZnM+PHBhdGggaWQ9ImEiIGQ9Ik0wIDBoMjR2MjRIMFYweiIvPjwvZGVmcz48Y2xpcFBhdGggaWQ9ImIiPjx1c2UgeGxpbms6aHJlZj0iI2EiIG92ZXJmbG93PSJ2aXNpYmxlIi8+PC9jbGlwUGF0aD48cGF0aCBjbGlwLXBhdGg9InVybCgjYikiIGZpbGw9IiMwMTAxMDEiIGQ9Ik03LjI0IDguNzVjLS4yNi0uNDgtLjM5LTEuMDMtLjM5LTEuNjcgMC0uNjEuMTMtMS4xNi40LTEuNjcuMjYtLjUuNjMtLjkzIDEuMTEtMS4yOS40OC0uMzUgMS4wNS0uNjMgMS43LS44My42Ni0uMTkgMS4zOS0uMjkgMi4xOC0uMjkuODEgMCAxLjU0LjExIDIuMjEuMzQuNjYuMjIgMS4yMy41NCAxLjY5Ljk0LjQ3LjQuODMuODggMS4wOCAxLjQzLjI1LjU1LjM4IDEuMTUuMzggMS44MWgtMy4wMWMwLS4zMS0uMDUtLjU5LS4xNS0uODUtLjA5LS4yNy0uMjQtLjQ5LS40NC0uNjgtLjItLjE5LS40NS0uMzMtLjc1LS40NC0uMy0uMS0uNjYtLjE2LTEuMDYtLjE2LS4zOSAwLS43NC4wNC0xLjAzLjEzLS4yOS4wOS0uNTMuMjEtLjcyLjM2LS4xOS4xNi0uMzQuMzQtLjQ0LjU1LS4xLjIxLS4xNS40My0uMTUuNjYgMCAuNDguMjUuODguNzQgMS4yMS4zOC4yNS43Ny40OCAxLjQxLjdINy4zOWMtLjA1LS4wOC0uMTEtLjE3LS4xNS0uMjV6TTIxIDEydi0ySDN2Mmg5LjYyYy4xOC4wNy40LjE0LjU1LjIuMzcuMTcuNjYuMzQuODcuNTEuMjEuMTcuMzUuMzYuNDMuNTcuMDcuMi4xMS40My4xMS42OSAwIC4yMy0uMDUuNDUtLjE0LjY2LS4wOS4yLS4yMy4zOC0uNDIuNTMtLjE5LjE1LS40Mi4yNi0uNzEuMzUtLjI5LjA4LS42My4xMy0xLjAxLjEzLS40MyAwLS44My0uMDQtMS4xOC0uMTNzLS42Ni0uMjMtLjkxLS40MmMtLjI1LS4xOS0uNDUtLjQ0LS41OS0uNzUtLjE0LS4zMS0uMjUtLjc2LS4yNS0xLjIxSDYuNGMwIC41NS4wOCAxLjEzLjI0IDEuNTguMTYuNDUuMzcuODUuNjUgMS4yMS4yOC4zNS42LjY2Ljk4LjkyLjM3LjI2Ljc4LjQ4IDEuMjIuNjUuNDQuMTcuOS4zIDEuMzguMzkuNDguMDguOTYuMTMgMS40NC4xMy44IDAgMS41My0uMDkgMi4xOC0uMjhzMS4yMS0uNDUgMS42Ny0uNzljLjQ2LS4zNC44Mi0uNzcgMS4wNy0xLjI3cy4zOC0xLjA3LjM4LTEuNzFjMC0uNi0uMS0xLjE0LS4zMS0xLjYxLS4wNS0uMTEtLjExLS4yMy0uMTctLjMzSDIxeiIvPjwvc3ZnPg==)';
+ strike.firstChild.style.backgroundPosition = '2px 2px';
+ strike.firstChild.style.backgroundSize = '18px 18px';
+
+ this.styleButtons([strike]);
+ }
+
+ var top = this.editorUi.toolbar.addButton('geSprite-top', mxResources.get('top'),
+ callFn(this.editorUi.menus.createStyleChangeFunction([mxConstants.STYLE_VERTICAL_ALIGN], [mxConstants.ALIGN_TOP])), stylePanel3);
+ var middle = this.editorUi.toolbar.addButton('geSprite-middle', mxResources.get('middle'),
+ callFn(this.editorUi.menus.createStyleChangeFunction([mxConstants.STYLE_VERTICAL_ALIGN], [mxConstants.ALIGN_MIDDLE])), stylePanel3);
+ var bottom = this.editorUi.toolbar.addButton('geSprite-bottom', mxResources.get('bottom'),
+ callFn(this.editorUi.menus.createStyleChangeFunction([mxConstants.STYLE_VERTICAL_ALIGN], [mxConstants.ALIGN_BOTTOM])), stylePanel3);
+
+ this.styleButtons([top, middle, bottom]);
+
+ if (mxClient.IS_QUIRKS)
+ {
+ mxUtils.br(container);
+ }
+
+ container.appendChild(stylePanel3);
+
+ // Hack for updating UI state below based on current text selection
+ // currentTable is the current selected DOM table updated below
+ var sub, sup, full, tableWrapper, currentTable, tableCell, tableRow;
+
+ if (graph.cellEditor.isContentEditing())
+ {
+ top.style.display = 'none';
+ middle.style.display = 'none';
+ bottom.style.display = 'none';
+ verticalItem.style.display = 'none';
+
+ full = this.editorUi.toolbar.addButton('geSprite-justifyfull', mxResources.get('block'),
+ function()
+ {
+ if (full.style.opacity == 1)
+ {
+ document.execCommand('justifyfull', false, null);
+ }
+ }, stylePanel3);
+ full.style.marginRight = '9px';
+ full.style.opacity = 1;
+
+ this.styleButtons([full,
+ sub = this.editorUi.toolbar.addButton('geSprite-subscript',
+ mxResources.get('subscript') + ' (' + Editor.ctrlKey + '+,)',
+ function()
+ {
+ document.execCommand('subscript', false, null);
+ }, stylePanel3), sup = this.editorUi.toolbar.addButton('geSprite-superscript',
+ mxResources.get('superscript') + ' (' + Editor.ctrlKey + '+.)',
+ function()
+ {
+ document.execCommand('superscript', false, null);
+ }, stylePanel3)]);
+ sub.style.marginLeft = '9px';
+
+ var tmp = stylePanel3.cloneNode(false);
+ tmp.style.paddingTop = '4px';
+ var btns = [this.editorUi.toolbar.addButton('geSprite-orderedlist', mxResources.get('numberedList'),
+ function()
+ {
+ document.execCommand('insertorderedlist', false, null);
+ }, tmp),
+ this.editorUi.toolbar.addButton('geSprite-unorderedlist', mxResources.get('bulletedList'),
+ function()
+ {
+ document.execCommand('insertunorderedlist', false, null);
+ }, tmp),
+ this.editorUi.toolbar.addButton('geSprite-outdent', mxResources.get('decreaseIndent'),
+ function()
+ {
+ document.execCommand('outdent', false, null);
+ }, tmp),
+ this.editorUi.toolbar.addButton('geSprite-indent', mxResources.get('increaseIndent'),
+ function()
+ {
+ document.execCommand('indent', false, null);
+ }, tmp),
+ this.editorUi.toolbar.addButton('geSprite-removeformat', mxResources.get('removeFormat'),
+ function()
+ {
+ document.execCommand('removeformat', false, null);
+ }, tmp),
+ this.editorUi.toolbar.addButton('geSprite-code', mxResources.get('html'),
+ function()
+ {
+ graph.cellEditor.toggleViewMode();
+ }, tmp)];
+ this.styleButtons(btns);
+ btns[btns.length - 2].style.marginLeft = '9px';
+
+ if (mxClient.IS_QUIRKS)
+ {
+ mxUtils.br(container);
+ tmp.style.height = '40';
+ }
+
+ container.appendChild(tmp);
+ }
+ else
+ {
+ fontStyleItems[2].style.marginRight = '9px';
+ right.style.marginRight = '9px';
+ }
+
+ // Label position
+ var stylePanel4 = stylePanel.cloneNode(false);
+ stylePanel4.style.marginLeft = '0px';
+ stylePanel4.style.paddingTop = '8px';
+ stylePanel4.style.paddingBottom = '4px';
+ stylePanel4.style.fontWeight = 'normal';
+
+ mxUtils.write(stylePanel4, mxResources.get('position'));
+
+ // Adds label position options
+ var positionSelect = document.createElement('select');
+ positionSelect.style.position = 'absolute';
+ positionSelect.style.right = '20px';
+ positionSelect.style.width = '97px';
+ positionSelect.style.marginTop = '-2px';
+
+ var directions = ['topLeft', 'top', 'topRight', 'left', 'center', 'right', 'bottomLeft', 'bottom', 'bottomRight'];
+ var lset = {'topLeft': [mxConstants.ALIGN_LEFT, mxConstants.ALIGN_TOP, mxConstants.ALIGN_RIGHT, mxConstants.ALIGN_BOTTOM],
+ 'top': [mxConstants.ALIGN_CENTER, mxConstants.ALIGN_TOP, mxConstants.ALIGN_CENTER, mxConstants.ALIGN_BOTTOM],
+ 'topRight': [mxConstants.ALIGN_RIGHT, mxConstants.ALIGN_TOP, mxConstants.ALIGN_LEFT, mxConstants.ALIGN_BOTTOM],
+ 'left': [mxConstants.ALIGN_LEFT, mxConstants.ALIGN_MIDDLE, mxConstants.ALIGN_RIGHT, mxConstants.ALIGN_MIDDLE],
+ 'center': [mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE],
+ 'right': [mxConstants.ALIGN_RIGHT, mxConstants.ALIGN_MIDDLE, mxConstants.ALIGN_LEFT, mxConstants.ALIGN_MIDDLE],
+ 'bottomLeft': [mxConstants.ALIGN_LEFT, mxConstants.ALIGN_BOTTOM, mxConstants.ALIGN_RIGHT, mxConstants.ALIGN_TOP],
+ 'bottom': [mxConstants.ALIGN_CENTER, mxConstants.ALIGN_BOTTOM, mxConstants.ALIGN_CENTER, mxConstants.ALIGN_TOP],
+ 'bottomRight': [mxConstants.ALIGN_RIGHT, mxConstants.ALIGN_BOTTOM, mxConstants.ALIGN_LEFT, mxConstants.ALIGN_TOP]};
+
+ for (var i = 0; i < directions.length; i++)
+ {
+ var positionOption = document.createElement('option');
+ positionOption.setAttribute('value', directions[i]);
+ mxUtils.write(positionOption, mxResources.get(directions[i]));
+ positionSelect.appendChild(positionOption);
+ }
+
+ stylePanel4.appendChild(positionSelect);
+
+ // Writing direction
+ var stylePanel5 = stylePanel.cloneNode(false);
+ stylePanel5.style.marginLeft = '0px';
+ stylePanel5.style.paddingTop = '4px';
+ stylePanel5.style.paddingBottom = '4px';
+ stylePanel5.style.fontWeight = 'normal';
+
+ mxUtils.write(stylePanel5, mxResources.get('writingDirection'));
+
+ // Adds writing direction options
+ // LATER: Handle reselect of same option in all selects (change event
+ // is not fired for same option so have opened state on click) and
+ // handle multiple different styles for current selection
+ var dirSelect = document.createElement('select');
+ dirSelect.style.position = 'absolute';
+ dirSelect.style.right = '20px';
+ dirSelect.style.width = '97px';
+ dirSelect.style.marginTop = '-2px';
+
+ // NOTE: For automatic we use the value null since automatic
+ // requires the text to be non formatted and non-wrapped
+ var dirs = ['automatic', 'leftToRight', 'rightToLeft'];
+ var dirSet = {'automatic': null,
+ 'leftToRight': mxConstants.TEXT_DIRECTION_LTR,
+ 'rightToLeft': mxConstants.TEXT_DIRECTION_RTL};
+
+ for (var i = 0; i < dirs.length; i++)
+ {
+ var dirOption = document.createElement('option');
+ dirOption.setAttribute('value', dirs[i]);
+ mxUtils.write(dirOption, mxResources.get(dirs[i]));
+ dirSelect.appendChild(dirOption);
+ }
+
+ stylePanel5.appendChild(dirSelect);
+
+ if (!graph.isEditing())
+ {
+ container.appendChild(stylePanel4);
+
+ mxEvent.addListener(positionSelect, 'change', function(evt)
+ {
+ graph.getModel().beginUpdate();
+ try
+ {
+ var vals = lset[positionSelect.value];
+
+ if (vals != null)
+ {
+ graph.setCellStyles(mxConstants.STYLE_LABEL_POSITION, vals[0], graph.getSelectionCells());
+ graph.setCellStyles(mxConstants.STYLE_VERTICAL_LABEL_POSITION, vals[1], graph.getSelectionCells());
+ graph.setCellStyles(mxConstants.STYLE_ALIGN, vals[2], graph.getSelectionCells());
+ graph.setCellStyles(mxConstants.STYLE_VERTICAL_ALIGN, vals[3], graph.getSelectionCells());
+ }
+ }
+ finally
+ {
+ graph.getModel().endUpdate();
+ }
+
+ mxEvent.consume(evt);
+ });
+
+ // LATER: Update dir in text editor while editing and update style with label
+ // NOTE: The tricky part is handling and passing on the auto value
+ container.appendChild(stylePanel5);
+
+ mxEvent.addListener(dirSelect, 'change', function(evt)
+ {
+ graph.setCellStyles(mxConstants.STYLE_TEXT_DIRECTION, dirSet[dirSelect.value], graph.getSelectionCells());
+ mxEvent.consume(evt);
+ });
+ }
+
+ // Font size
+ var input = document.createElement('input');
+ input.style.textAlign = 'right';
+ input.style.marginTop = '4px';
+
+ if (!mxClient.IS_QUIRKS)
+ {
+ input.style.position = 'absolute';
+ input.style.right = '32px';
+ }
+
+ input.style.width = '46px';
+ input.style.height = (mxClient.IS_QUIRKS) ? '21px' : '17px';
+ stylePanel2.appendChild(input);
+
+ // Workaround for font size 4 if no text is selected is update font size below
+ // after first character was entered (as the font element is lazy created)
+ var pendingFontSize = null;
+
+ var inputUpdate = this.installInputHandler(input, mxConstants.STYLE_FONTSIZE, Menus.prototype.defaultFontSize, 1, 999, ' pt',
+ function(fontSize)
+ {
+ // IE does not support containsNode
+ // KNOWN: Fixes font size issues but bypasses undo
+ if (window.getSelection && !mxClient.IS_IE && !mxClient.IS_IE11)
+ {
+ var selection = window.getSelection();
+ var container = (selection.rangeCount > 0) ? selection.getRangeAt(0).commonAncestorContainer :
+ graph.cellEditor.textarea;
+
+ function updateSize(elt, ignoreContains)
+ {
+ if (graph.cellEditor.textarea != null && elt != graph.cellEditor.textarea &&
+ graph.cellEditor.textarea.contains(elt) &&
+ (ignoreContains || selection.containsNode(elt, true)))
+ {
+ if (elt.nodeName == 'FONT')
+ {
+ elt.removeAttribute('size');
+ elt.style.fontSize = fontSize + 'px';
+ }
+ else
+ {
+ var css = mxUtils.getCurrentStyle(elt);
+
+ if (css.fontSize != fontSize + 'px')
+ {
+ if (mxUtils.getCurrentStyle(elt.parentNode).fontSize != fontSize + 'px')
+ {
+ elt.style.fontSize = fontSize + 'px';
+ }
+ else
+ {
+ elt.style.fontSize = '';
+ }
+ }
+ }
+ }
+ };
+
+ // Wraps text node or mixed selection with leading text in a font element
+ if (container == graph.cellEditor.textarea ||
+ container.nodeType != mxConstants.NODETYPE_ELEMENT)
+ {
+ document.execCommand('fontSize', false, '1');
+ }
+
+ if (container != graph.cellEditor.textarea)
+ {
+ container = container.parentNode;
+ }
+
+ if (container != null && container.nodeType == mxConstants.NODETYPE_ELEMENT)
+ {
+ var elts = container.getElementsByTagName('*');
+ updateSize(container);
+
+ for (var i = 0; i < elts.length; i++)
+ {
+ updateSize(elts[i]);
+ }
+ }
+
+ input.value = fontSize + ' pt';
+ }
+ else if (window.getSelection || document.selection)
+ {
+ // Checks selection
+ var par = null;
+
+ if (document.selection)
+ {
+ par = document.selection.createRange().parentElement();
+ }
+ else
+ {
+ var selection = window.getSelection();
+
+ if (selection.rangeCount > 0)
+ {
+ par = selection.getRangeAt(0).commonAncestorContainer;
+ }
+ }
+
+ // Node.contains does not work for text nodes in IE11
+ function isOrContains(container, node)
+ {
+ while (node != null)
+ {
+ if (node === container)
+ {
+ return true;
+ }
+
+ node = node.parentNode;
+ }
+
+ return false;
+ };
+
+ if (par != null && isOrContains(graph.cellEditor.textarea, par))
+ {
+ pendingFontSize = fontSize;
+
+ // Workaround for can't set font size in px is to change font size afterwards
+ document.execCommand('fontSize', false, '4');
+ var elts = graph.cellEditor.textarea.getElementsByTagName('font');
+
+ for (var i = 0; i < elts.length; i++)
+ {
+ if (elts[i].getAttribute('size') == '4')
+ {
+ elts[i].removeAttribute('size');
+ elts[i].style.fontSize = pendingFontSize + 'px';
+
+ // Overrides fontSize in input with the one just assigned as a workaround
+ // for potential fontSize values of parent elements that don't match
+ window.setTimeout(function()
+ {
+ input.value = pendingFontSize + ' pt';
+ pendingFontSize = null;
+ }, 0);
+
+ break;
+ }
+ }
+ }
+ }
+ }, true);
+
+ var stepper = this.createStepper(input, inputUpdate, 1, 10, true, Menus.prototype.defaultFontSize);
+ stepper.style.display = input.style.display;
+ stepper.style.marginTop = '4px';
+
+ if (!mxClient.IS_QUIRKS)
+ {
+ stepper.style.right = '20px';
+ }
+
+ stylePanel2.appendChild(stepper);
+
+ var arrow = fontMenu.getElementsByTagName('div')[0];
+ arrow.style.cssFloat = 'right';
+
+ var bgColorApply = null;
+ var currentBgColor = '#ffffff';
+
+ var fontColorApply = null;
+ var currentFontColor = '#000000';
+
+ var bgPanel = (graph.cellEditor.isContentEditing()) ? this.createColorOption(mxResources.get('backgroundColor'), function()
+ {
+ return currentBgColor;
+ }, function(color)
+ {
+ document.execCommand('backcolor', false, (color != mxConstants.NONE) ? color : 'transparent');
+ }, '#ffffff',
+ {
+ install: function(apply) { bgColorApply = apply; },
+ destroy: function() { bgColorApply = null; }
+ }, null, true) : this.createCellColorOption(mxResources.get('backgroundColor'), mxConstants.STYLE_LABEL_BACKGROUNDCOLOR, '#ffffff', null, function(color)
+ {
+ graph.updateLabelElements(graph.getSelectionCells(), function(elt)
+ {
+ elt.style.backgroundColor = null;
+ });
+ });
+ bgPanel.style.fontWeight = 'bold';
+
+ var borderPanel = this.createCellColorOption(mxResources.get('borderColor'), mxConstants.STYLE_LABEL_BORDERCOLOR, '#000000');
+ borderPanel.style.fontWeight = 'bold';
+
+ var panel = (graph.cellEditor.isContentEditing()) ? this.createColorOption(mxResources.get('fontColor'), function()
+ {
+ return currentFontColor;
+ }, function(color)
+ {
+ if (mxClient.IS_FF)
+ {
+ // Workaround for Firefox that adds the font element around
+ // anchor elements which ignore inherited colors is to move
+ // the font element inside anchor elements
+ var tmp = graph.cellEditor.textarea.getElementsByTagName('font');
+ var oldFonts = [];
+
+ for (var i = 0; i < tmp.length; i++)
+ {
+ oldFonts.push(
+ {
+ node: tmp[i],
+ color: tmp[i].getAttribute('color')
+ });
+ }
+
+ document.execCommand('forecolor', false, (color != mxConstants.NONE) ?
+ color : 'transparent');
+
+ // Finds the new or changed font element
+ var newFonts = graph.cellEditor.textarea.getElementsByTagName('font');
+
+ for (var i = 0; i < newFonts.length; i++)
+ {
+ if (i >= oldFonts.length || newFonts[i] != oldFonts[i].node ||
+ (newFonts[i] == oldFonts[i].node &&
+ newFonts[i].getAttribute('color') != oldFonts[i].color))
+ {
+ var child = newFonts[i].firstChild;
+
+ // Moves the font element to inside the anchor element and adopts all children
+ if (child != null && child.nodeName == 'A' && child.nextSibling ==
+ null &&
+ child.firstChild != null)
+ {
+ var parent = newFonts[i].parentNode;
+ parent.insertBefore(child, newFonts[i]);
+ var tmp = child.firstChild;
+
+ while (tmp != null)
+ {
+ var next = tmp.nextSibling;
+ newFonts[i].appendChild(tmp);
+ tmp = next;
+ }
+
+ child.appendChild(newFonts[i]);
+ }
+
+ break;
+ }
+ }
+ }
+ else
+ {
+ document.execCommand('forecolor', false, (color != mxConstants.NONE) ?
+ color : 'transparent');
+ }
+ }, '#000000',
+ {
+ install: function(apply) { fontColorApply = apply; },
+ destroy: function() { fontColorApply = null; }
+ }, null, true) : this.createCellColorOption(mxResources.get('fontColor'), mxConstants.STYLE_FONTCOLOR, '#000000', function(color)
+ {
+ if (color == null || color == mxConstants.NONE)
+ {
+ bgPanel.style.display = 'none';
+ }
+ else
+ {
+ bgPanel.style.display = '';
+ }
+
+ borderPanel.style.display = bgPanel.style.display;
+ }, function(color)
+ {
+ if (color == null || color == mxConstants.NONE)
+ {
+ graph.setCellStyles(mxConstants.STYLE_NOLABEL, '1', graph.getSelectionCells());
+ }
+ else
+ {
+ graph.setCellStyles(mxConstants.STYLE_NOLABEL, null, graph.getSelectionCells());
+ }
+
+ graph.updateLabelElements(graph.getSelectionCells(), function(elt)
+ {
+ elt.removeAttribute('color');
+ elt.style.color = null;
+ });
+ });
+ panel.style.fontWeight = 'bold';
+
+ colorPanel.appendChild(panel);
+ colorPanel.appendChild(bgPanel);
+
+ if (!graph.cellEditor.isContentEditing())
+ {
+ colorPanel.appendChild(borderPanel);
+ }
+
+ container.appendChild(colorPanel);
+
+ var extraPanel = this.createPanel();
+ extraPanel.style.paddingTop = '2px';
+ extraPanel.style.paddingBottom = '4px';
+
+ // LATER: Fix toggle using '' instead of 'null'
+ var wwOpt = this.createCellOption(mxResources.get('wordWrap'), mxConstants.STYLE_WHITE_SPACE, null, 'wrap', 'null', null, null, true);
+ wwOpt.style.fontWeight = 'bold';
+
+ // Word wrap in edge labels only supported via labelWidth style
+ if (!ss.containsLabel && !ss.autoSize && ss.edges.length == 0)
+ {
+ extraPanel.appendChild(wwOpt);
+ }
+
+ // Delegates switch of style to formattedText action as it also convertes newlines
+ var htmlOpt = this.createCellOption(mxResources.get('formattedText'), 'html', '0',
+ null, null, null, ui.actions.get('formattedText'));
+ htmlOpt.style.fontWeight = 'bold';
+ extraPanel.appendChild(htmlOpt);
+
+ var spacingPanel = this.createPanel();
+ spacingPanel.style.paddingTop = '10px';
+ spacingPanel.style.paddingBottom = '28px';
+ spacingPanel.style.fontWeight = 'normal';
+
+ var span = document.createElement('div');
+ span.style.position = 'absolute';
+ span.style.width = '70px';
+ span.style.marginTop = '0px';
+ span.style.fontWeight = 'bold';
+ mxUtils.write(span, mxResources.get('spacing'));
+ spacingPanel.appendChild(span);
+
+ var topUpdate, globalUpdate, leftUpdate, bottomUpdate, rightUpdate;
+ var topSpacing = this.addUnitInput(spacingPanel, 'pt', 91, 44, function()
+ {
+ topUpdate.apply(this, arguments);
+ });
+ var globalSpacing = this.addUnitInput(spacingPanel, 'pt', 20, 44, function()
+ {
+ globalUpdate.apply(this, arguments);
+ });
+
+ mxUtils.br(spacingPanel);
+ this.addLabel(spacingPanel, mxResources.get('top'), 91);
+ this.addLabel(spacingPanel, mxResources.get('global'), 20);
+ mxUtils.br(spacingPanel);
+ mxUtils.br(spacingPanel);
+
+ var leftSpacing = this.addUnitInput(spacingPanel, 'pt', 162, 44, function()
+ {
+ leftUpdate.apply(this, arguments);
+ });
+ var bottomSpacing = this.addUnitInput(spacingPanel, 'pt', 91, 44, function()
+ {
+ bottomUpdate.apply(this, arguments);
+ });
+ var rightSpacing = this.addUnitInput(spacingPanel, 'pt', 20, 44, function()
+ {
+ rightUpdate.apply(this, arguments);
+ });
+
+ mxUtils.br(spacingPanel);
+ this.addLabel(spacingPanel, mxResources.get('left'), 162);
+ this.addLabel(spacingPanel, mxResources.get('bottom'), 91);
+ this.addLabel(spacingPanel, mxResources.get('right'), 20);
+
+ if (!graph.cellEditor.isContentEditing())
+ {
+ container.appendChild(extraPanel);
+ container.appendChild(this.createRelativeOption(mxResources.get('opacity'), mxConstants.STYLE_TEXT_OPACITY));
+ container.appendChild(spacingPanel);
+ }
+ else
+ {
+ var selState = null;
+ var lineHeightInput = null;
+
+ container.appendChild(this.createRelativeOption(mxResources.get('lineheight'), null, null, function(input)
+ {
+ var value = (input.value == '') ? 120 : parseInt(input.value);
+ value = Math.max(0, (isNaN(value)) ? 120 : value);
+
+ if (selState != null)
+ {
+ graph.cellEditor.restoreSelection(selState);
+ selState = null;
+ }
+
+ var selectedElement = graph.getSelectedElement();
+ var node = selectedElement;
+
+ while (node != null && node.nodeType != mxConstants.NODETYPE_ELEMENT)
+ {
+ node = node.parentNode;
+ }
+
+ if (node != null && node == graph.cellEditor.textarea && graph.cellEditor.textarea.firstChild != null)
+ {
+ if (graph.cellEditor.textarea.firstChild.nodeName != 'P')
+ {
+ graph.cellEditor.textarea.innerHTML = '