elements past the limit
+ .addClass('fc-limited').get(); // hide elements and get a simple DOM-nodes array
+ // iterate though segments in the last allowable level
+ for (i = 0; i < levelSegs.length; i++) {
+ seg = levelSegs[i];
+ emptyCellsUntil(seg.leftCol); // process empty cells before the segment
+ // determine *all* segments below `seg` that occupy the same columns
+ colSegsBelow = [];
+ totalSegsBelow = 0;
+ while (col <= seg.rightCol) {
+ segsBelow = this.getCellSegs(row, col, levelLimit);
+ colSegsBelow.push(segsBelow);
+ totalSegsBelow += segsBelow.length;
+ col++;
+ }
+ if (totalSegsBelow) {
+ td = cellMatrix[levelLimit - 1][seg.leftCol]; // the segment's parent cell
+ rowspan = td.attr('rowspan') || 1;
+ segMoreNodes = [];
+ // make a replacement | for each column the segment occupies. will be one for each colspan
+ for (j = 0; j < colSegsBelow.length; j++) {
+ moreTd = $(' | | ').attr('rowspan', rowspan);
+ segsBelow = colSegsBelow[j];
+ moreLink = this.renderMoreLink(row, seg.leftCol + j, [seg].concat(segsBelow) // count seg as hidden too
+ );
+ moreWrap = $('').append(moreLink);
+ moreTd.append(moreWrap);
+ segMoreNodes.push(moreTd[0]);
+ moreNodes.push(moreTd[0]);
+ }
+ td.addClass('fc-limited').after($(segMoreNodes)); // hide original and inject replacements
+ limitedNodes.push(td[0]);
+ }
+ }
+ emptyCellsUntil(this.colCnt); // finish off the level
+ rowStruct.moreEls = $(moreNodes); // for easy undoing later
+ rowStruct.limitedEls = $(limitedNodes); // for easy undoing later
+ }
+ };
+ // Reveals all levels and removes all "more"-related elements for a grid's row.
+ // `row` is a row number.
+ DayGrid.prototype.unlimitRow = function (row) {
+ var rowStruct = this.eventRenderer.rowStructs[row];
+ if (rowStruct.moreEls) {
+ rowStruct.moreEls.remove();
+ rowStruct.moreEls = null;
+ }
+ if (rowStruct.limitedEls) {
+ rowStruct.limitedEls.removeClass('fc-limited');
+ rowStruct.limitedEls = null;
+ }
+ };
+ // Renders an element that represents hidden event element for a cell.
+ // Responsible for attaching click handler as well.
+ DayGrid.prototype.renderMoreLink = function (row, col, hiddenSegs) {
+ var _this = this;
+ var view = this.view;
+ return $('')
+ .text(this.getMoreLinkText(hiddenSegs.length))
+ .on('click', function (ev) {
+ var clickOption = _this.opt('eventLimitClick');
+ var date = _this.getCellDate(row, col);
+ var moreEl = $(ev.currentTarget);
+ var dayEl = _this.getCellEl(row, col);
+ var allSegs = _this.getCellSegs(row, col);
+ // rescope the segments to be within the cell's date
+ var reslicedAllSegs = _this.resliceDaySegs(allSegs, date);
+ var reslicedHiddenSegs = _this.resliceDaySegs(hiddenSegs, date);
+ if (typeof clickOption === 'function') {
+ // the returned value can be an atomic option
+ clickOption = _this.publiclyTrigger('eventLimitClick', {
+ context: view,
+ args: [
+ {
+ date: date.clone(),
+ dayEl: dayEl,
+ moreEl: moreEl,
+ segs: reslicedAllSegs,
+ hiddenSegs: reslicedHiddenSegs
+ },
+ ev,
+ view
+ ]
+ });
+ }
+ if (clickOption === 'popover') {
+ _this.showSegPopover(row, col, moreEl, reslicedAllSegs);
+ }
+ else if (typeof clickOption === 'string') {
+ view.calendar.zoomTo(date, clickOption);
+ }
+ });
+ };
+ // Reveals the popover that displays all events within a cell
+ DayGrid.prototype.showSegPopover = function (row, col, moreLink, segs) {
+ var _this = this;
+ var view = this.view;
+ var moreWrap = moreLink.parent(); // the wrapper around the
+ var topEl; // the element we want to match the top coordinate of
+ var options;
+ if (this.rowCnt === 1) {
+ topEl = view.el; // will cause the popover to cover any sort of header
+ }
+ else {
+ topEl = this.rowEls.eq(row); // will align with top of row
+ }
+ options = {
+ className: 'fc-more-popover ' + view.calendar.theme.getClass('popover'),
+ content: this.renderSegPopoverContent(row, col, segs),
+ parentEl: view.el,
+ top: topEl.offset().top,
+ autoHide: true,
+ viewportConstrain: this.opt('popoverViewportConstrain'),
+ hide: function () {
+ // kill everything when the popover is hidden
+ // notify events to be removed
+ if (_this.popoverSegs) {
+ _this.triggerBeforeEventSegsDestroyed(_this.popoverSegs);
+ }
+ _this.segPopover.removeElement();
+ _this.segPopover = null;
+ _this.popoverSegs = null;
+ }
+ };
+ // Determine horizontal coordinate.
+ // We use the moreWrap instead of the to avoid border confusion.
+ if (this.isRTL) {
+ options.right = moreWrap.offset().left + moreWrap.outerWidth() + 1; // +1 to be over cell border
+ }
+ else {
+ options.left = moreWrap.offset().left - 1; // -1 to be over cell border
+ }
+ this.segPopover = new Popover_1.default(options);
+ this.segPopover.show();
+ // the popover doesn't live within the grid's container element, and thus won't get the event
+ // delegated-handlers for free. attach event-related handlers to the popover.
+ this.bindAllSegHandlersToEl(this.segPopover.el);
+ this.triggerAfterEventSegsRendered(segs);
+ };
+ // Builds the inner DOM contents of the segment popover
+ DayGrid.prototype.renderSegPopoverContent = function (row, col, segs) {
+ var view = this.view;
+ var theme = view.calendar.theme;
+ var title = this.getCellDate(row, col).format(this.opt('dayPopoverFormat'));
+ var content = $('' +
+ '');
+ var segContainer = content.find('.fc-event-container');
+ var i;
+ // render each seg's `el` and only return the visible segs
+ segs = this.eventRenderer.renderFgSegEls(segs, true); // disableResizing=true
+ this.popoverSegs = segs;
+ for (i = 0; i < segs.length; i++) {
+ // because segments in the popover are not part of a grid coordinate system, provide a hint to any
+ // grids that want to do drag-n-drop about which cell it came from
+ this.hitsNeeded();
+ segs[i].hit = this.getCellHit(row, col);
+ this.hitsNotNeeded();
+ segContainer.append(segs[i].el);
+ }
+ return content;
+ };
+ // Given the events within an array of segment objects, reslice them to be in a single day
+ DayGrid.prototype.resliceDaySegs = function (segs, dayDate) {
+ var dayStart = dayDate.clone();
+ var dayEnd = dayStart.clone().add(1, 'days');
+ var dayRange = new UnzonedRange_1.default(dayStart, dayEnd);
+ var newSegs = [];
+ var i;
+ var seg;
+ var slicedRange;
+ for (i = 0; i < segs.length; i++) {
+ seg = segs[i];
+ slicedRange = seg.footprint.componentFootprint.unzonedRange.intersect(dayRange);
+ if (slicedRange) {
+ newSegs.push($.extend({}, seg, {
+ footprint: new EventFootprint_1.default(new ComponentFootprint_1.default(slicedRange, seg.footprint.componentFootprint.isAllDay), seg.footprint.eventDef, seg.footprint.eventInstance),
+ isStart: seg.isStart && slicedRange.isStart,
+ isEnd: seg.isEnd && slicedRange.isEnd
+ }));
+ }
+ }
+ // force an order because eventsToSegs doesn't guarantee one
+ // TODO: research if still needed
+ this.eventRenderer.sortEventSegs(newSegs);
+ return newSegs;
+ };
+ // Generates the text that should be inside a "more" link, given the number of events it represents
+ DayGrid.prototype.getMoreLinkText = function (num) {
+ var opt = this.opt('eventLimitText');
+ if (typeof opt === 'function') {
+ return opt(num);
+ }
+ else {
+ return '+' + num + ' ' + opt;
+ }
+ };
+ // Returns segments within a given cell.
+ // If `startLevel` is specified, returns only events including and below that level. Otherwise returns all segs.
+ DayGrid.prototype.getCellSegs = function (row, col, startLevel) {
+ var segMatrix = this.eventRenderer.rowStructs[row].segMatrix;
+ var level = startLevel || 0;
+ var segs = [];
+ var seg;
+ while (level < segMatrix.length) {
+ seg = segMatrix[level][col];
+ if (seg) {
+ segs.push(seg);
+ }
+ level++;
+ }
+ return segs;
+ };
+ return DayGrid;
+}(InteractiveDateComponent_1.default));
+exports.default = DayGrid;
+DayGrid.prototype.eventRendererClass = DayGridEventRenderer_1.default;
+DayGrid.prototype.businessHourRendererClass = BusinessHourRenderer_1.default;
+DayGrid.prototype.helperRendererClass = DayGridHelperRenderer_1.default;
+DayGrid.prototype.fillRendererClass = DayGridFillRenderer_1.default;
+StandardInteractionsMixin_1.default.mixInto(DayGrid);
+DayTableMixin_1.default.mixInto(DayGrid);
+
+
+/***/ }),
+/* 62 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var util_1 = __webpack_require__(4);
+var Scroller_1 = __webpack_require__(39);
+var View_1 = __webpack_require__(41);
+var BasicViewDateProfileGenerator_1 = __webpack_require__(228);
+var DayGrid_1 = __webpack_require__(61);
+/* An abstract class for the "basic" views, as well as month view. Renders one or more rows of day cells.
+----------------------------------------------------------------------------------------------------------------------*/
+// It is a manager for a DayGrid subcomponent, which does most of the heavy lifting.
+// It is responsible for managing width/height.
+var BasicView = /** @class */ (function (_super) {
+ tslib_1.__extends(BasicView, _super);
+ function BasicView(calendar, viewSpec) {
+ var _this = _super.call(this, calendar, viewSpec) || this;
+ _this.dayGrid = _this.instantiateDayGrid();
+ _this.dayGrid.isRigid = _this.hasRigidRows();
+ if (_this.opt('weekNumbers')) {
+ if (_this.opt('weekNumbersWithinDays')) {
+ _this.dayGrid.cellWeekNumbersVisible = true;
+ _this.dayGrid.colWeekNumbersVisible = false;
+ }
+ else {
+ _this.dayGrid.cellWeekNumbersVisible = false;
+ _this.dayGrid.colWeekNumbersVisible = true;
+ }
+ }
+ _this.addChild(_this.dayGrid);
+ _this.scroller = new Scroller_1.default({
+ overflowX: 'hidden',
+ overflowY: 'auto'
+ });
+ return _this;
+ }
+ // Generates the DayGrid object this view needs. Draws from this.dayGridClass
+ BasicView.prototype.instantiateDayGrid = function () {
+ // generate a subclass on the fly with BasicView-specific behavior
+ // TODO: cache this subclass
+ var subclass = makeDayGridSubclass(this.dayGridClass);
+ return new subclass(this);
+ };
+ BasicView.prototype.executeDateRender = function (dateProfile) {
+ this.dayGrid.breakOnWeeks = /year|month|week/.test(dateProfile.currentRangeUnit);
+ _super.prototype.executeDateRender.call(this, dateProfile);
+ };
+ BasicView.prototype.renderSkeleton = function () {
+ var dayGridContainerEl;
+ var dayGridEl;
+ this.el.addClass('fc-basic-view').html(this.renderSkeletonHtml());
+ this.scroller.render();
+ dayGridContainerEl = this.scroller.el.addClass('fc-day-grid-container');
+ dayGridEl = $('').appendTo(dayGridContainerEl);
+ this.el.find('.fc-body > tr > td').append(dayGridContainerEl);
+ this.dayGrid.headContainerEl = this.el.find('.fc-head-container');
+ this.dayGrid.setElement(dayGridEl);
+ };
+ BasicView.prototype.unrenderSkeleton = function () {
+ this.dayGrid.removeElement();
+ this.scroller.destroy();
+ };
+ // Builds the HTML skeleton for the view.
+ // The day-grid component will render inside of a container defined by this HTML.
+ BasicView.prototype.renderSkeletonHtml = function () {
+ var theme = this.calendar.theme;
+ return '' +
+ '' +
+ (this.opt('columnHeader') ?
+ '' +
+ '' +
+ '' +
+ ' ' +
+ '' :
+ '') +
+ '' +
+ '' +
+ ' | ' +
+ ' ' +
+ '' +
+ ' ';
+ };
+ // Generates an HTML attribute string for setting the width of the week number column, if it is known
+ BasicView.prototype.weekNumberStyleAttr = function () {
+ if (this.weekNumberWidth != null) {
+ return 'style="width:' + this.weekNumberWidth + 'px"';
+ }
+ return '';
+ };
+ // Determines whether each row should have a constant height
+ BasicView.prototype.hasRigidRows = function () {
+ var eventLimit = this.opt('eventLimit');
+ return eventLimit && typeof eventLimit !== 'number';
+ };
+ /* Dimensions
+ ------------------------------------------------------------------------------------------------------------------*/
+ // Refreshes the horizontal dimensions of the view
+ BasicView.prototype.updateSize = function (totalHeight, isAuto, isResize) {
+ var eventLimit = this.opt('eventLimit');
+ var headRowEl = this.dayGrid.headContainerEl.find('.fc-row');
+ var scrollerHeight;
+ var scrollbarWidths;
+ // hack to give the view some height prior to dayGrid's columns being rendered
+ // TODO: separate setting height from scroller VS dayGrid.
+ if (!this.dayGrid.rowEls) {
+ if (!isAuto) {
+ scrollerHeight = this.computeScrollerHeight(totalHeight);
+ this.scroller.setHeight(scrollerHeight);
+ }
+ return;
+ }
+ _super.prototype.updateSize.call(this, totalHeight, isAuto, isResize);
+ if (this.dayGrid.colWeekNumbersVisible) {
+ // Make sure all week number cells running down the side have the same width.
+ // Record the width for cells created later.
+ this.weekNumberWidth = util_1.matchCellWidths(this.el.find('.fc-week-number'));
+ }
+ // reset all heights to be natural
+ this.scroller.clear();
+ util_1.uncompensateScroll(headRowEl);
+ this.dayGrid.removeSegPopover(); // kill the "more" popover if displayed
+ // is the event limit a constant level number?
+ if (eventLimit && typeof eventLimit === 'number') {
+ this.dayGrid.limitRows(eventLimit); // limit the levels first so the height can redistribute after
+ }
+ // distribute the height to the rows
+ // (totalHeight is a "recommended" value if isAuto)
+ scrollerHeight = this.computeScrollerHeight(totalHeight);
+ this.setGridHeight(scrollerHeight, isAuto);
+ // is the event limit dynamically calculated?
+ if (eventLimit && typeof eventLimit !== 'number') {
+ this.dayGrid.limitRows(eventLimit); // limit the levels after the grid's row heights have been set
+ }
+ if (!isAuto) {
+ this.scroller.setHeight(scrollerHeight);
+ scrollbarWidths = this.scroller.getScrollbarWidths();
+ if (scrollbarWidths.left || scrollbarWidths.right) {
+ util_1.compensateScroll(headRowEl, scrollbarWidths);
+ // doing the scrollbar compensation might have created text overflow which created more height. redo
+ scrollerHeight = this.computeScrollerHeight(totalHeight);
+ this.scroller.setHeight(scrollerHeight);
+ }
+ // guarantees the same scrollbar widths
+ this.scroller.lockOverflow(scrollbarWidths);
+ }
+ };
+ // given a desired total height of the view, returns what the height of the scroller should be
+ BasicView.prototype.computeScrollerHeight = function (totalHeight) {
+ return totalHeight -
+ util_1.subtractInnerElHeight(this.el, this.scroller.el); // everything that's NOT the scroller
+ };
+ // Sets the height of just the DayGrid component in this view
+ BasicView.prototype.setGridHeight = function (height, isAuto) {
+ if (isAuto) {
+ util_1.undistributeHeight(this.dayGrid.rowEls); // let the rows be their natural height with no expanding
+ }
+ else {
+ util_1.distributeHeight(this.dayGrid.rowEls, height, true); // true = compensate for height-hogging rows
+ }
+ };
+ /* Scroll
+ ------------------------------------------------------------------------------------------------------------------*/
+ BasicView.prototype.computeInitialDateScroll = function () {
+ return { top: 0 };
+ };
+ BasicView.prototype.queryDateScroll = function () {
+ return { top: this.scroller.getScrollTop() };
+ };
+ BasicView.prototype.applyDateScroll = function (scroll) {
+ if (scroll.top !== undefined) {
+ this.scroller.setScrollTop(scroll.top);
+ }
+ };
+ return BasicView;
+}(View_1.default));
+exports.default = BasicView;
+BasicView.prototype.dateProfileGeneratorClass = BasicViewDateProfileGenerator_1.default;
+BasicView.prototype.dayGridClass = DayGrid_1.default;
+// customize the rendering behavior of BasicView's dayGrid
+function makeDayGridSubclass(SuperClass) {
+ return /** @class */ (function (_super) {
+ tslib_1.__extends(SubClass, _super);
+ function SubClass() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.colWeekNumbersVisible = false; // display week numbers along the side?
+ return _this;
+ }
+ // Generates the HTML that will go before the day-of week header cells
+ SubClass.prototype.renderHeadIntroHtml = function () {
+ var view = this.view;
+ if (this.colWeekNumbersVisible) {
+ return '' +
+ ' | ';
+ }
+ return '';
+ };
+ // Generates the HTML that will go before content-skeleton cells that display the day/week numbers
+ SubClass.prototype.renderNumberIntroHtml = function (row) {
+ var view = this.view;
+ var weekStart = this.getCellDate(row, 0);
+ if (this.colWeekNumbersVisible) {
+ return '' +
+ ' ' +
+ view.buildGotoAnchorHtml(// aside from link, important for matchCellWidths
+ { date: weekStart, type: 'week', forceOff: this.colCnt === 1 }, weekStart.format('w') // inner HTML
+ ) +
+ ' | ';
+ }
+ return '';
+ };
+ // Generates the HTML that goes before the day bg cells for each day-row
+ SubClass.prototype.renderBgIntroHtml = function () {
+ var view = this.view;
+ if (this.colWeekNumbersVisible) {
+ return ' | ';
+ }
+ return '';
+ };
+ // Generates the HTML that goes before every other type of row generated by DayGrid.
+ // Affects helper-skeleton and highlight-skeleton rows.
+ SubClass.prototype.renderIntroHtml = function () {
+ var view = this.view;
+ if (this.colWeekNumbersVisible) {
+ return ' | ';
+ }
+ return '';
+ };
+ SubClass.prototype.getIsNumbersVisible = function () {
+ return DayGrid_1.default.prototype.getIsNumbersVisible.apply(this, arguments) || this.colWeekNumbersVisible;
+ };
+ return SubClass;
+ }(SuperClass));
+}
+
+
+/***/ }),
+/* 63 */,
+/* 64 */,
+/* 65 */,
+/* 66 */,
+/* 67 */,
+/* 68 */,
+/* 69 */,
+/* 70 */,
+/* 71 */,
+/* 72 */,
+/* 73 */,
+/* 74 */,
+/* 75 */,
+/* 76 */,
+/* 77 */,
+/* 78 */,
+/* 79 */,
+/* 80 */,
+/* 81 */,
+/* 82 */,
+/* 83 */,
+/* 84 */,
+/* 85 */,
+/* 86 */,
+/* 87 */,
+/* 88 */,
+/* 89 */,
+/* 90 */,
+/* 91 */,
+/* 92 */,
+/* 93 */,
+/* 94 */,
+/* 95 */,
+/* 96 */,
+/* 97 */,
+/* 98 */,
+/* 99 */,
+/* 100 */,
+/* 101 */,
+/* 102 */,
+/* 103 */,
+/* 104 */,
+/* 105 */,
+/* 106 */,
+/* 107 */,
+/* 108 */,
+/* 109 */,
+/* 110 */,
+/* 111 */,
+/* 112 */,
+/* 113 */,
+/* 114 */,
+/* 115 */,
+/* 116 */,
+/* 117 */,
+/* 118 */,
+/* 119 */,
+/* 120 */,
+/* 121 */,
+/* 122 */,
+/* 123 */,
+/* 124 */,
+/* 125 */,
+/* 126 */,
+/* 127 */,
+/* 128 */,
+/* 129 */,
+/* 130 */,
+/* 131 */,
+/* 132 */,
+/* 133 */,
+/* 134 */,
+/* 135 */,
+/* 136 */,
+/* 137 */,
+/* 138 */,
+/* 139 */,
+/* 140 */,
+/* 141 */,
+/* 142 */,
+/* 143 */,
+/* 144 */,
+/* 145 */,
+/* 146 */,
+/* 147 */,
+/* 148 */,
+/* 149 */,
+/* 150 */,
+/* 151 */,
+/* 152 */,
+/* 153 */,
+/* 154 */,
+/* 155 */,
+/* 156 */,
+/* 157 */,
+/* 158 */,
+/* 159 */,
+/* 160 */,
+/* 161 */,
+/* 162 */,
+/* 163 */,
+/* 164 */,
+/* 165 */,
+/* 166 */,
+/* 167 */,
+/* 168 */,
+/* 169 */,
+/* 170 */,
+/* 171 */,
+/* 172 */,
+/* 173 */,
+/* 174 */,
+/* 175 */,
+/* 176 */,
+/* 177 */,
+/* 178 */,
+/* 179 */,
+/* 180 */,
+/* 181 */,
+/* 182 */,
+/* 183 */,
+/* 184 */,
+/* 185 */,
+/* 186 */,
+/* 187 */,
+/* 188 */,
+/* 189 */,
+/* 190 */,
+/* 191 */,
+/* 192 */,
+/* 193 */,
+/* 194 */,
+/* 195 */,
+/* 196 */,
+/* 197 */,
+/* 198 */,
+/* 199 */,
+/* 200 */,
+/* 201 */,
+/* 202 */,
+/* 203 */,
+/* 204 */,
+/* 205 */,
+/* 206 */,
+/* 207 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var UnzonedRange_1 = __webpack_require__(5);
+var ComponentFootprint_1 = __webpack_require__(12);
+var EventDefParser_1 = __webpack_require__(49);
+var EventSource_1 = __webpack_require__(6);
+var util_1 = __webpack_require__(35);
+var Constraints = /** @class */ (function () {
+ function Constraints(eventManager, _calendar) {
+ this.eventManager = eventManager;
+ this._calendar = _calendar;
+ }
+ Constraints.prototype.opt = function (name) {
+ return this._calendar.opt(name);
+ };
+ /*
+ determines if eventInstanceGroup is allowed,
+ in relation to other EVENTS and business hours.
+ */
+ Constraints.prototype.isEventInstanceGroupAllowed = function (eventInstanceGroup) {
+ var eventDef = eventInstanceGroup.getEventDef();
+ var eventFootprints = this.eventRangesToEventFootprints(eventInstanceGroup.getAllEventRanges());
+ var i;
+ var peerEventInstances = this.getPeerEventInstances(eventDef);
+ var peerEventRanges = peerEventInstances.map(util_1.eventInstanceToEventRange);
+ var peerEventFootprints = this.eventRangesToEventFootprints(peerEventRanges);
+ var constraintVal = eventDef.getConstraint();
+ var overlapVal = eventDef.getOverlap();
+ var eventAllowFunc = this.opt('eventAllow');
+ for (i = 0; i < eventFootprints.length; i++) {
+ if (!this.isFootprintAllowed(eventFootprints[i].componentFootprint, peerEventFootprints, constraintVal, overlapVal, eventFootprints[i].eventInstance)) {
+ return false;
+ }
+ }
+ if (eventAllowFunc) {
+ for (i = 0; i < eventFootprints.length; i++) {
+ if (eventAllowFunc(eventFootprints[i].componentFootprint.toLegacy(this._calendar), eventFootprints[i].getEventLegacy()) === false) {
+ return false;
+ }
+ }
+ }
+ return true;
+ };
+ Constraints.prototype.getPeerEventInstances = function (eventDef) {
+ return this.eventManager.getEventInstancesWithoutId(eventDef.id);
+ };
+ Constraints.prototype.isSelectionFootprintAllowed = function (componentFootprint) {
+ var peerEventInstances = this.eventManager.getEventInstances();
+ var peerEventRanges = peerEventInstances.map(util_1.eventInstanceToEventRange);
+ var peerEventFootprints = this.eventRangesToEventFootprints(peerEventRanges);
+ var selectAllowFunc;
+ if (this.isFootprintAllowed(componentFootprint, peerEventFootprints, this.opt('selectConstraint'), this.opt('selectOverlap'))) {
+ selectAllowFunc = this.opt('selectAllow');
+ if (selectAllowFunc) {
+ return selectAllowFunc(componentFootprint.toLegacy(this._calendar)) !== false;
+ }
+ else {
+ return true;
+ }
+ }
+ return false;
+ };
+ Constraints.prototype.isFootprintAllowed = function (componentFootprint, peerEventFootprints, constraintVal, overlapVal, subjectEventInstance // optional
+ ) {
+ var constraintFootprints; // ComponentFootprint[]
+ var overlapEventFootprints; // EventFootprint[]
+ if (constraintVal != null) {
+ constraintFootprints = this.constraintValToFootprints(constraintVal, componentFootprint.isAllDay);
+ if (!this.isFootprintWithinConstraints(componentFootprint, constraintFootprints)) {
+ return false;
+ }
+ }
+ overlapEventFootprints = this.collectOverlapEventFootprints(peerEventFootprints, componentFootprint);
+ if (overlapVal === false) {
+ if (overlapEventFootprints.length) {
+ return false;
+ }
+ }
+ else if (typeof overlapVal === 'function') {
+ if (!isOverlapsAllowedByFunc(overlapEventFootprints, overlapVal, subjectEventInstance)) {
+ return false;
+ }
+ }
+ if (subjectEventInstance) {
+ if (!isOverlapEventInstancesAllowed(overlapEventFootprints, subjectEventInstance)) {
+ return false;
+ }
+ }
+ return true;
+ };
+ // Constraint
+ // ------------------------------------------------------------------------------------------------
+ Constraints.prototype.isFootprintWithinConstraints = function (componentFootprint, constraintFootprints) {
+ var i;
+ for (i = 0; i < constraintFootprints.length; i++) {
+ if (this.footprintContainsFootprint(constraintFootprints[i], componentFootprint)) {
+ return true;
+ }
+ }
+ return false;
+ };
+ Constraints.prototype.constraintValToFootprints = function (constraintVal, isAllDay) {
+ var eventInstances;
+ if (constraintVal === 'businessHours') {
+ return this.buildCurrentBusinessFootprints(isAllDay);
+ }
+ else if (typeof constraintVal === 'object') {
+ eventInstances = this.parseEventDefToInstances(constraintVal); // handles recurring events
+ if (!eventInstances) {
+ return this.parseFootprints(constraintVal);
+ }
+ else {
+ return this.eventInstancesToFootprints(eventInstances);
+ }
+ }
+ else if (constraintVal != null) {
+ eventInstances = this.eventManager.getEventInstancesWithId(constraintVal);
+ return this.eventInstancesToFootprints(eventInstances);
+ }
+ };
+ // returns ComponentFootprint[]
+ // uses current view's range
+ Constraints.prototype.buildCurrentBusinessFootprints = function (isAllDay) {
+ var view = this._calendar.view;
+ var businessHourGenerator = view.get('businessHourGenerator');
+ var unzonedRange = view.dateProfile.activeUnzonedRange;
+ var eventInstanceGroup = businessHourGenerator.buildEventInstanceGroup(isAllDay, unzonedRange);
+ if (eventInstanceGroup) {
+ return this.eventInstancesToFootprints(eventInstanceGroup.eventInstances);
+ }
+ else {
+ return [];
+ }
+ };
+ // conversion util
+ Constraints.prototype.eventInstancesToFootprints = function (eventInstances) {
+ var eventRanges = eventInstances.map(util_1.eventInstanceToEventRange);
+ var eventFootprints = this.eventRangesToEventFootprints(eventRanges);
+ return eventFootprints.map(util_1.eventFootprintToComponentFootprint);
+ };
+ // Overlap
+ // ------------------------------------------------------------------------------------------------
+ Constraints.prototype.collectOverlapEventFootprints = function (peerEventFootprints, targetFootprint) {
+ var overlapEventFootprints = [];
+ var i;
+ for (i = 0; i < peerEventFootprints.length; i++) {
+ if (this.footprintsIntersect(targetFootprint, peerEventFootprints[i].componentFootprint)) {
+ overlapEventFootprints.push(peerEventFootprints[i]);
+ }
+ }
+ return overlapEventFootprints;
+ };
+ // Conversion: eventDefs -> eventInstances -> eventRanges -> eventFootprints -> componentFootprints
+ // ------------------------------------------------------------------------------------------------
+ // NOTE: this might seem like repetitive code with the Grid class, however, this code is related to
+ // constraints whereas the Grid code is related to rendering. Each approach might want to convert
+ // eventRanges -> eventFootprints in a different way. Regardless, there are opportunities to make
+ // this more DRY.
+ /*
+ Returns false on invalid input.
+ */
+ Constraints.prototype.parseEventDefToInstances = function (eventInput) {
+ var eventManager = this.eventManager;
+ var eventDef = EventDefParser_1.default.parse(eventInput, new EventSource_1.default(this._calendar));
+ if (!eventDef) {
+ return false;
+ }
+ return eventDef.buildInstances(eventManager.currentPeriod.unzonedRange);
+ };
+ Constraints.prototype.eventRangesToEventFootprints = function (eventRanges) {
+ var i;
+ var eventFootprints = [];
+ for (i = 0; i < eventRanges.length; i++) {
+ eventFootprints.push.apply(// footprints
+ eventFootprints, this.eventRangeToEventFootprints(eventRanges[i]));
+ }
+ return eventFootprints;
+ };
+ Constraints.prototype.eventRangeToEventFootprints = function (eventRange) {
+ return [util_1.eventRangeToEventFootprint(eventRange)];
+ };
+ /*
+ Parses footprints directly.
+ Very similar to EventDateProfile::parse :(
+ */
+ Constraints.prototype.parseFootprints = function (rawInput) {
+ var start;
+ var end;
+ if (rawInput.start) {
+ start = this._calendar.moment(rawInput.start);
+ if (!start.isValid()) {
+ start = null;
+ }
+ }
+ if (rawInput.end) {
+ end = this._calendar.moment(rawInput.end);
+ if (!end.isValid()) {
+ end = null;
+ }
+ }
+ return [
+ new ComponentFootprint_1.default(new UnzonedRange_1.default(start, end), (start && !start.hasTime()) || (end && !end.hasTime()) // isAllDay
+ )
+ ];
+ };
+ // Footprint Utils
+ // ----------------------------------------------------------------------------------------
+ Constraints.prototype.footprintContainsFootprint = function (outerFootprint, innerFootprint) {
+ return outerFootprint.unzonedRange.containsRange(innerFootprint.unzonedRange);
+ };
+ Constraints.prototype.footprintsIntersect = function (footprint0, footprint1) {
+ return footprint0.unzonedRange.intersectsWith(footprint1.unzonedRange);
+ };
+ return Constraints;
+}());
+exports.default = Constraints;
+// optional subjectEventInstance
+function isOverlapsAllowedByFunc(overlapEventFootprints, overlapFunc, subjectEventInstance) {
+ var i;
+ for (i = 0; i < overlapEventFootprints.length; i++) {
+ if (!overlapFunc(overlapEventFootprints[i].eventInstance.toLegacy(), subjectEventInstance ? subjectEventInstance.toLegacy() : null)) {
+ return false;
+ }
+ }
+ return true;
+}
+function isOverlapEventInstancesAllowed(overlapEventFootprints, subjectEventInstance) {
+ var subjectLegacyInstance = subjectEventInstance.toLegacy();
+ var i;
+ var overlapEventInstance;
+ var overlapEventDef;
+ var overlapVal;
+ for (i = 0; i < overlapEventFootprints.length; i++) {
+ overlapEventInstance = overlapEventFootprints[i].eventInstance;
+ overlapEventDef = overlapEventInstance.def;
+ // don't need to pass in calendar, because don't want to consider global eventOverlap property,
+ // because we already considered that earlier in the process.
+ overlapVal = overlapEventDef.getOverlap();
+ if (overlapVal === false) {
+ return false;
+ }
+ else if (typeof overlapVal === 'function') {
+ if (!overlapVal(overlapEventInstance.toLegacy(), subjectLegacyInstance)) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+
+/***/ }),
+/* 208 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/*
+USAGE:
+ import { default as ParsableModelMixin, ParsableModelInterface } from './ParsableModelMixin'
+in class:
+ applyProps: ParsableModelInterface['applyProps']
+ applyManualStandardProps: ParsableModelInterface['applyManualStandardProps']
+ applyMiscProps: ParsableModelInterface['applyMiscProps']
+ isStandardProp: ParsableModelInterface['isStandardProp']
+ static defineStandardProps = ParsableModelMixin.defineStandardProps
+ static copyVerbatimStandardProps = ParsableModelMixin.copyVerbatimStandardProps
+after class:
+ ParsableModelMixin.mixInto(TheClass)
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var util_1 = __webpack_require__(4);
+var Mixin_1 = __webpack_require__(14);
+var ParsableModelMixin = /** @class */ (function (_super) {
+ tslib_1.__extends(ParsableModelMixin, _super);
+ function ParsableModelMixin() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ParsableModelMixin.defineStandardProps = function (propDefs) {
+ var proto = this.prototype;
+ if (!proto.hasOwnProperty('standardPropMap')) {
+ proto.standardPropMap = Object.create(proto.standardPropMap);
+ }
+ util_1.copyOwnProps(propDefs, proto.standardPropMap);
+ };
+ ParsableModelMixin.copyVerbatimStandardProps = function (src, dest) {
+ var map = this.prototype.standardPropMap;
+ var propName;
+ for (propName in map) {
+ if (src[propName] != null && // in the src object?
+ map[propName] === true // false means "copy verbatim"
+ ) {
+ dest[propName] = src[propName];
+ }
+ }
+ };
+ /*
+ Returns true/false for success.
+ Meant to be only called ONCE, at object creation.
+ */
+ ParsableModelMixin.prototype.applyProps = function (rawProps) {
+ var standardPropMap = this.standardPropMap;
+ var manualProps = {};
+ var miscProps = {};
+ var propName;
+ for (propName in rawProps) {
+ if (standardPropMap[propName] === true) {
+ this[propName] = rawProps[propName];
+ }
+ else if (standardPropMap[propName] === false) {
+ manualProps[propName] = rawProps[propName];
+ }
+ else {
+ miscProps[propName] = rawProps[propName];
+ }
+ }
+ this.applyMiscProps(miscProps);
+ return this.applyManualStandardProps(manualProps);
+ };
+ /*
+ If subclasses override, they must call this supermethod and return the boolean response.
+ Meant to be only called ONCE, at object creation.
+ */
+ ParsableModelMixin.prototype.applyManualStandardProps = function (rawProps) {
+ return true;
+ };
+ /*
+ Can be called even after initial object creation.
+ */
+ ParsableModelMixin.prototype.applyMiscProps = function (rawProps) {
+ // subclasses can implement
+ };
+ /*
+ TODO: why is this a method when defineStandardProps is static
+ */
+ ParsableModelMixin.prototype.isStandardProp = function (propName) {
+ return propName in this.standardPropMap;
+ };
+ return ParsableModelMixin;
+}(Mixin_1.default));
+exports.default = ParsableModelMixin;
+ParsableModelMixin.prototype.standardPropMap = {}; // will be cloned by defineStandardProps
+
+
+/***/ }),
+/* 209 */
+/***/ (function(module, exports) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var EventInstance = /** @class */ (function () {
+ function EventInstance(def, dateProfile) {
+ this.def = def;
+ this.dateProfile = dateProfile;
+ }
+ EventInstance.prototype.toLegacy = function () {
+ var dateProfile = this.dateProfile;
+ var obj = this.def.toLegacy();
+ obj.start = dateProfile.start.clone();
+ obj.end = dateProfile.end ? dateProfile.end.clone() : null;
+ return obj;
+ };
+ return EventInstance;
+}());
+exports.default = EventInstance;
+
+
+/***/ }),
+/* 210 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var moment = __webpack_require__(0);
+var EventDef_1 = __webpack_require__(34);
+var EventInstance_1 = __webpack_require__(209);
+var EventDateProfile_1 = __webpack_require__(17);
+var RecurringEventDef = /** @class */ (function (_super) {
+ tslib_1.__extends(RecurringEventDef, _super);
+ function RecurringEventDef() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ RecurringEventDef.prototype.isAllDay = function () {
+ return !this.startTime && !this.endTime;
+ };
+ RecurringEventDef.prototype.buildInstances = function (unzonedRange) {
+ var calendar = this.source.calendar;
+ var unzonedDate = unzonedRange.getStart();
+ var unzonedEnd = unzonedRange.getEnd();
+ var zonedDayStart;
+ var instanceStart;
+ var instanceEnd;
+ var instances = [];
+ while (unzonedDate.isBefore(unzonedEnd)) {
+ // if everyday, or this particular day-of-week
+ if (!this.dowHash || this.dowHash[unzonedDate.day()]) {
+ zonedDayStart = calendar.applyTimezone(unzonedDate);
+ instanceStart = zonedDayStart.clone();
+ instanceEnd = null;
+ if (this.startTime) {
+ instanceStart.time(this.startTime);
+ }
+ else {
+ instanceStart.stripTime();
+ }
+ if (this.endTime) {
+ instanceEnd = zonedDayStart.clone().time(this.endTime);
+ }
+ instances.push(new EventInstance_1.default(this, // definition
+ new EventDateProfile_1.default(instanceStart, instanceEnd, calendar)));
+ }
+ unzonedDate.add(1, 'days');
+ }
+ return instances;
+ };
+ RecurringEventDef.prototype.setDow = function (dowNumbers) {
+ if (!this.dowHash) {
+ this.dowHash = {};
+ }
+ for (var i = 0; i < dowNumbers.length; i++) {
+ this.dowHash[dowNumbers[i]] = true;
+ }
+ };
+ RecurringEventDef.prototype.clone = function () {
+ var def = _super.prototype.clone.call(this);
+ if (def.startTime) {
+ def.startTime = moment.duration(this.startTime);
+ }
+ if (def.endTime) {
+ def.endTime = moment.duration(this.endTime);
+ }
+ if (this.dowHash) {
+ def.dowHash = $.extend({}, this.dowHash);
+ }
+ return def;
+ };
+ return RecurringEventDef;
+}(EventDef_1.default));
+exports.default = RecurringEventDef;
+/*
+HACK to work with TypeScript mixins
+NOTE: if super-method fails, should still attempt to apply
+*/
+RecurringEventDef.prototype.applyProps = function (rawProps) {
+ var superSuccess = EventDef_1.default.prototype.applyProps.call(this, rawProps);
+ if (rawProps.start) {
+ this.startTime = moment.duration(rawProps.start);
+ }
+ if (rawProps.end) {
+ this.endTime = moment.duration(rawProps.end);
+ }
+ if (rawProps.dow) {
+ this.setDow(rawProps.dow);
+ }
+ return superSuccess;
+};
+// Parsing
+// ---------------------------------------------------------------------------------------------------------------------
+RecurringEventDef.defineStandardProps({
+ start: false,
+ end: false,
+ dow: false
+});
+
+
+/***/ }),
+/* 211 */
+/***/ (function(module, exports) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var EventRange = /** @class */ (function () {
+ function EventRange(unzonedRange, eventDef, eventInstance) {
+ this.unzonedRange = unzonedRange;
+ this.eventDef = eventDef;
+ if (eventInstance) {
+ this.eventInstance = eventInstance;
+ }
+ }
+ return EventRange;
+}());
+exports.default = EventRange;
+
+
+/***/ }),
+/* 212 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var $ = __webpack_require__(3);
+var util_1 = __webpack_require__(35);
+var EventInstanceGroup_1 = __webpack_require__(18);
+var RecurringEventDef_1 = __webpack_require__(210);
+var EventSource_1 = __webpack_require__(6);
+var BUSINESS_HOUR_EVENT_DEFAULTS = {
+ start: '09:00',
+ end: '17:00',
+ dow: [1, 2, 3, 4, 5],
+ rendering: 'inverse-background'
+ // classNames are defined in businessHoursSegClasses
+};
+var BusinessHourGenerator = /** @class */ (function () {
+ function BusinessHourGenerator(rawComplexDef, calendar) {
+ this.rawComplexDef = rawComplexDef;
+ this.calendar = calendar;
+ }
+ BusinessHourGenerator.prototype.buildEventInstanceGroup = function (isAllDay, unzonedRange) {
+ var eventDefs = this.buildEventDefs(isAllDay);
+ var eventInstanceGroup;
+ if (eventDefs.length) {
+ eventInstanceGroup = new EventInstanceGroup_1.default(util_1.eventDefsToEventInstances(eventDefs, unzonedRange));
+ // so that inverse-background rendering can happen even when no eventRanges in view
+ eventInstanceGroup.explicitEventDef = eventDefs[0];
+ return eventInstanceGroup;
+ }
+ };
+ BusinessHourGenerator.prototype.buildEventDefs = function (isAllDay) {
+ var rawComplexDef = this.rawComplexDef;
+ var rawDefs = [];
+ var requireDow = false;
+ var i;
+ var defs = [];
+ if (rawComplexDef === true) {
+ rawDefs = [{}]; // will get BUSINESS_HOUR_EVENT_DEFAULTS verbatim
+ }
+ else if ($.isPlainObject(rawComplexDef)) {
+ rawDefs = [rawComplexDef];
+ }
+ else if ($.isArray(rawComplexDef)) {
+ rawDefs = rawComplexDef;
+ requireDow = true; // every sub-definition NEEDS a day-of-week
+ }
+ for (i = 0; i < rawDefs.length; i++) {
+ if (!requireDow || rawDefs[i].dow) {
+ defs.push(this.buildEventDef(isAllDay, rawDefs[i]));
+ }
+ }
+ return defs;
+ };
+ BusinessHourGenerator.prototype.buildEventDef = function (isAllDay, rawDef) {
+ var fullRawDef = $.extend({}, BUSINESS_HOUR_EVENT_DEFAULTS, rawDef);
+ if (isAllDay) {
+ fullRawDef.start = null;
+ fullRawDef.end = null;
+ }
+ return RecurringEventDef_1.default.parse(fullRawDef, new EventSource_1.default(this.calendar) // dummy source
+ );
+ };
+ return BusinessHourGenerator;
+}());
+exports.default = BusinessHourGenerator;
+
+
+/***/ }),
+/* 213 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var Theme_1 = __webpack_require__(19);
+var StandardTheme = /** @class */ (function (_super) {
+ tslib_1.__extends(StandardTheme, _super);
+ function StandardTheme() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ return StandardTheme;
+}(Theme_1.default));
+exports.default = StandardTheme;
+StandardTheme.prototype.classes = {
+ widget: 'fc-unthemed',
+ widgetHeader: 'fc-widget-header',
+ widgetContent: 'fc-widget-content',
+ buttonGroup: 'fc-button-group',
+ button: 'fc-button',
+ cornerLeft: 'fc-corner-left',
+ cornerRight: 'fc-corner-right',
+ stateDefault: 'fc-state-default',
+ stateActive: 'fc-state-active',
+ stateDisabled: 'fc-state-disabled',
+ stateHover: 'fc-state-hover',
+ stateDown: 'fc-state-down',
+ popoverHeader: 'fc-widget-header',
+ popoverContent: 'fc-widget-content',
+ // day grid
+ headerRow: 'fc-widget-header',
+ dayRow: 'fc-widget-content',
+ // list view
+ listView: 'fc-widget-content'
+};
+StandardTheme.prototype.baseIconClass = 'fc-icon';
+StandardTheme.prototype.iconClasses = {
+ close: 'fc-icon-x',
+ prev: 'fc-icon-left-single-arrow',
+ next: 'fc-icon-right-single-arrow',
+ prevYear: 'fc-icon-left-double-arrow',
+ nextYear: 'fc-icon-right-double-arrow'
+};
+StandardTheme.prototype.iconOverrideOption = 'buttonIcons';
+StandardTheme.prototype.iconOverrideCustomButtonOption = 'icon';
+StandardTheme.prototype.iconOverridePrefix = 'fc-icon-';
+
+
+/***/ }),
+/* 214 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var Theme_1 = __webpack_require__(19);
+var JqueryUiTheme = /** @class */ (function (_super) {
+ tslib_1.__extends(JqueryUiTheme, _super);
+ function JqueryUiTheme() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ return JqueryUiTheme;
+}(Theme_1.default));
+exports.default = JqueryUiTheme;
+JqueryUiTheme.prototype.classes = {
+ widget: 'ui-widget',
+ widgetHeader: 'ui-widget-header',
+ widgetContent: 'ui-widget-content',
+ buttonGroup: 'fc-button-group',
+ button: 'ui-button',
+ cornerLeft: 'ui-corner-left',
+ cornerRight: 'ui-corner-right',
+ stateDefault: 'ui-state-default',
+ stateActive: 'ui-state-active',
+ stateDisabled: 'ui-state-disabled',
+ stateHover: 'ui-state-hover',
+ stateDown: 'ui-state-down',
+ today: 'ui-state-highlight',
+ popoverHeader: 'ui-widget-header',
+ popoverContent: 'ui-widget-content',
+ // day grid
+ headerRow: 'ui-widget-header',
+ dayRow: 'ui-widget-content',
+ // list view
+ listView: 'ui-widget-content'
+};
+JqueryUiTheme.prototype.baseIconClass = 'ui-icon';
+JqueryUiTheme.prototype.iconClasses = {
+ close: 'ui-icon-closethick',
+ prev: 'ui-icon-circle-triangle-w',
+ next: 'ui-icon-circle-triangle-e',
+ prevYear: 'ui-icon-seek-prev',
+ nextYear: 'ui-icon-seek-next'
+};
+JqueryUiTheme.prototype.iconOverrideOption = 'themeButtonIcons';
+JqueryUiTheme.prototype.iconOverrideCustomButtonOption = 'themeIcon';
+JqueryUiTheme.prototype.iconOverridePrefix = 'ui-icon-';
+
+
+/***/ }),
+/* 215 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var Promise_1 = __webpack_require__(20);
+var EventSource_1 = __webpack_require__(6);
+var FuncEventSource = /** @class */ (function (_super) {
+ tslib_1.__extends(FuncEventSource, _super);
+ function FuncEventSource() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ FuncEventSource.parse = function (rawInput, calendar) {
+ var rawProps;
+ // normalize raw input
+ if ($.isFunction(rawInput.events)) {
+ rawProps = rawInput;
+ }
+ else if ($.isFunction(rawInput)) {
+ rawProps = { events: rawInput };
+ }
+ if (rawProps) {
+ return EventSource_1.default.parse.call(this, rawProps, calendar);
+ }
+ return false;
+ };
+ FuncEventSource.prototype.fetch = function (start, end, timezone) {
+ var _this = this;
+ this.calendar.pushLoading();
+ return Promise_1.default.construct(function (onResolve) {
+ _this.func.call(_this.calendar, start.clone(), end.clone(), timezone, function (rawEventDefs) {
+ _this.calendar.popLoading();
+ onResolve(_this.parseEventDefs(rawEventDefs));
+ });
+ });
+ };
+ FuncEventSource.prototype.getPrimitive = function () {
+ return this.func;
+ };
+ FuncEventSource.prototype.applyManualStandardProps = function (rawProps) {
+ var superSuccess = _super.prototype.applyManualStandardProps.call(this, rawProps);
+ this.func = rawProps.events;
+ return superSuccess;
+ };
+ return FuncEventSource;
+}(EventSource_1.default));
+exports.default = FuncEventSource;
+FuncEventSource.defineStandardProps({
+ events: false // don't automatically transfer
+});
+
+
+/***/ }),
+/* 216 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var util_1 = __webpack_require__(4);
+var Promise_1 = __webpack_require__(20);
+var EventSource_1 = __webpack_require__(6);
+var JsonFeedEventSource = /** @class */ (function (_super) {
+ tslib_1.__extends(JsonFeedEventSource, _super);
+ function JsonFeedEventSource() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ JsonFeedEventSource.parse = function (rawInput, calendar) {
+ var rawProps;
+ // normalize raw input
+ if (typeof rawInput.url === 'string') {
+ rawProps = rawInput;
+ }
+ else if (typeof rawInput === 'string') {
+ rawProps = { url: rawInput };
+ }
+ if (rawProps) {
+ return EventSource_1.default.parse.call(this, rawProps, calendar);
+ }
+ return false;
+ };
+ JsonFeedEventSource.prototype.fetch = function (start, end, timezone) {
+ var _this = this;
+ var ajaxSettings = this.ajaxSettings;
+ var onSuccess = ajaxSettings.success;
+ var onError = ajaxSettings.error;
+ var requestParams = this.buildRequestParams(start, end, timezone);
+ // todo: eventually handle the promise's then,
+ // don't intercept success/error
+ // tho will be a breaking API change
+ this.calendar.pushLoading();
+ return Promise_1.default.construct(function (onResolve, onReject) {
+ $.ajax($.extend({}, // destination
+ JsonFeedEventSource.AJAX_DEFAULTS, ajaxSettings, {
+ url: _this.url,
+ data: requestParams,
+ success: function (rawEventDefs, status, xhr) {
+ var callbackRes;
+ _this.calendar.popLoading();
+ if (rawEventDefs) {
+ callbackRes = util_1.applyAll(onSuccess, _this, [rawEventDefs, status, xhr]); // redirect `this`
+ if ($.isArray(callbackRes)) {
+ rawEventDefs = callbackRes;
+ }
+ onResolve(_this.parseEventDefs(rawEventDefs));
+ }
+ else {
+ onReject();
+ }
+ },
+ error: function (xhr, statusText, errorThrown) {
+ _this.calendar.popLoading();
+ util_1.applyAll(onError, _this, [xhr, statusText, errorThrown]); // redirect `this`
+ onReject();
+ }
+ }));
+ });
+ };
+ JsonFeedEventSource.prototype.buildRequestParams = function (start, end, timezone) {
+ var calendar = this.calendar;
+ var ajaxSettings = this.ajaxSettings;
+ var startParam;
+ var endParam;
+ var timezoneParam;
+ var customRequestParams;
+ var params = {};
+ startParam = this.startParam;
+ if (startParam == null) {
+ startParam = calendar.opt('startParam');
+ }
+ endParam = this.endParam;
+ if (endParam == null) {
+ endParam = calendar.opt('endParam');
+ }
+ timezoneParam = this.timezoneParam;
+ if (timezoneParam == null) {
+ timezoneParam = calendar.opt('timezoneParam');
+ }
+ // retrieve any outbound GET/POST $.ajax data from the options
+ if ($.isFunction(ajaxSettings.data)) {
+ // supplied as a function that returns a key/value object
+ customRequestParams = ajaxSettings.data();
+ }
+ else {
+ // probably supplied as a straight key/value object
+ customRequestParams = ajaxSettings.data || {};
+ }
+ $.extend(params, customRequestParams);
+ params[startParam] = start.format();
+ params[endParam] = end.format();
+ if (timezone && timezone !== 'local') {
+ params[timezoneParam] = timezone;
+ }
+ return params;
+ };
+ JsonFeedEventSource.prototype.getPrimitive = function () {
+ return this.url;
+ };
+ JsonFeedEventSource.prototype.applyMiscProps = function (rawProps) {
+ this.ajaxSettings = rawProps;
+ };
+ JsonFeedEventSource.AJAX_DEFAULTS = {
+ dataType: 'json',
+ cache: false
+ };
+ return JsonFeedEventSource;
+}(EventSource_1.default));
+exports.default = JsonFeedEventSource;
+JsonFeedEventSource.defineStandardProps({
+ // automatically transfer (true)...
+ url: true,
+ startParam: true,
+ endParam: true,
+ timezoneParam: true
+});
+
+
+/***/ }),
+/* 217 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var EmitterMixin_1 = __webpack_require__(11);
+var TaskQueue = /** @class */ (function () {
+ function TaskQueue() {
+ this.q = [];
+ this.isPaused = false;
+ this.isRunning = false;
+ }
+ TaskQueue.prototype.queue = function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ this.q.push.apply(this.q, args); // append
+ this.tryStart();
+ };
+ TaskQueue.prototype.pause = function () {
+ this.isPaused = true;
+ };
+ TaskQueue.prototype.resume = function () {
+ this.isPaused = false;
+ this.tryStart();
+ };
+ TaskQueue.prototype.getIsIdle = function () {
+ return !this.isRunning && !this.isPaused;
+ };
+ TaskQueue.prototype.tryStart = function () {
+ if (!this.isRunning && this.canRunNext()) {
+ this.isRunning = true;
+ this.trigger('start');
+ this.runRemaining();
+ }
+ };
+ TaskQueue.prototype.canRunNext = function () {
+ return !this.isPaused && this.q.length;
+ };
+ TaskQueue.prototype.runRemaining = function () {
+ var _this = this;
+ var task;
+ var res;
+ do {
+ task = this.q.shift(); // always freshly reference q. might have been reassigned.
+ res = this.runTask(task);
+ if (res && res.then) {
+ res.then(function () {
+ if (_this.canRunNext()) {
+ _this.runRemaining();
+ }
+ });
+ return; // prevent marking as stopped
+ }
+ } while (this.canRunNext());
+ this.trigger('stop'); // not really a 'stop' ... more of a 'drained'
+ this.isRunning = false;
+ // if 'stop' handler added more tasks.... TODO: write test for this
+ this.tryStart();
+ };
+ TaskQueue.prototype.runTask = function (task) {
+ return task(); // task *is* the function, but subclasses can change the format of a task
+ };
+ return TaskQueue;
+}());
+exports.default = TaskQueue;
+EmitterMixin_1.default.mixInto(TaskQueue);
+
+
+/***/ }),
+/* 218 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var TaskQueue_1 = __webpack_require__(217);
+var RenderQueue = /** @class */ (function (_super) {
+ tslib_1.__extends(RenderQueue, _super);
+ function RenderQueue(waitsByNamespace) {
+ var _this = _super.call(this) || this;
+ _this.waitsByNamespace = waitsByNamespace || {};
+ return _this;
+ }
+ RenderQueue.prototype.queue = function (taskFunc, namespace, type) {
+ var task = {
+ func: taskFunc,
+ namespace: namespace,
+ type: type
+ };
+ var waitMs;
+ if (namespace) {
+ waitMs = this.waitsByNamespace[namespace];
+ }
+ if (this.waitNamespace) {
+ if (namespace === this.waitNamespace && waitMs != null) {
+ this.delayWait(waitMs);
+ }
+ else {
+ this.clearWait();
+ this.tryStart();
+ }
+ }
+ if (this.compoundTask(task)) {
+ if (!this.waitNamespace && waitMs != null) {
+ this.startWait(namespace, waitMs);
+ }
+ else {
+ this.tryStart();
+ }
+ }
+ };
+ RenderQueue.prototype.startWait = function (namespace, waitMs) {
+ this.waitNamespace = namespace;
+ this.spawnWait(waitMs);
+ };
+ RenderQueue.prototype.delayWait = function (waitMs) {
+ clearTimeout(this.waitId);
+ this.spawnWait(waitMs);
+ };
+ RenderQueue.prototype.spawnWait = function (waitMs) {
+ var _this = this;
+ this.waitId = setTimeout(function () {
+ _this.waitNamespace = null;
+ _this.tryStart();
+ }, waitMs);
+ };
+ RenderQueue.prototype.clearWait = function () {
+ if (this.waitNamespace) {
+ clearTimeout(this.waitId);
+ this.waitId = null;
+ this.waitNamespace = null;
+ }
+ };
+ RenderQueue.prototype.canRunNext = function () {
+ if (!_super.prototype.canRunNext.call(this)) {
+ return false;
+ }
+ // waiting for a certain namespace to stop receiving tasks?
+ if (this.waitNamespace) {
+ var q = this.q;
+ // if there was a different namespace task in the meantime,
+ // that forces all previously-waiting tasks to suddenly execute.
+ // TODO: find a way to do this in constant time.
+ for (var i = 0; i < q.length; i++) {
+ if (q[i].namespace !== this.waitNamespace) {
+ return true; // allow execution
+ }
+ }
+ return false;
+ }
+ return true;
+ };
+ RenderQueue.prototype.runTask = function (task) {
+ task.func();
+ };
+ RenderQueue.prototype.compoundTask = function (newTask) {
+ var q = this.q;
+ var shouldAppend = true;
+ var i;
+ var task;
+ if (newTask.namespace && newTask.type === 'destroy') {
+ // remove all init/add/remove ops with same namespace, regardless of order
+ for (i = q.length - 1; i >= 0; i--) {
+ task = q[i];
+ switch (task.type) {
+ case 'init':
+ shouldAppend = false;
+ // the latest destroy is cancelled out by not doing the init
+ /* falls through */
+ case 'add':
+ /* falls through */
+ case 'remove':
+ q.splice(i, 1); // remove task
+ }
+ }
+ }
+ if (shouldAppend) {
+ q.push(newTask);
+ }
+ return shouldAppend;
+ };
+ return RenderQueue;
+}(TaskQueue_1.default));
+exports.default = RenderQueue;
+
+
+/***/ }),
+/* 219 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var moment = __webpack_require__(0);
+var util_1 = __webpack_require__(4);
+var moment_ext_1 = __webpack_require__(10);
+var date_formatting_1 = __webpack_require__(47);
+var Component_1 = __webpack_require__(237);
+var util_2 = __webpack_require__(35);
+var DateComponent = /** @class */ (function (_super) {
+ tslib_1.__extends(DateComponent, _super);
+ function DateComponent(_view, _options) {
+ var _this = _super.call(this) || this;
+ _this.isRTL = false; // frequently accessed options
+ _this.hitsNeededDepth = 0; // necessary because multiple callers might need the same hits
+ _this.hasAllDayBusinessHours = false; // TODO: unify with largeUnit and isTimeScale?
+ _this.isDatesRendered = false;
+ // hack to set options prior to the this.opt calls
+ if (_view) {
+ _this['view'] = _view;
+ }
+ if (_options) {
+ _this['options'] = _options;
+ }
+ _this.uid = String(DateComponent.guid++);
+ _this.childrenByUid = {};
+ _this.nextDayThreshold = moment.duration(_this.opt('nextDayThreshold'));
+ _this.isRTL = _this.opt('isRTL');
+ if (_this.fillRendererClass) {
+ _this.fillRenderer = new _this.fillRendererClass(_this);
+ }
+ if (_this.eventRendererClass) {
+ _this.eventRenderer = new _this.eventRendererClass(_this, _this.fillRenderer);
+ }
+ if (_this.helperRendererClass && _this.eventRenderer) {
+ _this.helperRenderer = new _this.helperRendererClass(_this, _this.eventRenderer);
+ }
+ if (_this.businessHourRendererClass && _this.fillRenderer) {
+ _this.businessHourRenderer = new _this.businessHourRendererClass(_this, _this.fillRenderer);
+ }
+ return _this;
+ }
+ DateComponent.prototype.addChild = function (child) {
+ if (!this.childrenByUid[child.uid]) {
+ this.childrenByUid[child.uid] = child;
+ return true;
+ }
+ return false;
+ };
+ DateComponent.prototype.removeChild = function (child) {
+ if (this.childrenByUid[child.uid]) {
+ delete this.childrenByUid[child.uid];
+ return true;
+ }
+ return false;
+ };
+ // TODO: only do if isInDom?
+ // TODO: make part of Component, along with children/batch-render system?
+ DateComponent.prototype.updateSize = function (totalHeight, isAuto, isResize) {
+ this.callChildren('updateSize', arguments);
+ };
+ // Options
+ // -----------------------------------------------------------------------------------------------------------------
+ DateComponent.prototype.opt = function (name) {
+ return this._getView().opt(name); // default implementation
+ };
+ DateComponent.prototype.publiclyTrigger = function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var calendar = this._getCalendar();
+ return calendar.publiclyTrigger.apply(calendar, args);
+ };
+ DateComponent.prototype.hasPublicHandlers = function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var calendar = this._getCalendar();
+ return calendar.hasPublicHandlers.apply(calendar, args);
+ };
+ // Date
+ // -----------------------------------------------------------------------------------------------------------------
+ DateComponent.prototype.executeDateRender = function (dateProfile) {
+ this.dateProfile = dateProfile; // for rendering
+ this.renderDates(dateProfile);
+ this.isDatesRendered = true;
+ this.callChildren('executeDateRender', arguments);
+ };
+ DateComponent.prototype.executeDateUnrender = function () {
+ this.callChildren('executeDateUnrender', arguments);
+ this.dateProfile = null;
+ this.unrenderDates();
+ this.isDatesRendered = false;
+ };
+ // date-cell content only
+ DateComponent.prototype.renderDates = function (dateProfile) {
+ // subclasses should implement
+ };
+ // date-cell content only
+ DateComponent.prototype.unrenderDates = function () {
+ // subclasses should override
+ };
+ // Now-Indicator
+ // -----------------------------------------------------------------------------------------------------------------
+ // Returns a string unit, like 'second' or 'minute' that defined how often the current time indicator
+ // should be refreshed. If something falsy is returned, no time indicator is rendered at all.
+ DateComponent.prototype.getNowIndicatorUnit = function () {
+ // subclasses should implement
+ };
+ // Renders a current time indicator at the given datetime
+ DateComponent.prototype.renderNowIndicator = function (date) {
+ this.callChildren('renderNowIndicator', arguments);
+ };
+ // Undoes the rendering actions from renderNowIndicator
+ DateComponent.prototype.unrenderNowIndicator = function () {
+ this.callChildren('unrenderNowIndicator', arguments);
+ };
+ // Business Hours
+ // ---------------------------------------------------------------------------------------------------------------
+ DateComponent.prototype.renderBusinessHours = function (businessHourGenerator) {
+ if (this.businessHourRenderer) {
+ this.businessHourRenderer.render(businessHourGenerator);
+ }
+ this.callChildren('renderBusinessHours', arguments);
+ };
+ // Unrenders previously-rendered business-hours
+ DateComponent.prototype.unrenderBusinessHours = function () {
+ this.callChildren('unrenderBusinessHours', arguments);
+ if (this.businessHourRenderer) {
+ this.businessHourRenderer.unrender();
+ }
+ };
+ // Event Displaying
+ // -----------------------------------------------------------------------------------------------------------------
+ DateComponent.prototype.executeEventRender = function (eventsPayload) {
+ if (this.eventRenderer) {
+ this.eventRenderer.rangeUpdated(); // poorly named now
+ this.eventRenderer.render(eventsPayload);
+ }
+ else if (this['renderEvents']) {
+ this['renderEvents'](convertEventsPayloadToLegacyArray(eventsPayload));
+ }
+ this.callChildren('executeEventRender', arguments);
+ };
+ DateComponent.prototype.executeEventUnrender = function () {
+ this.callChildren('executeEventUnrender', arguments);
+ if (this.eventRenderer) {
+ this.eventRenderer.unrender();
+ }
+ else if (this['destroyEvents']) {
+ this['destroyEvents']();
+ }
+ };
+ DateComponent.prototype.getBusinessHourSegs = function () {
+ var segs = this.getOwnBusinessHourSegs();
+ this.iterChildren(function (child) {
+ segs.push.apply(segs, child.getBusinessHourSegs());
+ });
+ return segs;
+ };
+ DateComponent.prototype.getOwnBusinessHourSegs = function () {
+ if (this.businessHourRenderer) {
+ return this.businessHourRenderer.getSegs();
+ }
+ return [];
+ };
+ DateComponent.prototype.getEventSegs = function () {
+ var segs = this.getOwnEventSegs();
+ this.iterChildren(function (child) {
+ segs.push.apply(segs, child.getEventSegs());
+ });
+ return segs;
+ };
+ DateComponent.prototype.getOwnEventSegs = function () {
+ if (this.eventRenderer) {
+ return this.eventRenderer.getSegs();
+ }
+ return [];
+ };
+ // Event Rendering Triggering
+ // -----------------------------------------------------------------------------------------------------------------
+ DateComponent.prototype.triggerAfterEventsRendered = function () {
+ this.triggerAfterEventSegsRendered(this.getEventSegs());
+ this.publiclyTrigger('eventAfterAllRender', {
+ context: this,
+ args: [this]
+ });
+ };
+ DateComponent.prototype.triggerAfterEventSegsRendered = function (segs) {
+ var _this = this;
+ // an optimization, because getEventLegacy is expensive
+ if (this.hasPublicHandlers('eventAfterRender')) {
+ segs.forEach(function (seg) {
+ var legacy;
+ if (seg.el) {
+ legacy = seg.footprint.getEventLegacy();
+ _this.publiclyTrigger('eventAfterRender', {
+ context: legacy,
+ args: [legacy, seg.el, _this]
+ });
+ }
+ });
+ }
+ };
+ DateComponent.prototype.triggerBeforeEventsDestroyed = function () {
+ this.triggerBeforeEventSegsDestroyed(this.getEventSegs());
+ };
+ DateComponent.prototype.triggerBeforeEventSegsDestroyed = function (segs) {
+ var _this = this;
+ if (this.hasPublicHandlers('eventDestroy')) {
+ segs.forEach(function (seg) {
+ var legacy;
+ if (seg.el) {
+ legacy = seg.footprint.getEventLegacy();
+ _this.publiclyTrigger('eventDestroy', {
+ context: legacy,
+ args: [legacy, seg.el, _this]
+ });
+ }
+ });
+ }
+ };
+ // Event Rendering Utils
+ // -----------------------------------------------------------------------------------------------------------------
+ // Hides all rendered event segments linked to the given event
+ // RECURSIVE with subcomponents
+ DateComponent.prototype.showEventsWithId = function (eventDefId) {
+ this.getEventSegs().forEach(function (seg) {
+ if (seg.footprint.eventDef.id === eventDefId &&
+ seg.el // necessary?
+ ) {
+ seg.el.css('visibility', '');
+ }
+ });
+ this.callChildren('showEventsWithId', arguments);
+ };
+ // Shows all rendered event segments linked to the given event
+ // RECURSIVE with subcomponents
+ DateComponent.prototype.hideEventsWithId = function (eventDefId) {
+ this.getEventSegs().forEach(function (seg) {
+ if (seg.footprint.eventDef.id === eventDefId &&
+ seg.el // necessary?
+ ) {
+ seg.el.css('visibility', 'hidden');
+ }
+ });
+ this.callChildren('hideEventsWithId', arguments);
+ };
+ // Drag-n-Drop Rendering (for both events and external elements)
+ // ---------------------------------------------------------------------------------------------------------------
+ // Renders a visual indication of a event or external-element drag over the given drop zone.
+ // If an external-element, seg will be `null`.
+ // Must return elements used for any mock events.
+ DateComponent.prototype.renderDrag = function (eventFootprints, seg, isTouch) {
+ var renderedHelper = false;
+ this.iterChildren(function (child) {
+ if (child.renderDrag(eventFootprints, seg, isTouch)) {
+ renderedHelper = true;
+ }
+ });
+ return renderedHelper;
+ };
+ // Unrenders a visual indication of an event or external-element being dragged.
+ DateComponent.prototype.unrenderDrag = function () {
+ this.callChildren('unrenderDrag', arguments);
+ };
+ // Event Resizing
+ // ---------------------------------------------------------------------------------------------------------------
+ // Renders a visual indication of an event being resized.
+ DateComponent.prototype.renderEventResize = function (eventFootprints, seg, isTouch) {
+ this.callChildren('renderEventResize', arguments);
+ };
+ // Unrenders a visual indication of an event being resized.
+ DateComponent.prototype.unrenderEventResize = function () {
+ this.callChildren('unrenderEventResize', arguments);
+ };
+ // Selection
+ // ---------------------------------------------------------------------------------------------------------------
+ // Renders a visual indication of the selection
+ // TODO: rename to `renderSelection` after legacy is gone
+ DateComponent.prototype.renderSelectionFootprint = function (componentFootprint) {
+ this.renderHighlight(componentFootprint);
+ this.callChildren('renderSelectionFootprint', arguments);
+ };
+ // Unrenders a visual indication of selection
+ DateComponent.prototype.unrenderSelection = function () {
+ this.unrenderHighlight();
+ this.callChildren('unrenderSelection', arguments);
+ };
+ // Highlight
+ // ---------------------------------------------------------------------------------------------------------------
+ // Renders an emphasis on the given date range. Given a span (unzoned start/end and other misc data)
+ DateComponent.prototype.renderHighlight = function (componentFootprint) {
+ if (this.fillRenderer) {
+ this.fillRenderer.renderFootprint('highlight', componentFootprint, {
+ getClasses: function () {
+ return ['fc-highlight'];
+ }
+ });
+ }
+ this.callChildren('renderHighlight', arguments);
+ };
+ // Unrenders the emphasis on a date range
+ DateComponent.prototype.unrenderHighlight = function () {
+ if (this.fillRenderer) {
+ this.fillRenderer.unrender('highlight');
+ }
+ this.callChildren('unrenderHighlight', arguments);
+ };
+ // Hit Areas
+ // ---------------------------------------------------------------------------------------------------------------
+ // just because all DateComponents support this interface
+ // doesn't mean they need to have their own internal coord system. they can defer to sub-components.
+ DateComponent.prototype.hitsNeeded = function () {
+ if (!(this.hitsNeededDepth++)) {
+ this.prepareHits();
+ }
+ this.callChildren('hitsNeeded', arguments);
+ };
+ DateComponent.prototype.hitsNotNeeded = function () {
+ if (this.hitsNeededDepth && !(--this.hitsNeededDepth)) {
+ this.releaseHits();
+ }
+ this.callChildren('hitsNotNeeded', arguments);
+ };
+ DateComponent.prototype.prepareHits = function () {
+ // subclasses can implement
+ };
+ DateComponent.prototype.releaseHits = function () {
+ // subclasses can implement
+ };
+ // Given coordinates from the topleft of the document, return data about the date-related area underneath.
+ // Can return an object with arbitrary properties (although top/right/left/bottom are encouraged).
+ // Must have a `grid` property, a reference to this current grid. TODO: avoid this
+ // The returned object will be processed by getHitFootprint and getHitEl.
+ DateComponent.prototype.queryHit = function (leftOffset, topOffset) {
+ var childrenByUid = this.childrenByUid;
+ var uid;
+ var hit;
+ for (uid in childrenByUid) {
+ hit = childrenByUid[uid].queryHit(leftOffset, topOffset);
+ if (hit) {
+ break;
+ }
+ }
+ return hit;
+ };
+ DateComponent.prototype.getSafeHitFootprint = function (hit) {
+ var footprint = this.getHitFootprint(hit);
+ if (!this.dateProfile.activeUnzonedRange.containsRange(footprint.unzonedRange)) {
+ return null;
+ }
+ return footprint;
+ };
+ DateComponent.prototype.getHitFootprint = function (hit) {
+ // what about being abstract!?
+ };
+ // Given position-level information about a date-related area within the grid,
+ // should return a jQuery element that best represents it. passed to dayClick callback.
+ DateComponent.prototype.getHitEl = function (hit) {
+ // what about being abstract!?
+ };
+ /* Converting eventRange -> eventFootprint
+ ------------------------------------------------------------------------------------------------------------------*/
+ DateComponent.prototype.eventRangesToEventFootprints = function (eventRanges) {
+ var eventFootprints = [];
+ var i;
+ for (i = 0; i < eventRanges.length; i++) {
+ eventFootprints.push.apply(// append
+ eventFootprints, this.eventRangeToEventFootprints(eventRanges[i]));
+ }
+ return eventFootprints;
+ };
+ DateComponent.prototype.eventRangeToEventFootprints = function (eventRange) {
+ return [util_2.eventRangeToEventFootprint(eventRange)];
+ };
+ /* Converting componentFootprint/eventFootprint -> segs
+ ------------------------------------------------------------------------------------------------------------------*/
+ DateComponent.prototype.eventFootprintsToSegs = function (eventFootprints) {
+ var segs = [];
+ var i;
+ for (i = 0; i < eventFootprints.length; i++) {
+ segs.push.apply(segs, this.eventFootprintToSegs(eventFootprints[i]));
+ }
+ return segs;
+ };
+ // Given an event's span (unzoned start/end and other misc data), and the event itself,
+ // slices into segments and attaches event-derived properties to them.
+ // eventSpan - { start, end, isStart, isEnd, otherthings... }
+ DateComponent.prototype.eventFootprintToSegs = function (eventFootprint) {
+ var unzonedRange = eventFootprint.componentFootprint.unzonedRange;
+ var segs;
+ var i;
+ var seg;
+ segs = this.componentFootprintToSegs(eventFootprint.componentFootprint);
+ for (i = 0; i < segs.length; i++) {
+ seg = segs[i];
+ if (!unzonedRange.isStart) {
+ seg.isStart = false;
+ }
+ if (!unzonedRange.isEnd) {
+ seg.isEnd = false;
+ }
+ seg.footprint = eventFootprint;
+ // TODO: rename to seg.eventFootprint
+ }
+ return segs;
+ };
+ DateComponent.prototype.componentFootprintToSegs = function (componentFootprint) {
+ return [];
+ };
+ // Utils
+ // ---------------------------------------------------------------------------------------------------------------
+ DateComponent.prototype.callChildren = function (methodName, args) {
+ this.iterChildren(function (child) {
+ child[methodName].apply(child, args);
+ });
+ };
+ DateComponent.prototype.iterChildren = function (func) {
+ var childrenByUid = this.childrenByUid;
+ var uid;
+ for (uid in childrenByUid) {
+ func(childrenByUid[uid]);
+ }
+ };
+ DateComponent.prototype._getCalendar = function () {
+ var t = this;
+ return t.calendar || t.view.calendar;
+ };
+ DateComponent.prototype._getView = function () {
+ return this.view;
+ };
+ DateComponent.prototype._getDateProfile = function () {
+ return this._getView().get('dateProfile');
+ };
+ // Generates HTML for an anchor to another view into the calendar.
+ // Will either generate an tag or a non-clickable tag, depending on enabled settings.
+ // `gotoOptions` can either be a moment input, or an object with the form:
+ // { date, type, forceOff }
+ // `type` is a view-type like "day" or "week". default value is "day".
+ // `attrs` and `innerHtml` are use to generate the rest of the HTML tag.
+ DateComponent.prototype.buildGotoAnchorHtml = function (gotoOptions, attrs, innerHtml) {
+ var date;
+ var type;
+ var forceOff;
+ var finalOptions;
+ if ($.isPlainObject(gotoOptions)) {
+ date = gotoOptions.date;
+ type = gotoOptions.type;
+ forceOff = gotoOptions.forceOff;
+ }
+ else {
+ date = gotoOptions; // a single moment input
+ }
+ date = moment_ext_1.default(date); // if a string, parse it
+ finalOptions = {
+ date: date.format('YYYY-MM-DD'),
+ type: type || 'day'
+ };
+ if (typeof attrs === 'string') {
+ innerHtml = attrs;
+ attrs = null;
+ }
+ attrs = attrs ? ' ' + util_1.attrsToStr(attrs) : ''; // will have a leading space
+ innerHtml = innerHtml || '';
+ if (!forceOff && this.opt('navLinks')) {
+ return '' +
+ innerHtml +
+ '';
+ }
+ else {
+ return ' ' +
+ innerHtml +
+ '';
+ }
+ };
+ DateComponent.prototype.getAllDayHtml = function () {
+ return this.opt('allDayHtml') || util_1.htmlEscape(this.opt('allDayText'));
+ };
+ // Computes HTML classNames for a single-day element
+ DateComponent.prototype.getDayClasses = function (date, noThemeHighlight) {
+ var view = this._getView();
+ var classes = [];
+ var today;
+ if (!this.dateProfile.activeUnzonedRange.containsDate(date)) {
+ classes.push('fc-disabled-day'); // TODO: jQuery UI theme?
+ }
+ else {
+ classes.push('fc-' + util_1.dayIDs[date.day()]);
+ if (view.isDateInOtherMonth(date, this.dateProfile)) {
+ classes.push('fc-other-month');
+ }
+ today = view.calendar.getNow();
+ if (date.isSame(today, 'day')) {
+ classes.push('fc-today');
+ if (noThemeHighlight !== true) {
+ classes.push(view.calendar.theme.getClass('today'));
+ }
+ }
+ else if (date < today) {
+ classes.push('fc-past');
+ }
+ else {
+ classes.push('fc-future');
+ }
+ }
+ return classes;
+ };
+ // Utility for formatting a range. Accepts a range object, formatting string, and optional separator.
+ // Displays all-day ranges naturally, with an inclusive end. Takes the current isRTL into account.
+ // The timezones of the dates within `range` will be respected.
+ DateComponent.prototype.formatRange = function (range, isAllDay, formatStr, separator) {
+ var end = range.end;
+ if (isAllDay) {
+ end = end.clone().subtract(1); // convert to inclusive. last ms of previous day
+ }
+ return date_formatting_1.formatRange(range.start, end, formatStr, separator, this.isRTL);
+ };
+ // Compute the number of the give units in the "current" range.
+ // Will return a floating-point number. Won't round.
+ DateComponent.prototype.currentRangeAs = function (unit) {
+ return this._getDateProfile().currentUnzonedRange.as(unit);
+ };
+ // Returns the date range of the full days the given range visually appears to occupy.
+ // Returns a plain object with start/end, NOT an UnzonedRange!
+ DateComponent.prototype.computeDayRange = function (unzonedRange) {
+ var calendar = this._getCalendar();
+ var startDay = calendar.msToUtcMoment(unzonedRange.startMs, true); // the beginning of the day the range starts
+ var end = calendar.msToUtcMoment(unzonedRange.endMs);
+ var endTimeMS = +end.time(); // # of milliseconds into `endDay`
+ var endDay = end.clone().stripTime(); // the beginning of the day the range exclusively ends
+ // If the end time is actually inclusively part of the next day and is equal to or
+ // beyond the next day threshold, adjust the end to be the exclusive end of `endDay`.
+ // Otherwise, leaving it as inclusive will cause it to exclude `endDay`.
+ if (endTimeMS && endTimeMS >= this.nextDayThreshold) {
+ endDay.add(1, 'days');
+ }
+ // If end is within `startDay` but not past nextDayThreshold, assign the default duration of one day.
+ if (endDay <= startDay) {
+ endDay = startDay.clone().add(1, 'days');
+ }
+ return { start: startDay, end: endDay };
+ };
+ // Does the given range visually appear to occupy more than one day?
+ DateComponent.prototype.isMultiDayRange = function (unzonedRange) {
+ var dayRange = this.computeDayRange(unzonedRange);
+ return dayRange.end.diff(dayRange.start, 'days') > 1;
+ };
+ DateComponent.guid = 0; // TODO: better system for this?
+ return DateComponent;
+}(Component_1.default));
+exports.default = DateComponent;
+// legacy
+function convertEventsPayloadToLegacyArray(eventsPayload) {
+ var eventDefId;
+ var eventInstances;
+ var legacyEvents = [];
+ var i;
+ for (eventDefId in eventsPayload) {
+ eventInstances = eventsPayload[eventDefId].eventInstances;
+ for (i = 0; i < eventInstances.length; i++) {
+ legacyEvents.push(eventInstances[i].toLegacy());
+ }
+ }
+ return legacyEvents;
+}
+
+
+/***/ }),
+/* 220 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var $ = __webpack_require__(3);
+var moment = __webpack_require__(0);
+var util_1 = __webpack_require__(4);
+var options_1 = __webpack_require__(32);
+var Iterator_1 = __webpack_require__(238);
+var GlobalEmitter_1 = __webpack_require__(21);
+var EmitterMixin_1 = __webpack_require__(11);
+var ListenerMixin_1 = __webpack_require__(7);
+var Toolbar_1 = __webpack_require__(239);
+var OptionsManager_1 = __webpack_require__(240);
+var ViewSpecManager_1 = __webpack_require__(241);
+var Constraints_1 = __webpack_require__(207);
+var locale_1 = __webpack_require__(31);
+var moment_ext_1 = __webpack_require__(10);
+var UnzonedRange_1 = __webpack_require__(5);
+var ComponentFootprint_1 = __webpack_require__(12);
+var EventDateProfile_1 = __webpack_require__(17);
+var EventManager_1 = __webpack_require__(242);
+var BusinessHourGenerator_1 = __webpack_require__(212);
+var EventSourceParser_1 = __webpack_require__(38);
+var EventDefParser_1 = __webpack_require__(49);
+var SingleEventDef_1 = __webpack_require__(13);
+var EventDefMutation_1 = __webpack_require__(37);
+var EventSource_1 = __webpack_require__(6);
+var ThemeRegistry_1 = __webpack_require__(51);
+var Calendar = /** @class */ (function () {
+ function Calendar(el, overrides) {
+ this.loadingLevel = 0; // number of simultaneous loading tasks
+ this.ignoreUpdateViewSize = 0;
+ this.freezeContentHeightDepth = 0;
+ // declare the current calendar instance relies on GlobalEmitter. needed for garbage collection.
+ // unneeded() is called in destroy.
+ GlobalEmitter_1.default.needed();
+ this.el = el;
+ this.viewsByType = {};
+ this.optionsManager = new OptionsManager_1.default(this, overrides);
+ this.viewSpecManager = new ViewSpecManager_1.default(this.optionsManager, this);
+ this.initMomentInternals(); // needs to happen after options hash initialized
+ this.initCurrentDate();
+ this.initEventManager();
+ this.constraints = new Constraints_1.default(this.eventManager, this);
+ this.constructed();
+ }
+ Calendar.prototype.constructed = function () {
+ // useful for monkeypatching. used?
+ };
+ Calendar.prototype.getView = function () {
+ return this.view;
+ };
+ Calendar.prototype.publiclyTrigger = function (name, triggerInfo) {
+ var optHandler = this.opt(name);
+ var context;
+ var args;
+ if ($.isPlainObject(triggerInfo)) {
+ context = triggerInfo.context;
+ args = triggerInfo.args;
+ }
+ else if ($.isArray(triggerInfo)) {
+ args = triggerInfo;
+ }
+ if (context == null) {
+ context = this.el[0]; // fallback context
+ }
+ if (!args) {
+ args = [];
+ }
+ this.triggerWith(name, context, args); // Emitter's method
+ if (optHandler) {
+ return optHandler.apply(context, args);
+ }
+ };
+ Calendar.prototype.hasPublicHandlers = function (name) {
+ return this.hasHandlers(name) ||
+ this.opt(name); // handler specified in options
+ };
+ // Options Public API
+ // -----------------------------------------------------------------------------------------------------------------
+ // public getter/setter
+ Calendar.prototype.option = function (name, value) {
+ var newOptionHash;
+ if (typeof name === 'string') {
+ if (value === undefined) {
+ return this.optionsManager.get(name);
+ }
+ else {
+ newOptionHash = {};
+ newOptionHash[name] = value;
+ this.optionsManager.add(newOptionHash);
+ }
+ }
+ else if (typeof name === 'object') {
+ this.optionsManager.add(name);
+ }
+ };
+ // private getter
+ Calendar.prototype.opt = function (name) {
+ return this.optionsManager.get(name);
+ };
+ // View
+ // -----------------------------------------------------------------------------------------------------------------
+ // Given a view name for a custom view or a standard view, creates a ready-to-go View object
+ Calendar.prototype.instantiateView = function (viewType) {
+ var spec = this.viewSpecManager.getViewSpec(viewType);
+ if (!spec) {
+ throw new Error("View type \"" + viewType + "\" is not valid");
+ }
+ return new spec['class'](this, spec);
+ };
+ // Returns a boolean about whether the view is okay to instantiate at some point
+ Calendar.prototype.isValidViewType = function (viewType) {
+ return Boolean(this.viewSpecManager.getViewSpec(viewType));
+ };
+ Calendar.prototype.changeView = function (viewName, dateOrRange) {
+ if (dateOrRange) {
+ if (dateOrRange.start && dateOrRange.end) {
+ this.optionsManager.recordOverrides({
+ visibleRange: dateOrRange
+ });
+ }
+ else {
+ this.currentDate = this.moment(dateOrRange).stripZone(); // just like gotoDate
+ }
+ }
+ this.renderView(viewName);
+ };
+ // Forces navigation to a view for the given date.
+ // `viewType` can be a specific view name or a generic one like "week" or "day".
+ Calendar.prototype.zoomTo = function (newDate, viewType) {
+ var spec;
+ viewType = viewType || 'day'; // day is default zoom
+ spec = this.viewSpecManager.getViewSpec(viewType) ||
+ this.viewSpecManager.getUnitViewSpec(viewType);
+ this.currentDate = newDate.clone();
+ this.renderView(spec ? spec.type : null);
+ };
+ // Current Date
+ // -----------------------------------------------------------------------------------------------------------------
+ Calendar.prototype.initCurrentDate = function () {
+ var defaultDateInput = this.opt('defaultDate');
+ // compute the initial ambig-timezone date
+ if (defaultDateInput != null) {
+ this.currentDate = this.moment(defaultDateInput).stripZone();
+ }
+ else {
+ this.currentDate = this.getNow(); // getNow already returns unzoned
+ }
+ };
+ Calendar.prototype.prev = function () {
+ var view = this.view;
+ var prevInfo = view.dateProfileGenerator.buildPrev(view.get('dateProfile'));
+ if (prevInfo.isValid) {
+ this.currentDate = prevInfo.date;
+ this.renderView();
+ }
+ };
+ Calendar.prototype.next = function () {
+ var view = this.view;
+ var nextInfo = view.dateProfileGenerator.buildNext(view.get('dateProfile'));
+ if (nextInfo.isValid) {
+ this.currentDate = nextInfo.date;
+ this.renderView();
+ }
+ };
+ Calendar.prototype.prevYear = function () {
+ this.currentDate.add(-1, 'years');
+ this.renderView();
+ };
+ Calendar.prototype.nextYear = function () {
+ this.currentDate.add(1, 'years');
+ this.renderView();
+ };
+ Calendar.prototype.today = function () {
+ this.currentDate = this.getNow(); // should deny like prev/next?
+ this.renderView();
+ };
+ Calendar.prototype.gotoDate = function (zonedDateInput) {
+ this.currentDate = this.moment(zonedDateInput).stripZone();
+ this.renderView();
+ };
+ Calendar.prototype.incrementDate = function (delta) {
+ this.currentDate.add(moment.duration(delta));
+ this.renderView();
+ };
+ // for external API
+ Calendar.prototype.getDate = function () {
+ return this.applyTimezone(this.currentDate); // infuse the calendar's timezone
+ };
+ // Loading Triggering
+ // -----------------------------------------------------------------------------------------------------------------
+ // Should be called when any type of async data fetching begins
+ Calendar.prototype.pushLoading = function () {
+ if (!(this.loadingLevel++)) {
+ this.publiclyTrigger('loading', [true, this.view]);
+ }
+ };
+ // Should be called when any type of async data fetching completes
+ Calendar.prototype.popLoading = function () {
+ if (!(--this.loadingLevel)) {
+ this.publiclyTrigger('loading', [false, this.view]);
+ }
+ };
+ // High-level Rendering
+ // -----------------------------------------------------------------------------------
+ Calendar.prototype.render = function () {
+ if (!this.contentEl) {
+ this.initialRender();
+ }
+ else if (this.elementVisible()) {
+ // mainly for the public API
+ this.calcSize();
+ this.updateViewSize();
+ }
+ };
+ Calendar.prototype.initialRender = function () {
+ var _this = this;
+ var el = this.el;
+ el.addClass('fc');
+ // event delegation for nav links
+ el.on('click.fc', 'a[data-goto]', function (ev) {
+ var anchorEl = $(ev.currentTarget);
+ var gotoOptions = anchorEl.data('goto'); // will automatically parse JSON
+ var date = _this.moment(gotoOptions.date);
+ var viewType = gotoOptions.type;
+ // property like "navLinkDayClick". might be a string or a function
+ var customAction = _this.view.opt('navLink' + util_1.capitaliseFirstLetter(viewType) + 'Click');
+ if (typeof customAction === 'function') {
+ customAction(date, ev);
+ }
+ else {
+ if (typeof customAction === 'string') {
+ viewType = customAction;
+ }
+ _this.zoomTo(date, viewType);
+ }
+ });
+ // called immediately, and upon option change
+ this.optionsManager.watch('settingTheme', ['?theme', '?themeSystem'], function (opts) {
+ var themeClass = ThemeRegistry_1.getThemeSystemClass(opts.themeSystem || opts.theme);
+ var theme = new themeClass(_this.optionsManager);
+ var widgetClass = theme.getClass('widget');
+ _this.theme = theme;
+ if (widgetClass) {
+ el.addClass(widgetClass);
+ }
+ }, function () {
+ var widgetClass = _this.theme.getClass('widget');
+ _this.theme = null;
+ if (widgetClass) {
+ el.removeClass(widgetClass);
+ }
+ });
+ this.optionsManager.watch('settingBusinessHourGenerator', ['?businessHours'], function (deps) {
+ _this.businessHourGenerator = new BusinessHourGenerator_1.default(deps.businessHours, _this);
+ if (_this.view) {
+ _this.view.set('businessHourGenerator', _this.businessHourGenerator);
+ }
+ }, function () {
+ _this.businessHourGenerator = null;
+ });
+ // called immediately, and upon option change.
+ // HACK: locale often affects isRTL, so we explicitly listen to that too.
+ this.optionsManager.watch('applyingDirClasses', ['?isRTL', '?locale'], function (opts) {
+ el.toggleClass('fc-ltr', !opts.isRTL);
+ el.toggleClass('fc-rtl', opts.isRTL);
+ });
+ this.contentEl = $("").prependTo(el);
+ this.initToolbars();
+ this.renderHeader();
+ this.renderFooter();
+ this.renderView(this.opt('defaultView'));
+ if (this.opt('handleWindowResize')) {
+ $(window).resize(this.windowResizeProxy = util_1.debounce(// prevents rapid calls
+ this.windowResize.bind(this), this.opt('windowResizeDelay')));
+ }
+ };
+ Calendar.prototype.destroy = function () {
+ if (this.view) {
+ this.clearView();
+ }
+ this.toolbarsManager.proxyCall('removeElement');
+ this.contentEl.remove();
+ this.el.removeClass('fc fc-ltr fc-rtl');
+ // removes theme-related root className
+ this.optionsManager.unwatch('settingTheme');
+ this.optionsManager.unwatch('settingBusinessHourGenerator');
+ this.el.off('.fc'); // unbind nav link handlers
+ if (this.windowResizeProxy) {
+ $(window).unbind('resize', this.windowResizeProxy);
+ this.windowResizeProxy = null;
+ }
+ GlobalEmitter_1.default.unneeded();
+ };
+ Calendar.prototype.elementVisible = function () {
+ return this.el.is(':visible');
+ };
+ // Render Queue
+ // -----------------------------------------------------------------------------------------------------------------
+ Calendar.prototype.bindViewHandlers = function (view) {
+ var _this = this;
+ view.watch('titleForCalendar', ['title'], function (deps) {
+ if (view === _this.view) {
+ _this.setToolbarsTitle(deps.title);
+ }
+ });
+ view.watch('dateProfileForCalendar', ['dateProfile'], function (deps) {
+ if (view === _this.view) {
+ _this.currentDate = deps.dateProfile.date; // might have been constrained by view dates
+ _this.updateToolbarButtons(deps.dateProfile);
+ }
+ });
+ };
+ Calendar.prototype.unbindViewHandlers = function (view) {
+ view.unwatch('titleForCalendar');
+ view.unwatch('dateProfileForCalendar');
+ };
+ // View Rendering
+ // -----------------------------------------------------------------------------------
+ // Renders a view because of a date change, view-type change, or for the first time.
+ // If not given a viewType, keep the current view but render different dates.
+ // Accepts an optional scroll state to restore to.
+ Calendar.prototype.renderView = function (viewType) {
+ var oldView = this.view;
+ var newView;
+ this.freezeContentHeight();
+ if (oldView && viewType && oldView.type !== viewType) {
+ this.clearView();
+ }
+ // if viewType changed, or the view was never created, create a fresh view
+ if (!this.view && viewType) {
+ newView = this.view =
+ this.viewsByType[viewType] ||
+ (this.viewsByType[viewType] = this.instantiateView(viewType));
+ this.bindViewHandlers(newView);
+ newView.startBatchRender(); // so that setElement+setDate rendering are joined
+ newView.setElement($("").appendTo(this.contentEl));
+ this.toolbarsManager.proxyCall('activateButton', viewType);
+ }
+ if (this.view) {
+ // prevent unnecessary change firing
+ if (this.view.get('businessHourGenerator') !== this.businessHourGenerator) {
+ this.view.set('businessHourGenerator', this.businessHourGenerator);
+ }
+ this.view.setDate(this.currentDate);
+ if (newView) {
+ newView.stopBatchRender();
+ }
+ }
+ this.thawContentHeight();
+ };
+ // Unrenders the current view and reflects this change in the Header.
+ // Unregsiters the `view`, but does not remove from viewByType hash.
+ Calendar.prototype.clearView = function () {
+ var currentView = this.view;
+ this.toolbarsManager.proxyCall('deactivateButton', currentView.type);
+ this.unbindViewHandlers(currentView);
+ currentView.removeElement();
+ currentView.unsetDate(); // so bindViewHandlers doesn't fire with old values next time
+ this.view = null;
+ };
+ // Destroys the view, including the view object. Then, re-instantiates it and renders it.
+ // Maintains the same scroll state.
+ // TODO: maintain any other user-manipulated state.
+ Calendar.prototype.reinitView = function () {
+ var oldView = this.view;
+ var scroll = oldView.queryScroll(); // wouldn't be so complicated if Calendar owned the scroll
+ this.freezeContentHeight();
+ this.clearView();
+ this.calcSize();
+ this.renderView(oldView.type); // needs the type to freshly render
+ this.view.applyScroll(scroll);
+ this.thawContentHeight();
+ };
+ // Resizing
+ // -----------------------------------------------------------------------------------
+ Calendar.prototype.getSuggestedViewHeight = function () {
+ if (this.suggestedViewHeight == null) {
+ this.calcSize();
+ }
+ return this.suggestedViewHeight;
+ };
+ Calendar.prototype.isHeightAuto = function () {
+ return this.opt('contentHeight') === 'auto' || this.opt('height') === 'auto';
+ };
+ Calendar.prototype.updateViewSize = function (isResize) {
+ if (isResize === void 0) { isResize = false; }
+ var view = this.view;
+ var scroll;
+ if (!this.ignoreUpdateViewSize && view) {
+ if (isResize) {
+ this.calcSize();
+ scroll = view.queryScroll();
+ }
+ this.ignoreUpdateViewSize++;
+ view.updateSize(this.getSuggestedViewHeight(), this.isHeightAuto(), isResize);
+ this.ignoreUpdateViewSize--;
+ if (isResize) {
+ view.applyScroll(scroll);
+ }
+ return true; // signal success
+ }
+ };
+ Calendar.prototype.calcSize = function () {
+ if (this.elementVisible()) {
+ this._calcSize();
+ }
+ };
+ Calendar.prototype._calcSize = function () {
+ var contentHeightInput = this.opt('contentHeight');
+ var heightInput = this.opt('height');
+ if (typeof contentHeightInput === 'number') {
+ this.suggestedViewHeight = contentHeightInput;
+ }
+ else if (typeof contentHeightInput === 'function') {
+ this.suggestedViewHeight = contentHeightInput();
+ }
+ else if (typeof heightInput === 'number') {
+ this.suggestedViewHeight = heightInput - this.queryToolbarsHeight();
+ }
+ else if (typeof heightInput === 'function') {
+ this.suggestedViewHeight = heightInput() - this.queryToolbarsHeight();
+ }
+ else if (heightInput === 'parent') {
+ this.suggestedViewHeight = this.el.parent().height() - this.queryToolbarsHeight();
+ }
+ else {
+ this.suggestedViewHeight = Math.round(this.contentEl.width() /
+ Math.max(this.opt('aspectRatio'), .5));
+ }
+ };
+ Calendar.prototype.windowResize = function (ev) {
+ if (
+ // the purpose: so we don't process jqui "resize" events that have bubbled up
+ // cast to any because .target, which is Element, can't be compared to window for some reason.
+ ev.target === window &&
+ this.view &&
+ this.view.isDatesRendered) {
+ if (this.updateViewSize(true)) {
+ this.publiclyTrigger('windowResize', [this.view]);
+ }
+ }
+ };
+ /* Height "Freezing"
+ -----------------------------------------------------------------------------*/
+ Calendar.prototype.freezeContentHeight = function () {
+ if (!(this.freezeContentHeightDepth++)) {
+ this.forceFreezeContentHeight();
+ }
+ };
+ Calendar.prototype.forceFreezeContentHeight = function () {
+ this.contentEl.css({
+ width: '100%',
+ height: this.contentEl.height(),
+ overflow: 'hidden'
+ });
+ };
+ Calendar.prototype.thawContentHeight = function () {
+ this.freezeContentHeightDepth--;
+ // always bring back to natural height
+ this.contentEl.css({
+ width: '',
+ height: '',
+ overflow: ''
+ });
+ // but if there are future thaws, re-freeze
+ if (this.freezeContentHeightDepth) {
+ this.forceFreezeContentHeight();
+ }
+ };
+ // Toolbar
+ // -----------------------------------------------------------------------------------------------------------------
+ Calendar.prototype.initToolbars = function () {
+ this.header = new Toolbar_1.default(this, this.computeHeaderOptions());
+ this.footer = new Toolbar_1.default(this, this.computeFooterOptions());
+ this.toolbarsManager = new Iterator_1.default([this.header, this.footer]);
+ };
+ Calendar.prototype.computeHeaderOptions = function () {
+ return {
+ extraClasses: 'fc-header-toolbar',
+ layout: this.opt('header')
+ };
+ };
+ Calendar.prototype.computeFooterOptions = function () {
+ return {
+ extraClasses: 'fc-footer-toolbar',
+ layout: this.opt('footer')
+ };
+ };
+ // can be called repeatedly and Header will rerender
+ Calendar.prototype.renderHeader = function () {
+ var header = this.header;
+ header.setToolbarOptions(this.computeHeaderOptions());
+ header.render();
+ if (header.el) {
+ this.el.prepend(header.el);
+ }
+ };
+ // can be called repeatedly and Footer will rerender
+ Calendar.prototype.renderFooter = function () {
+ var footer = this.footer;
+ footer.setToolbarOptions(this.computeFooterOptions());
+ footer.render();
+ if (footer.el) {
+ this.el.append(footer.el);
+ }
+ };
+ Calendar.prototype.setToolbarsTitle = function (title) {
+ this.toolbarsManager.proxyCall('updateTitle', title);
+ };
+ Calendar.prototype.updateToolbarButtons = function (dateProfile) {
+ var now = this.getNow();
+ var view = this.view;
+ var todayInfo = view.dateProfileGenerator.build(now);
+ var prevInfo = view.dateProfileGenerator.buildPrev(view.get('dateProfile'));
+ var nextInfo = view.dateProfileGenerator.buildNext(view.get('dateProfile'));
+ this.toolbarsManager.proxyCall((todayInfo.isValid && !dateProfile.currentUnzonedRange.containsDate(now)) ?
+ 'enableButton' :
+ 'disableButton', 'today');
+ this.toolbarsManager.proxyCall(prevInfo.isValid ?
+ 'enableButton' :
+ 'disableButton', 'prev');
+ this.toolbarsManager.proxyCall(nextInfo.isValid ?
+ 'enableButton' :
+ 'disableButton', 'next');
+ };
+ Calendar.prototype.queryToolbarsHeight = function () {
+ return this.toolbarsManager.items.reduce(function (accumulator, toolbar) {
+ var toolbarHeight = toolbar.el ? toolbar.el.outerHeight(true) : 0; // includes margin
+ return accumulator + toolbarHeight;
+ }, 0);
+ };
+ // Selection
+ // -----------------------------------------------------------------------------------------------------------------
+ // this public method receives start/end dates in any format, with any timezone
+ Calendar.prototype.select = function (zonedStartInput, zonedEndInput) {
+ this.view.select(this.buildSelectFootprint.apply(this, arguments));
+ };
+ Calendar.prototype.unselect = function () {
+ if (this.view) {
+ this.view.unselect();
+ }
+ };
+ // Given arguments to the select method in the API, returns a span (unzoned start/end and other info)
+ Calendar.prototype.buildSelectFootprint = function (zonedStartInput, zonedEndInput) {
+ var start = this.moment(zonedStartInput).stripZone();
+ var end;
+ if (zonedEndInput) {
+ end = this.moment(zonedEndInput).stripZone();
+ }
+ else if (start.hasTime()) {
+ end = start.clone().add(this.defaultTimedEventDuration);
+ }
+ else {
+ end = start.clone().add(this.defaultAllDayEventDuration);
+ }
+ return new ComponentFootprint_1.default(new UnzonedRange_1.default(start, end), !start.hasTime());
+ };
+ // Date Utils
+ // -----------------------------------------------------------------------------------------------------------------
+ Calendar.prototype.initMomentInternals = function () {
+ var _this = this;
+ this.defaultAllDayEventDuration = moment.duration(this.opt('defaultAllDayEventDuration'));
+ this.defaultTimedEventDuration = moment.duration(this.opt('defaultTimedEventDuration'));
+ // Called immediately, and when any of the options change.
+ // Happens before any internal objects rebuild or rerender, because this is very core.
+ this.optionsManager.watch('buildingMomentLocale', [
+ '?locale', '?monthNames', '?monthNamesShort', '?dayNames', '?dayNamesShort',
+ '?firstDay', '?weekNumberCalculation'
+ ], function (opts) {
+ var weekNumberCalculation = opts.weekNumberCalculation;
+ var firstDay = opts.firstDay;
+ var _week;
+ // normalize
+ if (weekNumberCalculation === 'iso') {
+ weekNumberCalculation = 'ISO'; // normalize
+ }
+ var localeData = Object.create(// make a cheap copy
+ locale_1.getMomentLocaleData(opts.locale) // will fall back to en
+ );
+ if (opts.monthNames) {
+ localeData._months = opts.monthNames;
+ }
+ if (opts.monthNamesShort) {
+ localeData._monthsShort = opts.monthNamesShort;
+ }
+ if (opts.dayNames) {
+ localeData._weekdays = opts.dayNames;
+ }
+ if (opts.dayNamesShort) {
+ localeData._weekdaysShort = opts.dayNamesShort;
+ }
+ if (firstDay == null && weekNumberCalculation === 'ISO') {
+ firstDay = 1;
+ }
+ if (firstDay != null) {
+ _week = Object.create(localeData._week); // _week: { dow: # }
+ _week.dow = firstDay;
+ localeData._week = _week;
+ }
+ if (weekNumberCalculation === 'ISO' ||
+ weekNumberCalculation === 'local' ||
+ typeof weekNumberCalculation === 'function') {
+ localeData._fullCalendar_weekCalc = weekNumberCalculation; // moment-ext will know what to do with it
+ }
+ _this.localeData = localeData;
+ // If the internal current date object already exists, move to new locale.
+ // We do NOT need to do this technique for event dates, because this happens when converting to "segments".
+ if (_this.currentDate) {
+ _this.localizeMoment(_this.currentDate); // sets to localeData
+ }
+ });
+ };
+ // Builds a moment using the settings of the current calendar: timezone and locale.
+ // Accepts anything the vanilla moment() constructor accepts.
+ Calendar.prototype.moment = function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var mom;
+ if (this.opt('timezone') === 'local') {
+ mom = moment_ext_1.default.apply(null, args);
+ // Force the moment to be local, because momentExt doesn't guarantee it.
+ if (mom.hasTime()) {
+ mom.local();
+ }
+ }
+ else if (this.opt('timezone') === 'UTC') {
+ mom = moment_ext_1.default.utc.apply(null, args); // process as UTC
+ }
+ else {
+ mom = moment_ext_1.default.parseZone.apply(null, args); // let the input decide the zone
+ }
+ this.localizeMoment(mom); // TODO
+ return mom;
+ };
+ Calendar.prototype.msToMoment = function (ms, forceAllDay) {
+ var mom = moment_ext_1.default.utc(ms); // TODO: optimize by using Date.UTC
+ if (forceAllDay) {
+ mom.stripTime();
+ }
+ else {
+ mom = this.applyTimezone(mom); // may or may not apply locale
+ }
+ this.localizeMoment(mom);
+ return mom;
+ };
+ Calendar.prototype.msToUtcMoment = function (ms, forceAllDay) {
+ var mom = moment_ext_1.default.utc(ms); // TODO: optimize by using Date.UTC
+ if (forceAllDay) {
+ mom.stripTime();
+ }
+ this.localizeMoment(mom);
+ return mom;
+ };
+ // Updates the given moment's locale settings to the current calendar locale settings.
+ Calendar.prototype.localizeMoment = function (mom) {
+ mom._locale = this.localeData;
+ };
+ // Returns a boolean about whether or not the calendar knows how to calculate
+ // the timezone offset of arbitrary dates in the current timezone.
+ Calendar.prototype.getIsAmbigTimezone = function () {
+ return this.opt('timezone') !== 'local' && this.opt('timezone') !== 'UTC';
+ };
+ // Returns a copy of the given date in the current timezone. Has no effect on dates without times.
+ Calendar.prototype.applyTimezone = function (date) {
+ if (!date.hasTime()) {
+ return date.clone();
+ }
+ var zonedDate = this.moment(date.toArray());
+ var timeAdjust = date.time().asMilliseconds() - zonedDate.time().asMilliseconds();
+ var adjustedZonedDate;
+ // Safari sometimes has problems with this coersion when near DST. Adjust if necessary. (bug #2396)
+ if (timeAdjust) {
+ adjustedZonedDate = zonedDate.clone().add(timeAdjust); // add milliseconds
+ if (date.time().asMilliseconds() - adjustedZonedDate.time().asMilliseconds() === 0) {
+ zonedDate = adjustedZonedDate;
+ }
+ }
+ return zonedDate;
+ };
+ /*
+ Assumes the footprint is non-open-ended.
+ */
+ Calendar.prototype.footprintToDateProfile = function (componentFootprint, ignoreEnd) {
+ if (ignoreEnd === void 0) { ignoreEnd = false; }
+ var start = moment_ext_1.default.utc(componentFootprint.unzonedRange.startMs);
+ var end;
+ if (!ignoreEnd) {
+ end = moment_ext_1.default.utc(componentFootprint.unzonedRange.endMs);
+ }
+ if (componentFootprint.isAllDay) {
+ start.stripTime();
+ if (end) {
+ end.stripTime();
+ }
+ }
+ else {
+ start = this.applyTimezone(start);
+ if (end) {
+ end = this.applyTimezone(end);
+ }
+ }
+ return new EventDateProfile_1.default(start, end, this);
+ };
+ // Returns a moment for the current date, as defined by the client's computer or from the `now` option.
+ // Will return an moment with an ambiguous timezone.
+ Calendar.prototype.getNow = function () {
+ var now = this.opt('now');
+ if (typeof now === 'function') {
+ now = now();
+ }
+ return this.moment(now).stripZone();
+ };
+ // Produces a human-readable string for the given duration.
+ // Side-effect: changes the locale of the given duration.
+ Calendar.prototype.humanizeDuration = function (duration) {
+ return duration.locale(this.opt('locale')).humanize();
+ };
+ // will return `null` if invalid range
+ Calendar.prototype.parseUnzonedRange = function (rangeInput) {
+ var start = null;
+ var end = null;
+ if (rangeInput.start) {
+ start = this.moment(rangeInput.start).stripZone();
+ }
+ if (rangeInput.end) {
+ end = this.moment(rangeInput.end).stripZone();
+ }
+ if (!start && !end) {
+ return null;
+ }
+ if (start && end && end.isBefore(start)) {
+ return null;
+ }
+ return new UnzonedRange_1.default(start, end);
+ };
+ // Event-Date Utilities
+ // -----------------------------------------------------------------------------------------------------------------
+ Calendar.prototype.initEventManager = function () {
+ var _this = this;
+ var eventManager = new EventManager_1.default(this);
+ var rawSources = this.opt('eventSources') || [];
+ var singleRawSource = this.opt('events');
+ this.eventManager = eventManager;
+ if (singleRawSource) {
+ rawSources.unshift(singleRawSource);
+ }
+ eventManager.on('release', function (eventsPayload) {
+ _this.trigger('eventsReset', eventsPayload);
+ });
+ eventManager.freeze();
+ rawSources.forEach(function (rawSource) {
+ var source = EventSourceParser_1.default.parse(rawSource, _this);
+ if (source) {
+ eventManager.addSource(source);
+ }
+ });
+ eventManager.thaw();
+ };
+ Calendar.prototype.requestEvents = function (start, end) {
+ return this.eventManager.requestEvents(start, end, this.opt('timezone'), !this.opt('lazyFetching'));
+ };
+ // Get an event's normalized end date. If not present, calculate it from the defaults.
+ Calendar.prototype.getEventEnd = function (event) {
+ if (event.end) {
+ return event.end.clone();
+ }
+ else {
+ return this.getDefaultEventEnd(event.allDay, event.start);
+ }
+ };
+ // Given an event's allDay status and start date, return what its fallback end date should be.
+ // TODO: rename to computeDefaultEventEnd
+ Calendar.prototype.getDefaultEventEnd = function (allDay, zonedStart) {
+ var end = zonedStart.clone();
+ if (allDay) {
+ end.stripTime().add(this.defaultAllDayEventDuration);
+ }
+ else {
+ end.add(this.defaultTimedEventDuration);
+ }
+ if (this.getIsAmbigTimezone()) {
+ end.stripZone(); // we don't know what the tzo should be
+ }
+ return end;
+ };
+ // Public Events API
+ // -----------------------------------------------------------------------------------------------------------------
+ Calendar.prototype.rerenderEvents = function () {
+ this.view.flash('displayingEvents');
+ };
+ Calendar.prototype.refetchEvents = function () {
+ this.eventManager.refetchAllSources();
+ };
+ Calendar.prototype.renderEvents = function (eventInputs, isSticky) {
+ this.eventManager.freeze();
+ for (var i = 0; i < eventInputs.length; i++) {
+ this.renderEvent(eventInputs[i], isSticky);
+ }
+ this.eventManager.thaw();
+ };
+ Calendar.prototype.renderEvent = function (eventInput, isSticky) {
+ if (isSticky === void 0) { isSticky = false; }
+ var eventManager = this.eventManager;
+ var eventDef = EventDefParser_1.default.parse(eventInput, eventInput.source || eventManager.stickySource);
+ if (eventDef) {
+ eventManager.addEventDef(eventDef, isSticky);
+ }
+ };
+ // legacyQuery operates on legacy event instance objects
+ Calendar.prototype.removeEvents = function (legacyQuery) {
+ var eventManager = this.eventManager;
+ var legacyInstances = [];
+ var idMap = {};
+ var eventDef;
+ var i;
+ if (legacyQuery == null) {
+ eventManager.removeAllEventDefs(); // persist=true
+ }
+ else {
+ eventManager.getEventInstances().forEach(function (eventInstance) {
+ legacyInstances.push(eventInstance.toLegacy());
+ });
+ legacyInstances = filterLegacyEventInstances(legacyInstances, legacyQuery);
+ // compute unique IDs
+ for (i = 0; i < legacyInstances.length; i++) {
+ eventDef = this.eventManager.getEventDefByUid(legacyInstances[i]._id);
+ idMap[eventDef.id] = true;
+ }
+ eventManager.freeze();
+ for (i in idMap) {
+ eventManager.removeEventDefsById(i); // persist=true
+ }
+ eventManager.thaw();
+ }
+ };
+ // legacyQuery operates on legacy event instance objects
+ Calendar.prototype.clientEvents = function (legacyQuery) {
+ var legacyEventInstances = [];
+ this.eventManager.getEventInstances().forEach(function (eventInstance) {
+ legacyEventInstances.push(eventInstance.toLegacy());
+ });
+ return filterLegacyEventInstances(legacyEventInstances, legacyQuery);
+ };
+ Calendar.prototype.updateEvents = function (eventPropsArray) {
+ this.eventManager.freeze();
+ for (var i = 0; i < eventPropsArray.length; i++) {
+ this.updateEvent(eventPropsArray[i]);
+ }
+ this.eventManager.thaw();
+ };
+ Calendar.prototype.updateEvent = function (eventProps) {
+ var eventDef = this.eventManager.getEventDefByUid(eventProps._id);
+ var eventInstance;
+ var eventDefMutation;
+ if (eventDef instanceof SingleEventDef_1.default) {
+ eventInstance = eventDef.buildInstance();
+ eventDefMutation = EventDefMutation_1.default.createFromRawProps(eventInstance, eventProps, // raw props
+ null // largeUnit -- who uses it?
+ );
+ this.eventManager.mutateEventsWithId(eventDef.id, eventDefMutation); // will release
+ }
+ };
+ // Public Event Sources API
+ // ------------------------------------------------------------------------------------
+ Calendar.prototype.getEventSources = function () {
+ return this.eventManager.otherSources.slice(); // clone
+ };
+ Calendar.prototype.getEventSourceById = function (id) {
+ return this.eventManager.getSourceById(EventSource_1.default.normalizeId(id));
+ };
+ Calendar.prototype.addEventSource = function (sourceInput) {
+ var source = EventSourceParser_1.default.parse(sourceInput, this);
+ if (source) {
+ this.eventManager.addSource(source);
+ }
+ };
+ Calendar.prototype.removeEventSources = function (sourceMultiQuery) {
+ var eventManager = this.eventManager;
+ var sources;
+ var i;
+ if (sourceMultiQuery == null) {
+ this.eventManager.removeAllSources();
+ }
+ else {
+ sources = eventManager.multiQuerySources(sourceMultiQuery);
+ eventManager.freeze();
+ for (i = 0; i < sources.length; i++) {
+ eventManager.removeSource(sources[i]);
+ }
+ eventManager.thaw();
+ }
+ };
+ Calendar.prototype.removeEventSource = function (sourceQuery) {
+ var eventManager = this.eventManager;
+ var sources = eventManager.querySources(sourceQuery);
+ var i;
+ eventManager.freeze();
+ for (i = 0; i < sources.length; i++) {
+ eventManager.removeSource(sources[i]);
+ }
+ eventManager.thaw();
+ };
+ Calendar.prototype.refetchEventSources = function (sourceMultiQuery) {
+ var eventManager = this.eventManager;
+ var sources = eventManager.multiQuerySources(sourceMultiQuery);
+ var i;
+ eventManager.freeze();
+ for (i = 0; i < sources.length; i++) {
+ eventManager.refetchSource(sources[i]);
+ }
+ eventManager.thaw();
+ };
+ // not for internal use. use options module directly instead.
+ Calendar.defaults = options_1.globalDefaults;
+ Calendar.englishDefaults = options_1.englishDefaults;
+ Calendar.rtlDefaults = options_1.rtlDefaults;
+ return Calendar;
+}());
+exports.default = Calendar;
+EmitterMixin_1.default.mixInto(Calendar);
+ListenerMixin_1.default.mixInto(Calendar);
+function filterLegacyEventInstances(legacyEventInstances, legacyQuery) {
+ if (legacyQuery == null) {
+ return legacyEventInstances;
+ }
+ else if ($.isFunction(legacyQuery)) {
+ return legacyEventInstances.filter(legacyQuery);
+ }
+ else {
+ legacyQuery += ''; // normalize to string
+ return legacyEventInstances.filter(function (legacyEventInstance) {
+ // soft comparison because id not be normalized to string
+ // tslint:disable-next-line
+ return legacyEventInstance.id == legacyQuery ||
+ legacyEventInstance._id === legacyQuery; // can specify internal id, but must exactly match
+ });
+ }
+}
+
+
+/***/ }),
+/* 221 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var moment = __webpack_require__(0);
+var util_1 = __webpack_require__(4);
+var UnzonedRange_1 = __webpack_require__(5);
+var DateProfileGenerator = /** @class */ (function () {
+ function DateProfileGenerator(_view) {
+ this._view = _view;
+ }
+ DateProfileGenerator.prototype.opt = function (name) {
+ return this._view.opt(name);
+ };
+ DateProfileGenerator.prototype.trimHiddenDays = function (unzonedRange) {
+ return this._view.trimHiddenDays(unzonedRange);
+ };
+ DateProfileGenerator.prototype.msToUtcMoment = function (ms, forceAllDay) {
+ return this._view.calendar.msToUtcMoment(ms, forceAllDay);
+ };
+ /* Date Range Computation
+ ------------------------------------------------------------------------------------------------------------------*/
+ // Builds a structure with info about what the dates/ranges will be for the "prev" view.
+ DateProfileGenerator.prototype.buildPrev = function (currentDateProfile) {
+ var prevDate = currentDateProfile.date.clone()
+ .startOf(currentDateProfile.currentRangeUnit)
+ .subtract(currentDateProfile.dateIncrement);
+ return this.build(prevDate, -1);
+ };
+ // Builds a structure with info about what the dates/ranges will be for the "next" view.
+ DateProfileGenerator.prototype.buildNext = function (currentDateProfile) {
+ var nextDate = currentDateProfile.date.clone()
+ .startOf(currentDateProfile.currentRangeUnit)
+ .add(currentDateProfile.dateIncrement);
+ return this.build(nextDate, 1);
+ };
+ // Builds a structure holding dates/ranges for rendering around the given date.
+ // Optional direction param indicates whether the date is being incremented/decremented
+ // from its previous value. decremented = -1, incremented = 1 (default).
+ DateProfileGenerator.prototype.build = function (date, direction, forceToValid) {
+ if (forceToValid === void 0) { forceToValid = false; }
+ var isDateAllDay = !date.hasTime();
+ var validUnzonedRange;
+ var minTime = null;
+ var maxTime = null;
+ var currentInfo;
+ var isRangeAllDay;
+ var renderUnzonedRange;
+ var activeUnzonedRange;
+ var isValid;
+ validUnzonedRange = this.buildValidRange();
+ validUnzonedRange = this.trimHiddenDays(validUnzonedRange);
+ if (forceToValid) {
+ date = this.msToUtcMoment(validUnzonedRange.constrainDate(date), // returns MS
+ isDateAllDay);
+ }
+ currentInfo = this.buildCurrentRangeInfo(date, direction);
+ isRangeAllDay = /^(year|month|week|day)$/.test(currentInfo.unit);
+ renderUnzonedRange = this.buildRenderRange(this.trimHiddenDays(currentInfo.unzonedRange), currentInfo.unit, isRangeAllDay);
+ renderUnzonedRange = this.trimHiddenDays(renderUnzonedRange);
+ activeUnzonedRange = renderUnzonedRange.clone();
+ if (!this.opt('showNonCurrentDates')) {
+ activeUnzonedRange = activeUnzonedRange.intersect(currentInfo.unzonedRange);
+ }
+ minTime = moment.duration(this.opt('minTime'));
+ maxTime = moment.duration(this.opt('maxTime'));
+ activeUnzonedRange = this.adjustActiveRange(activeUnzonedRange, minTime, maxTime);
+ activeUnzonedRange = activeUnzonedRange.intersect(validUnzonedRange); // might return null
+ if (activeUnzonedRange) {
+ date = this.msToUtcMoment(activeUnzonedRange.constrainDate(date), // returns MS
+ isDateAllDay);
+ }
+ // it's invalid if the originally requested date is not contained,
+ // or if the range is completely outside of the valid range.
+ isValid = currentInfo.unzonedRange.intersectsWith(validUnzonedRange);
+ return {
+ // constraint for where prev/next operations can go and where events can be dragged/resized to.
+ // an object with optional start and end properties.
+ validUnzonedRange: validUnzonedRange,
+ // range the view is formally responsible for.
+ // for example, a month view might have 1st-31st, excluding padded dates
+ currentUnzonedRange: currentInfo.unzonedRange,
+ // name of largest unit being displayed, like "month" or "week"
+ currentRangeUnit: currentInfo.unit,
+ isRangeAllDay: isRangeAllDay,
+ // dates that display events and accept drag-n-drop
+ // will be `null` if no dates accept events
+ activeUnzonedRange: activeUnzonedRange,
+ // date range with a rendered skeleton
+ // includes not-active days that need some sort of DOM
+ renderUnzonedRange: renderUnzonedRange,
+ // Duration object that denotes the first visible time of any given day
+ minTime: minTime,
+ // Duration object that denotes the exclusive visible end time of any given day
+ maxTime: maxTime,
+ isValid: isValid,
+ date: date,
+ // how far the current date will move for a prev/next operation
+ dateIncrement: this.buildDateIncrement(currentInfo.duration)
+ // pass a fallback (might be null) ^
+ };
+ };
+ // Builds an object with optional start/end properties.
+ // Indicates the minimum/maximum dates to display.
+ // not responsible for trimming hidden days.
+ DateProfileGenerator.prototype.buildValidRange = function () {
+ return this._view.getUnzonedRangeOption('validRange', this._view.calendar.getNow()) ||
+ new UnzonedRange_1.default(); // completely open-ended
+ };
+ // Builds a structure with info about the "current" range, the range that is
+ // highlighted as being the current month for example.
+ // See build() for a description of `direction`.
+ // Guaranteed to have `range` and `unit` properties. `duration` is optional.
+ // TODO: accept a MS-time instead of a moment `date`?
+ DateProfileGenerator.prototype.buildCurrentRangeInfo = function (date, direction) {
+ var viewSpec = this._view.viewSpec;
+ var duration = null;
+ var unit = null;
+ var unzonedRange = null;
+ var dayCount;
+ if (viewSpec.duration) {
+ duration = viewSpec.duration;
+ unit = viewSpec.durationUnit;
+ unzonedRange = this.buildRangeFromDuration(date, direction, duration, unit);
+ }
+ else if ((dayCount = this.opt('dayCount'))) {
+ unit = 'day';
+ unzonedRange = this.buildRangeFromDayCount(date, direction, dayCount);
+ }
+ else if ((unzonedRange = this.buildCustomVisibleRange(date))) {
+ unit = util_1.computeGreatestUnit(unzonedRange.getStart(), unzonedRange.getEnd());
+ }
+ else {
+ duration = this.getFallbackDuration();
+ unit = util_1.computeGreatestUnit(duration);
+ unzonedRange = this.buildRangeFromDuration(date, direction, duration, unit);
+ }
+ return { duration: duration, unit: unit, unzonedRange: unzonedRange };
+ };
+ DateProfileGenerator.prototype.getFallbackDuration = function () {
+ return moment.duration({ days: 1 });
+ };
+ // Returns a new activeUnzonedRange to have time values (un-ambiguate)
+ // minTime or maxTime causes the range to expand.
+ DateProfileGenerator.prototype.adjustActiveRange = function (unzonedRange, minTime, maxTime) {
+ var start = unzonedRange.getStart();
+ var end = unzonedRange.getEnd();
+ if (this._view.usesMinMaxTime) {
+ if (minTime < 0) {
+ start.time(0).add(minTime);
+ }
+ if (maxTime > 24 * 60 * 60 * 1000) {
+ end.time(maxTime - (24 * 60 * 60 * 1000));
+ }
+ }
+ return new UnzonedRange_1.default(start, end);
+ };
+ // Builds the "current" range when it is specified as an explicit duration.
+ // `unit` is the already-computed computeGreatestUnit value of duration.
+ // TODO: accept a MS-time instead of a moment `date`?
+ DateProfileGenerator.prototype.buildRangeFromDuration = function (date, direction, duration, unit) {
+ var alignment = this.opt('dateAlignment');
+ var dateIncrementInput;
+ var dateIncrementDuration;
+ var start;
+ var end;
+ var res;
+ // compute what the alignment should be
+ if (!alignment) {
+ dateIncrementInput = this.opt('dateIncrement');
+ if (dateIncrementInput) {
+ dateIncrementDuration = moment.duration(dateIncrementInput);
+ // use the smaller of the two units
+ if (dateIncrementDuration < duration) {
+ alignment = util_1.computeDurationGreatestUnit(dateIncrementDuration, dateIncrementInput);
+ }
+ else {
+ alignment = unit;
+ }
+ }
+ else {
+ alignment = unit;
+ }
+ }
+ // if the view displays a single day or smaller
+ if (duration.as('days') <= 1) {
+ if (this._view.isHiddenDay(start)) {
+ start = this._view.skipHiddenDays(start, direction);
+ start.startOf('day');
+ }
+ }
+ function computeRes() {
+ start = date.clone().startOf(alignment);
+ end = start.clone().add(duration);
+ res = new UnzonedRange_1.default(start, end);
+ }
+ computeRes();
+ // if range is completely enveloped by hidden days, go past the hidden days
+ if (!this.trimHiddenDays(res)) {
+ date = this._view.skipHiddenDays(date, direction);
+ computeRes();
+ }
+ return res;
+ };
+ // Builds the "current" range when a dayCount is specified.
+ // TODO: accept a MS-time instead of a moment `date`?
+ DateProfileGenerator.prototype.buildRangeFromDayCount = function (date, direction, dayCount) {
+ var customAlignment = this.opt('dateAlignment');
+ var runningCount = 0;
+ var start = date.clone();
+ var end;
+ if (customAlignment) {
+ start.startOf(customAlignment);
+ }
+ start.startOf('day');
+ start = this._view.skipHiddenDays(start, direction);
+ end = start.clone();
+ do {
+ end.add(1, 'day');
+ if (!this._view.isHiddenDay(end)) {
+ runningCount++;
+ }
+ } while (runningCount < dayCount);
+ return new UnzonedRange_1.default(start, end);
+ };
+ // Builds a normalized range object for the "visible" range,
+ // which is a way to define the currentUnzonedRange and activeUnzonedRange at the same time.
+ // TODO: accept a MS-time instead of a moment `date`?
+ DateProfileGenerator.prototype.buildCustomVisibleRange = function (date) {
+ var visibleUnzonedRange = this._view.getUnzonedRangeOption('visibleRange', this._view.calendar.applyTimezone(date) // correct zone. also generates new obj that avoids mutations
+ );
+ if (visibleUnzonedRange && (visibleUnzonedRange.startMs == null || visibleUnzonedRange.endMs == null)) {
+ return null;
+ }
+ return visibleUnzonedRange;
+ };
+ // Computes the range that will represent the element/cells for *rendering*,
+ // but which may have voided days/times.
+ // not responsible for trimming hidden days.
+ DateProfileGenerator.prototype.buildRenderRange = function (currentUnzonedRange, currentRangeUnit, isRangeAllDay) {
+ return currentUnzonedRange.clone();
+ };
+ // Compute the duration value that should be added/substracted to the current date
+ // when a prev/next operation happens.
+ DateProfileGenerator.prototype.buildDateIncrement = function (fallback) {
+ var dateIncrementInput = this.opt('dateIncrement');
+ var customAlignment;
+ if (dateIncrementInput) {
+ return moment.duration(dateIncrementInput);
+ }
+ else if ((customAlignment = this.opt('dateAlignment'))) {
+ return moment.duration(1, customAlignment);
+ }
+ else if (fallback) {
+ return fallback;
+ }
+ else {
+ return moment.duration({ days: 1 });
+ }
+ };
+ return DateProfileGenerator;
+}());
+exports.default = DateProfileGenerator;
+
+
+/***/ }),
+/* 222 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var moment = __webpack_require__(0);
+var exportHooks = __webpack_require__(16);
+var util_1 = __webpack_require__(4);
+var moment_ext_1 = __webpack_require__(10);
+var ListenerMixin_1 = __webpack_require__(7);
+var HitDragListener_1 = __webpack_require__(23);
+var SingleEventDef_1 = __webpack_require__(13);
+var EventInstanceGroup_1 = __webpack_require__(18);
+var EventSource_1 = __webpack_require__(6);
+var Interaction_1 = __webpack_require__(15);
+var ExternalDropping = /** @class */ (function (_super) {
+ tslib_1.__extends(ExternalDropping, _super);
+ function ExternalDropping() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.isDragging = false; // jqui-dragging an external element? boolean
+ return _this;
+ }
+ /*
+ component impements:
+ - eventRangesToEventFootprints
+ - isEventInstanceGroupAllowed
+ - isExternalInstanceGroupAllowed
+ - renderDrag
+ - unrenderDrag
+ */
+ ExternalDropping.prototype.end = function () {
+ if (this.dragListener) {
+ this.dragListener.endInteraction();
+ }
+ };
+ ExternalDropping.prototype.bindToDocument = function () {
+ this.listenTo($(document), {
+ dragstart: this.handleDragStart,
+ sortstart: this.handleDragStart // jqui
+ });
+ };
+ ExternalDropping.prototype.unbindFromDocument = function () {
+ this.stopListeningTo($(document));
+ };
+ // Called when a jQuery UI drag is initiated anywhere in the DOM
+ ExternalDropping.prototype.handleDragStart = function (ev, ui) {
+ var el;
+ var accept;
+ if (this.opt('droppable')) {
+ el = $((ui ? ui.item : null) || ev.target);
+ // Test that the dragged element passes the dropAccept selector or filter function.
+ // FYI, the default is "*" (matches all)
+ accept = this.opt('dropAccept');
+ if ($.isFunction(accept) ? accept.call(el[0], el) : el.is(accept)) {
+ if (!this.isDragging) {
+ this.listenToExternalDrag(el, ev, ui);
+ }
+ }
+ }
+ };
+ // Called when a jQuery UI drag starts and it needs to be monitored for dropping
+ ExternalDropping.prototype.listenToExternalDrag = function (el, ev, ui) {
+ var _this = this;
+ var component = this.component;
+ var view = this.view;
+ var meta = getDraggedElMeta(el); // extra data about event drop, including possible event to create
+ var singleEventDef; // a null value signals an unsuccessful drag
+ // listener that tracks mouse movement over date-associated pixel regions
+ var dragListener = this.dragListener = new HitDragListener_1.default(component, {
+ interactionStart: function () {
+ _this.isDragging = true;
+ },
+ hitOver: function (hit) {
+ var isAllowed = true;
+ var hitFootprint = hit.component.getSafeHitFootprint(hit); // hit might not belong to this grid
+ var mutatedEventInstanceGroup;
+ if (hitFootprint) {
+ singleEventDef = _this.computeExternalDrop(hitFootprint, meta);
+ if (singleEventDef) {
+ mutatedEventInstanceGroup = new EventInstanceGroup_1.default(singleEventDef.buildInstances());
+ isAllowed = meta.eventProps ? // isEvent?
+ component.isEventInstanceGroupAllowed(mutatedEventInstanceGroup) :
+ component.isExternalInstanceGroupAllowed(mutatedEventInstanceGroup);
+ }
+ else {
+ isAllowed = false;
+ }
+ }
+ else {
+ isAllowed = false;
+ }
+ if (!isAllowed) {
+ singleEventDef = null;
+ util_1.disableCursor();
+ }
+ if (singleEventDef) {
+ component.renderDrag(// called without a seg parameter
+ component.eventRangesToEventFootprints(mutatedEventInstanceGroup.sliceRenderRanges(component.dateProfile.renderUnzonedRange, view.calendar)));
+ }
+ },
+ hitOut: function () {
+ singleEventDef = null; // signal unsuccessful
+ },
+ hitDone: function () {
+ util_1.enableCursor();
+ component.unrenderDrag();
+ },
+ interactionEnd: function (ev) {
+ if (singleEventDef) {
+ view.reportExternalDrop(singleEventDef, Boolean(meta.eventProps), // isEvent
+ Boolean(meta.stick), // isSticky
+ el, ev, ui);
+ }
+ _this.isDragging = false;
+ _this.dragListener = null;
+ }
+ });
+ dragListener.startDrag(ev); // start listening immediately
+ };
+ // Given a hit to be dropped upon, and misc data associated with the jqui drag (guaranteed to be a plain object),
+ // returns the zoned start/end dates for the event that would result from the hypothetical drop. end might be null.
+ // Returning a null value signals an invalid drop hit.
+ // DOES NOT consider overlap/constraint.
+ // Assumes both footprints are non-open-ended.
+ ExternalDropping.prototype.computeExternalDrop = function (componentFootprint, meta) {
+ var calendar = this.view.calendar;
+ var start = moment_ext_1.default.utc(componentFootprint.unzonedRange.startMs).stripZone();
+ var end;
+ var eventDef;
+ if (componentFootprint.isAllDay) {
+ // if dropped on an all-day span, and element's metadata specified a time, set it
+ if (meta.startTime) {
+ start.time(meta.startTime);
+ }
+ else {
+ start.stripTime();
+ }
+ }
+ if (meta.duration) {
+ end = start.clone().add(meta.duration);
+ }
+ start = calendar.applyTimezone(start);
+ if (end) {
+ end = calendar.applyTimezone(end);
+ }
+ eventDef = SingleEventDef_1.default.parse($.extend({}, meta.eventProps, {
+ start: start,
+ end: end
+ }), new EventSource_1.default(calendar));
+ return eventDef;
+ };
+ return ExternalDropping;
+}(Interaction_1.default));
+exports.default = ExternalDropping;
+ListenerMixin_1.default.mixInto(ExternalDropping);
+/* External-Dragging-Element Data
+----------------------------------------------------------------------------------------------------------------------*/
+// Require all HTML5 data-* attributes used by FullCalendar to have this prefix.
+// A value of '' will query attributes like data-event. A value of 'fc' will query attributes like data-fc-event.
+exportHooks.dataAttrPrefix = '';
+// Given a jQuery element that might represent a dragged FullCalendar event, returns an intermediate data structure
+// to be used for Event Object creation.
+// A defined `.eventProps`, even when empty, indicates that an event should be created.
+function getDraggedElMeta(el) {
+ var prefix = exportHooks.dataAttrPrefix;
+ var eventProps; // properties for creating the event, not related to date/time
+ var startTime; // a Duration
+ var duration;
+ var stick;
+ if (prefix) {
+ prefix += '-';
+ }
+ eventProps = el.data(prefix + 'event') || null;
+ if (eventProps) {
+ if (typeof eventProps === 'object') {
+ eventProps = $.extend({}, eventProps); // make a copy
+ }
+ else {
+ eventProps = {};
+ }
+ // pluck special-cased date/time properties
+ startTime = eventProps.start;
+ if (startTime == null) {
+ startTime = eventProps.time;
+ } // accept 'time' as well
+ duration = eventProps.duration;
+ stick = eventProps.stick;
+ delete eventProps.start;
+ delete eventProps.time;
+ delete eventProps.duration;
+ delete eventProps.stick;
+ }
+ // fallback to standalone attribute values for each of the date/time properties
+ if (startTime == null) {
+ startTime = el.data(prefix + 'start');
+ }
+ if (startTime == null) {
+ startTime = el.data(prefix + 'time');
+ } // accept 'time' as well
+ if (duration == null) {
+ duration = el.data(prefix + 'duration');
+ }
+ if (stick == null) {
+ stick = el.data(prefix + 'stick');
+ }
+ // massage into correct data types
+ startTime = startTime != null ? moment.duration(startTime) : null;
+ duration = duration != null ? moment.duration(duration) : null;
+ stick = Boolean(stick);
+ return { eventProps: eventProps, startTime: startTime, duration: duration, stick: stick };
+}
+
+
+/***/ }),
+/* 223 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var util_1 = __webpack_require__(4);
+var EventDefMutation_1 = __webpack_require__(37);
+var EventDefDateMutation_1 = __webpack_require__(50);
+var HitDragListener_1 = __webpack_require__(23);
+var Interaction_1 = __webpack_require__(15);
+var EventResizing = /** @class */ (function (_super) {
+ tslib_1.__extends(EventResizing, _super);
+ /*
+ component impements:
+ - bindSegHandlerToEl
+ - publiclyTrigger
+ - diffDates
+ - eventRangesToEventFootprints
+ - isEventInstanceGroupAllowed
+ - getSafeHitFootprint
+ */
+ function EventResizing(component, eventPointing) {
+ var _this = _super.call(this, component) || this;
+ _this.isResizing = false;
+ _this.eventPointing = eventPointing;
+ return _this;
+ }
+ EventResizing.prototype.end = function () {
+ if (this.dragListener) {
+ this.dragListener.endInteraction();
+ }
+ };
+ EventResizing.prototype.bindToEl = function (el) {
+ var component = this.component;
+ component.bindSegHandlerToEl(el, 'mousedown', this.handleMouseDown.bind(this));
+ component.bindSegHandlerToEl(el, 'touchstart', this.handleTouchStart.bind(this));
+ };
+ EventResizing.prototype.handleMouseDown = function (seg, ev) {
+ if (this.component.canStartResize(seg, ev)) {
+ this.buildDragListener(seg, $(ev.target).is('.fc-start-resizer'))
+ .startInteraction(ev, { distance: 5 });
+ }
+ };
+ EventResizing.prototype.handleTouchStart = function (seg, ev) {
+ if (this.component.canStartResize(seg, ev)) {
+ this.buildDragListener(seg, $(ev.target).is('.fc-start-resizer'))
+ .startInteraction(ev);
+ }
+ };
+ // Creates a listener that tracks the user as they resize an event segment.
+ // Generic enough to work with any type of Grid.
+ EventResizing.prototype.buildDragListener = function (seg, isStart) {
+ var _this = this;
+ var component = this.component;
+ var view = this.view;
+ var calendar = view.calendar;
+ var eventManager = calendar.eventManager;
+ var el = seg.el;
+ var eventDef = seg.footprint.eventDef;
+ var eventInstance = seg.footprint.eventInstance;
+ var isDragging;
+ var resizeMutation; // zoned event date properties. falsy if invalid resize
+ // Tracks mouse movement over the *grid's* coordinate map
+ var dragListener = this.dragListener = new HitDragListener_1.default(component, {
+ scroll: this.opt('dragScroll'),
+ subjectEl: el,
+ interactionStart: function () {
+ isDragging = false;
+ },
+ dragStart: function (ev) {
+ isDragging = true;
+ // ensure a mouseout on the manipulated event has been reported
+ _this.eventPointing.handleMouseout(seg, ev);
+ _this.segResizeStart(seg, ev);
+ },
+ hitOver: function (hit, isOrig, origHit) {
+ var isAllowed = true;
+ var origHitFootprint = component.getSafeHitFootprint(origHit);
+ var hitFootprint = component.getSafeHitFootprint(hit);
+ var mutatedEventInstanceGroup;
+ if (origHitFootprint && hitFootprint) {
+ resizeMutation = isStart ?
+ _this.computeEventStartResizeMutation(origHitFootprint, hitFootprint, seg.footprint) :
+ _this.computeEventEndResizeMutation(origHitFootprint, hitFootprint, seg.footprint);
+ if (resizeMutation) {
+ mutatedEventInstanceGroup = eventManager.buildMutatedEventInstanceGroup(eventDef.id, resizeMutation);
+ isAllowed = component.isEventInstanceGroupAllowed(mutatedEventInstanceGroup);
+ }
+ else {
+ isAllowed = false;
+ }
+ }
+ else {
+ isAllowed = false;
+ }
+ if (!isAllowed) {
+ resizeMutation = null;
+ util_1.disableCursor();
+ }
+ else if (resizeMutation.isEmpty()) {
+ // no change. (FYI, event dates might have zones)
+ resizeMutation = null;
+ }
+ if (resizeMutation) {
+ view.hideEventsWithId(seg.footprint.eventDef.id);
+ view.renderEventResize(component.eventRangesToEventFootprints(mutatedEventInstanceGroup.sliceRenderRanges(component.dateProfile.renderUnzonedRange, calendar)), seg);
+ }
+ },
+ hitOut: function () {
+ resizeMutation = null;
+ },
+ hitDone: function () {
+ view.unrenderEventResize(seg);
+ view.showEventsWithId(seg.footprint.eventDef.id);
+ util_1.enableCursor();
+ },
+ interactionEnd: function (ev) {
+ if (isDragging) {
+ _this.segResizeStop(seg, ev);
+ }
+ if (resizeMutation) {
+ // no need to re-show original, will rerender all anyways. esp important if eventRenderWait
+ view.reportEventResize(eventInstance, resizeMutation, el, ev);
+ }
+ _this.dragListener = null;
+ }
+ });
+ return dragListener;
+ };
+ // Called before event segment resizing starts
+ EventResizing.prototype.segResizeStart = function (seg, ev) {
+ this.isResizing = true;
+ this.component.publiclyTrigger('eventResizeStart', {
+ context: seg.el[0],
+ args: [
+ seg.footprint.getEventLegacy(),
+ ev,
+ {},
+ this.view
+ ]
+ });
+ };
+ // Called after event segment resizing stops
+ EventResizing.prototype.segResizeStop = function (seg, ev) {
+ this.isResizing = false;
+ this.component.publiclyTrigger('eventResizeStop', {
+ context: seg.el[0],
+ args: [
+ seg.footprint.getEventLegacy(),
+ ev,
+ {},
+ this.view
+ ]
+ });
+ };
+ // Returns new date-information for an event segment being resized from its start
+ EventResizing.prototype.computeEventStartResizeMutation = function (startFootprint, endFootprint, origEventFootprint) {
+ var origRange = origEventFootprint.componentFootprint.unzonedRange;
+ var startDelta = this.component.diffDates(endFootprint.unzonedRange.getStart(), startFootprint.unzonedRange.getStart());
+ var dateMutation;
+ var eventDefMutation;
+ if (origRange.getStart().add(startDelta) < origRange.getEnd()) {
+ dateMutation = new EventDefDateMutation_1.default();
+ dateMutation.setStartDelta(startDelta);
+ eventDefMutation = new EventDefMutation_1.default();
+ eventDefMutation.setDateMutation(dateMutation);
+ return eventDefMutation;
+ }
+ return false;
+ };
+ // Returns new date-information for an event segment being resized from its end
+ EventResizing.prototype.computeEventEndResizeMutation = function (startFootprint, endFootprint, origEventFootprint) {
+ var origRange = origEventFootprint.componentFootprint.unzonedRange;
+ var endDelta = this.component.diffDates(endFootprint.unzonedRange.getEnd(), startFootprint.unzonedRange.getEnd());
+ var dateMutation;
+ var eventDefMutation;
+ if (origRange.getEnd().add(endDelta) > origRange.getStart()) {
+ dateMutation = new EventDefDateMutation_1.default();
+ dateMutation.setEndDelta(endDelta);
+ eventDefMutation = new EventDefMutation_1.default();
+ eventDefMutation.setDateMutation(dateMutation);
+ return eventDefMutation;
+ }
+ return false;
+ };
+ return EventResizing;
+}(Interaction_1.default));
+exports.default = EventResizing;
+
+
+/***/ }),
+/* 224 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var util_1 = __webpack_require__(4);
+var EventDefMutation_1 = __webpack_require__(37);
+var EventDefDateMutation_1 = __webpack_require__(50);
+var DragListener_1 = __webpack_require__(54);
+var HitDragListener_1 = __webpack_require__(23);
+var MouseFollower_1 = __webpack_require__(244);
+var Interaction_1 = __webpack_require__(15);
+var EventDragging = /** @class */ (function (_super) {
+ tslib_1.__extends(EventDragging, _super);
+ /*
+ component implements:
+ - bindSegHandlerToEl
+ - publiclyTrigger
+ - diffDates
+ - eventRangesToEventFootprints
+ - isEventInstanceGroupAllowed
+ */
+ function EventDragging(component, eventPointing) {
+ var _this = _super.call(this, component) || this;
+ _this.isDragging = false;
+ _this.eventPointing = eventPointing;
+ return _this;
+ }
+ EventDragging.prototype.end = function () {
+ if (this.dragListener) {
+ this.dragListener.endInteraction();
+ }
+ };
+ EventDragging.prototype.getSelectionDelay = function () {
+ var delay = this.opt('eventLongPressDelay');
+ if (delay == null) {
+ delay = this.opt('longPressDelay'); // fallback
+ }
+ return delay;
+ };
+ EventDragging.prototype.bindToEl = function (el) {
+ var component = this.component;
+ component.bindSegHandlerToEl(el, 'mousedown', this.handleMousedown.bind(this));
+ component.bindSegHandlerToEl(el, 'touchstart', this.handleTouchStart.bind(this));
+ };
+ EventDragging.prototype.handleMousedown = function (seg, ev) {
+ if (!this.component.shouldIgnoreMouse() &&
+ this.component.canStartDrag(seg, ev)) {
+ this.buildDragListener(seg).startInteraction(ev, { distance: 5 });
+ }
+ };
+ EventDragging.prototype.handleTouchStart = function (seg, ev) {
+ var component = this.component;
+ var settings = {
+ delay: this.view.isEventDefSelected(seg.footprint.eventDef) ? // already selected?
+ 0 : this.getSelectionDelay()
+ };
+ if (component.canStartDrag(seg, ev)) {
+ this.buildDragListener(seg).startInteraction(ev, settings);
+ }
+ else if (component.canStartSelection(seg, ev)) {
+ this.buildSelectListener(seg).startInteraction(ev, settings);
+ }
+ };
+ // seg isn't draggable, but let's use a generic DragListener
+ // simply for the delay, so it can be selected.
+ // Has side effect of setting/unsetting `dragListener`
+ EventDragging.prototype.buildSelectListener = function (seg) {
+ var _this = this;
+ var view = this.view;
+ var eventDef = seg.footprint.eventDef;
+ var eventInstance = seg.footprint.eventInstance; // null for inverse-background events
+ if (this.dragListener) {
+ return this.dragListener;
+ }
+ var dragListener = this.dragListener = new DragListener_1.default({
+ dragStart: function (ev) {
+ if (dragListener.isTouch &&
+ !view.isEventDefSelected(eventDef) &&
+ eventInstance) {
+ // if not previously selected, will fire after a delay. then, select the event
+ view.selectEventInstance(eventInstance);
+ }
+ },
+ interactionEnd: function (ev) {
+ _this.dragListener = null;
+ }
+ });
+ return dragListener;
+ };
+ // Builds a listener that will track user-dragging on an event segment.
+ // Generic enough to work with any type of Grid.
+ // Has side effect of setting/unsetting `dragListener`
+ EventDragging.prototype.buildDragListener = function (seg) {
+ var _this = this;
+ var component = this.component;
+ var view = this.view;
+ var calendar = view.calendar;
+ var eventManager = calendar.eventManager;
+ var el = seg.el;
+ var eventDef = seg.footprint.eventDef;
+ var eventInstance = seg.footprint.eventInstance; // null for inverse-background events
+ var isDragging;
+ var mouseFollower; // A clone of the original element that will move with the mouse
+ var eventDefMutation;
+ if (this.dragListener) {
+ return this.dragListener;
+ }
+ // Tracks mouse movement over the *view's* coordinate map. Allows dragging and dropping between subcomponents
+ // of the view.
+ var dragListener = this.dragListener = new HitDragListener_1.default(view, {
+ scroll: this.opt('dragScroll'),
+ subjectEl: el,
+ subjectCenter: true,
+ interactionStart: function (ev) {
+ seg.component = component; // for renderDrag
+ isDragging = false;
+ mouseFollower = new MouseFollower_1.default(seg.el, {
+ additionalClass: 'fc-dragging',
+ parentEl: view.el,
+ opacity: dragListener.isTouch ? null : _this.opt('dragOpacity'),
+ revertDuration: _this.opt('dragRevertDuration'),
+ zIndex: 2 // one above the .fc-view
+ });
+ mouseFollower.hide(); // don't show until we know this is a real drag
+ mouseFollower.start(ev);
+ },
+ dragStart: function (ev) {
+ if (dragListener.isTouch &&
+ !view.isEventDefSelected(eventDef) &&
+ eventInstance) {
+ // if not previously selected, will fire after a delay. then, select the event
+ view.selectEventInstance(eventInstance);
+ }
+ isDragging = true;
+ // ensure a mouseout on the manipulated event has been reported
+ _this.eventPointing.handleMouseout(seg, ev);
+ _this.segDragStart(seg, ev);
+ view.hideEventsWithId(seg.footprint.eventDef.id);
+ },
+ hitOver: function (hit, isOrig, origHit) {
+ var isAllowed = true;
+ var origFootprint;
+ var footprint;
+ var mutatedEventInstanceGroup;
+ // starting hit could be forced (DayGrid.limit)
+ if (seg.hit) {
+ origHit = seg.hit;
+ }
+ // hit might not belong to this grid, so query origin grid
+ origFootprint = origHit.component.getSafeHitFootprint(origHit);
+ footprint = hit.component.getSafeHitFootprint(hit);
+ if (origFootprint && footprint) {
+ eventDefMutation = _this.computeEventDropMutation(origFootprint, footprint, eventDef);
+ if (eventDefMutation) {
+ mutatedEventInstanceGroup = eventManager.buildMutatedEventInstanceGroup(eventDef.id, eventDefMutation);
+ isAllowed = component.isEventInstanceGroupAllowed(mutatedEventInstanceGroup);
+ }
+ else {
+ isAllowed = false;
+ }
+ }
+ else {
+ isAllowed = false;
+ }
+ if (!isAllowed) {
+ eventDefMutation = null;
+ util_1.disableCursor();
+ }
+ // if a valid drop location, have the subclass render a visual indication
+ if (eventDefMutation &&
+ view.renderDrag(// truthy if rendered something
+ component.eventRangesToEventFootprints(mutatedEventInstanceGroup.sliceRenderRanges(component.dateProfile.renderUnzonedRange, calendar)), seg, dragListener.isTouch)) {
+ mouseFollower.hide(); // if the subclass is already using a mock event "helper", hide our own
+ }
+ else {
+ mouseFollower.show(); // otherwise, have the helper follow the mouse (no snapping)
+ }
+ if (isOrig) {
+ // needs to have moved hits to be a valid drop
+ eventDefMutation = null;
+ }
+ },
+ hitOut: function () {
+ view.unrenderDrag(seg); // unrender whatever was done in renderDrag
+ mouseFollower.show(); // show in case we are moving out of all hits
+ eventDefMutation = null;
+ },
+ hitDone: function () {
+ util_1.enableCursor();
+ },
+ interactionEnd: function (ev) {
+ delete seg.component; // prevent side effects
+ // do revert animation if hasn't changed. calls a callback when finished (whether animation or not)
+ mouseFollower.stop(!eventDefMutation, function () {
+ if (isDragging) {
+ view.unrenderDrag(seg);
+ _this.segDragStop(seg, ev);
+ }
+ view.showEventsWithId(seg.footprint.eventDef.id);
+ if (eventDefMutation) {
+ // no need to re-show original, will rerender all anyways. esp important if eventRenderWait
+ view.reportEventDrop(eventInstance, eventDefMutation, el, ev);
+ }
+ });
+ _this.dragListener = null;
+ }
+ });
+ return dragListener;
+ };
+ // Called before event segment dragging starts
+ EventDragging.prototype.segDragStart = function (seg, ev) {
+ this.isDragging = true;
+ this.component.publiclyTrigger('eventDragStart', {
+ context: seg.el[0],
+ args: [
+ seg.footprint.getEventLegacy(),
+ ev,
+ {},
+ this.view
+ ]
+ });
+ };
+ // Called after event segment dragging stops
+ EventDragging.prototype.segDragStop = function (seg, ev) {
+ this.isDragging = false;
+ this.component.publiclyTrigger('eventDragStop', {
+ context: seg.el[0],
+ args: [
+ seg.footprint.getEventLegacy(),
+ ev,
+ {},
+ this.view
+ ]
+ });
+ };
+ // DOES NOT consider overlap/constraint
+ EventDragging.prototype.computeEventDropMutation = function (startFootprint, endFootprint, eventDef) {
+ var eventDefMutation = new EventDefMutation_1.default();
+ eventDefMutation.setDateMutation(this.computeEventDateMutation(startFootprint, endFootprint));
+ return eventDefMutation;
+ };
+ EventDragging.prototype.computeEventDateMutation = function (startFootprint, endFootprint) {
+ var date0 = startFootprint.unzonedRange.getStart();
+ var date1 = endFootprint.unzonedRange.getStart();
+ var clearEnd = false;
+ var forceTimed = false;
+ var forceAllDay = false;
+ var dateDelta;
+ var dateMutation;
+ if (startFootprint.isAllDay !== endFootprint.isAllDay) {
+ clearEnd = true;
+ if (endFootprint.isAllDay) {
+ forceAllDay = true;
+ date0.stripTime();
+ }
+ else {
+ forceTimed = true;
+ }
+ }
+ dateDelta = this.component.diffDates(date1, date0);
+ dateMutation = new EventDefDateMutation_1.default();
+ dateMutation.clearEnd = clearEnd;
+ dateMutation.forceTimed = forceTimed;
+ dateMutation.forceAllDay = forceAllDay;
+ dateMutation.setDateDelta(dateDelta);
+ return dateMutation;
+ };
+ return EventDragging;
+}(Interaction_1.default));
+exports.default = EventDragging;
+
+
+/***/ }),
+/* 225 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var util_1 = __webpack_require__(4);
+var HitDragListener_1 = __webpack_require__(23);
+var ComponentFootprint_1 = __webpack_require__(12);
+var UnzonedRange_1 = __webpack_require__(5);
+var Interaction_1 = __webpack_require__(15);
+var DateSelecting = /** @class */ (function (_super) {
+ tslib_1.__extends(DateSelecting, _super);
+ /*
+ component must implement:
+ - bindDateHandlerToEl
+ - getSafeHitFootprint
+ - renderHighlight
+ - unrenderHighlight
+ */
+ function DateSelecting(component) {
+ var _this = _super.call(this, component) || this;
+ _this.dragListener = _this.buildDragListener();
+ return _this;
+ }
+ DateSelecting.prototype.end = function () {
+ this.dragListener.endInteraction();
+ };
+ DateSelecting.prototype.getDelay = function () {
+ var delay = this.opt('selectLongPressDelay');
+ if (delay == null) {
+ delay = this.opt('longPressDelay'); // fallback
+ }
+ return delay;
+ };
+ DateSelecting.prototype.bindToEl = function (el) {
+ var _this = this;
+ var component = this.component;
+ var dragListener = this.dragListener;
+ component.bindDateHandlerToEl(el, 'mousedown', function (ev) {
+ if (_this.opt('selectable') && !component.shouldIgnoreMouse()) {
+ dragListener.startInteraction(ev, {
+ distance: _this.opt('selectMinDistance')
+ });
+ }
+ });
+ component.bindDateHandlerToEl(el, 'touchstart', function (ev) {
+ if (_this.opt('selectable') && !component.shouldIgnoreTouch()) {
+ dragListener.startInteraction(ev, {
+ delay: _this.getDelay()
+ });
+ }
+ });
+ util_1.preventSelection(el);
+ };
+ // Creates a listener that tracks the user's drag across day elements, for day selecting.
+ DateSelecting.prototype.buildDragListener = function () {
+ var _this = this;
+ var component = this.component;
+ var selectionFootprint; // null if invalid selection
+ var dragListener = new HitDragListener_1.default(component, {
+ scroll: this.opt('dragScroll'),
+ interactionStart: function () {
+ selectionFootprint = null;
+ },
+ dragStart: function (ev) {
+ _this.view.unselect(ev); // since we could be rendering a new selection, we want to clear any old one
+ },
+ hitOver: function (hit, isOrig, origHit) {
+ var origHitFootprint;
+ var hitFootprint;
+ if (origHit) {
+ origHitFootprint = component.getSafeHitFootprint(origHit);
+ hitFootprint = component.getSafeHitFootprint(hit);
+ if (origHitFootprint && hitFootprint) {
+ selectionFootprint = _this.computeSelection(origHitFootprint, hitFootprint);
+ }
+ else {
+ selectionFootprint = null;
+ }
+ if (selectionFootprint) {
+ component.renderSelectionFootprint(selectionFootprint);
+ }
+ else if (selectionFootprint === false) {
+ util_1.disableCursor();
+ }
+ }
+ },
+ hitOut: function () {
+ selectionFootprint = null;
+ component.unrenderSelection();
+ },
+ hitDone: function () {
+ util_1.enableCursor();
+ },
+ interactionEnd: function (ev, isCancelled) {
+ if (!isCancelled && selectionFootprint) {
+ // the selection will already have been rendered. just report it
+ _this.view.reportSelection(selectionFootprint, ev);
+ }
+ }
+ });
+ return dragListener;
+ };
+ // Given the first and last date-spans of a selection, returns another date-span object.
+ // Subclasses can override and provide additional data in the span object. Will be passed to renderSelectionFootprint().
+ // Will return false if the selection is invalid and this should be indicated to the user.
+ // Will return null/undefined if a selection invalid but no error should be reported.
+ DateSelecting.prototype.computeSelection = function (footprint0, footprint1) {
+ var wholeFootprint = this.computeSelectionFootprint(footprint0, footprint1);
+ if (wholeFootprint && !this.isSelectionFootprintAllowed(wholeFootprint)) {
+ return false;
+ }
+ return wholeFootprint;
+ };
+ // Given two spans, must return the combination of the two.
+ // TODO: do this separation of concerns (combining VS validation) for event dnd/resize too.
+ // Assumes both footprints are non-open-ended.
+ DateSelecting.prototype.computeSelectionFootprint = function (footprint0, footprint1) {
+ var ms = [
+ footprint0.unzonedRange.startMs,
+ footprint0.unzonedRange.endMs,
+ footprint1.unzonedRange.startMs,
+ footprint1.unzonedRange.endMs
+ ];
+ ms.sort(util_1.compareNumbers);
+ return new ComponentFootprint_1.default(new UnzonedRange_1.default(ms[0], ms[3]), footprint0.isAllDay);
+ };
+ DateSelecting.prototype.isSelectionFootprintAllowed = function (componentFootprint) {
+ return this.component.dateProfile.validUnzonedRange.containsRange(componentFootprint.unzonedRange) &&
+ this.view.calendar.constraints.isSelectionFootprintAllowed(componentFootprint);
+ };
+ return DateSelecting;
+}(Interaction_1.default));
+exports.default = DateSelecting;
+
+
+/***/ }),
+/* 226 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var moment = __webpack_require__(0);
+var $ = __webpack_require__(3);
+var util_1 = __webpack_require__(4);
+var Scroller_1 = __webpack_require__(39);
+var View_1 = __webpack_require__(41);
+var TimeGrid_1 = __webpack_require__(227);
+var DayGrid_1 = __webpack_require__(61);
+var AGENDA_ALL_DAY_EVENT_LIMIT = 5;
+var agendaTimeGridMethods;
+var agendaDayGridMethods;
+/* An abstract class for all agenda-related views. Displays one more columns with time slots running vertically.
+----------------------------------------------------------------------------------------------------------------------*/
+// Is a manager for the TimeGrid subcomponent and possibly the DayGrid subcomponent (if allDaySlot is on).
+// Responsible for managing width/height.
+var AgendaView = /** @class */ (function (_super) {
+ tslib_1.__extends(AgendaView, _super);
+ function AgendaView(calendar, viewSpec) {
+ var _this = _super.call(this, calendar, viewSpec) || this;
+ _this.usesMinMaxTime = true; // indicates that minTime/maxTime affects rendering
+ _this.timeGrid = _this.instantiateTimeGrid();
+ _this.addChild(_this.timeGrid);
+ if (_this.opt('allDaySlot')) {
+ _this.dayGrid = _this.instantiateDayGrid(); // the all-day subcomponent of this view
+ _this.addChild(_this.dayGrid);
+ }
+ _this.scroller = new Scroller_1.default({
+ overflowX: 'hidden',
+ overflowY: 'auto'
+ });
+ return _this;
+ }
+ // Instantiates the TimeGrid object this view needs. Draws from this.timeGridClass
+ AgendaView.prototype.instantiateTimeGrid = function () {
+ var timeGrid = new this.timeGridClass(this);
+ util_1.copyOwnProps(agendaTimeGridMethods, timeGrid);
+ return timeGrid;
+ };
+ // Instantiates the DayGrid object this view might need. Draws from this.dayGridClass
+ AgendaView.prototype.instantiateDayGrid = function () {
+ var dayGrid = new this.dayGridClass(this);
+ util_1.copyOwnProps(agendaDayGridMethods, dayGrid);
+ return dayGrid;
+ };
+ /* Rendering
+ ------------------------------------------------------------------------------------------------------------------*/
+ AgendaView.prototype.renderSkeleton = function () {
+ var timeGridWrapEl;
+ var timeGridEl;
+ this.el.addClass('fc-agenda-view').html(this.renderSkeletonHtml());
+ this.scroller.render();
+ timeGridWrapEl = this.scroller.el.addClass('fc-time-grid-container');
+ timeGridEl = $('').appendTo(timeGridWrapEl);
+ this.el.find('.fc-body > tr > td').append(timeGridWrapEl);
+ this.timeGrid.headContainerEl = this.el.find('.fc-head-container');
+ this.timeGrid.setElement(timeGridEl);
+ if (this.dayGrid) {
+ this.dayGrid.setElement(this.el.find('.fc-day-grid'));
+ // have the day-grid extend it's coordinate area over the
dividing the two grids
+ this.dayGrid.bottomCoordPadding = this.dayGrid.el.next('hr').outerHeight();
+ }
+ };
+ AgendaView.prototype.unrenderSkeleton = function () {
+ this.timeGrid.removeElement();
+ if (this.dayGrid) {
+ this.dayGrid.removeElement();
+ }
+ this.scroller.destroy();
+ };
+ // Builds the HTML skeleton for the view.
+ // The day-grid and time-grid components will render inside containers defined by this HTML.
+ AgendaView.prototype.renderSkeletonHtml = function () {
+ var theme = this.calendar.theme;
+ return '' +
+ '' +
+ (this.opt('columnHeader') ?
+ '' +
+ '' +
+ '' +
+ ' ' +
+ '' :
+ '') +
+ '' +
+ '' +
+ '| ' +
+ (this.dayGrid ?
+ '' +
+ '' :
+ '') +
+ ' | ' +
+ ' ' +
+ '' +
+ ' ';
+ };
+ // Generates an HTML attribute string for setting the width of the axis, if it is known
+ AgendaView.prototype.axisStyleAttr = function () {
+ if (this.axisWidth != null) {
+ return 'style="width:' + this.axisWidth + 'px"';
+ }
+ return '';
+ };
+ /* Now Indicator
+ ------------------------------------------------------------------------------------------------------------------*/
+ AgendaView.prototype.getNowIndicatorUnit = function () {
+ return this.timeGrid.getNowIndicatorUnit();
+ };
+ /* Dimensions
+ ------------------------------------------------------------------------------------------------------------------*/
+ // Adjusts the vertical dimensions of the view to the specified values
+ AgendaView.prototype.updateSize = function (totalHeight, isAuto, isResize) {
+ var eventLimit;
+ var scrollerHeight;
+ var scrollbarWidths;
+ _super.prototype.updateSize.call(this, totalHeight, isAuto, isResize);
+ // make all axis cells line up, and record the width so newly created axis cells will have it
+ this.axisWidth = util_1.matchCellWidths(this.el.find('.fc-axis'));
+ // hack to give the view some height prior to timeGrid's columns being rendered
+ // TODO: separate setting height from scroller VS timeGrid.
+ if (!this.timeGrid.colEls) {
+ if (!isAuto) {
+ scrollerHeight = this.computeScrollerHeight(totalHeight);
+ this.scroller.setHeight(scrollerHeight);
+ }
+ return;
+ }
+ // set of fake row elements that must compensate when scroller has scrollbars
+ var noScrollRowEls = this.el.find('.fc-row:not(.fc-scroller *)');
+ // reset all dimensions back to the original state
+ this.timeGrid.bottomRuleEl.hide(); // .show() will be called later if this
is necessary
+ this.scroller.clear(); // sets height to 'auto' and clears overflow
+ util_1.uncompensateScroll(noScrollRowEls);
+ // limit number of events in the all-day area
+ if (this.dayGrid) {
+ this.dayGrid.removeSegPopover(); // kill the "more" popover if displayed
+ eventLimit = this.opt('eventLimit');
+ if (eventLimit && typeof eventLimit !== 'number') {
+ eventLimit = AGENDA_ALL_DAY_EVENT_LIMIT; // make sure "auto" goes to a real number
+ }
+ if (eventLimit) {
+ this.dayGrid.limitRows(eventLimit);
+ }
+ }
+ if (!isAuto) {
+ scrollerHeight = this.computeScrollerHeight(totalHeight);
+ this.scroller.setHeight(scrollerHeight);
+ scrollbarWidths = this.scroller.getScrollbarWidths();
+ if (scrollbarWidths.left || scrollbarWidths.right) {
+ // make the all-day and header rows lines up
+ util_1.compensateScroll(noScrollRowEls, scrollbarWidths);
+ // the scrollbar compensation might have changed text flow, which might affect height, so recalculate
+ // and reapply the desired height to the scroller.
+ scrollerHeight = this.computeScrollerHeight(totalHeight);
+ this.scroller.setHeight(scrollerHeight);
+ }
+ // guarantees the same scrollbar widths
+ this.scroller.lockOverflow(scrollbarWidths);
+ // if there's any space below the slats, show the horizontal rule.
+ // this won't cause any new overflow, because lockOverflow already called.
+ if (this.timeGrid.getTotalSlatHeight() < scrollerHeight) {
+ this.timeGrid.bottomRuleEl.show();
+ }
+ }
+ };
+ // given a desired total height of the view, returns what the height of the scroller should be
+ AgendaView.prototype.computeScrollerHeight = function (totalHeight) {
+ return totalHeight -
+ util_1.subtractInnerElHeight(this.el, this.scroller.el); // everything that's NOT the scroller
+ };
+ /* Scroll
+ ------------------------------------------------------------------------------------------------------------------*/
+ // Computes the initial pre-configured scroll state prior to allowing the user to change it
+ AgendaView.prototype.computeInitialDateScroll = function () {
+ var scrollTime = moment.duration(this.opt('scrollTime'));
+ var top = this.timeGrid.computeTimeTop(scrollTime);
+ // zoom can give weird floating-point values. rather scroll a little bit further
+ top = Math.ceil(top);
+ if (top) {
+ top++; // to overcome top border that slots beyond the first have. looks better
+ }
+ return { top: top };
+ };
+ AgendaView.prototype.queryDateScroll = function () {
+ return { top: this.scroller.getScrollTop() };
+ };
+ AgendaView.prototype.applyDateScroll = function (scroll) {
+ if (scroll.top !== undefined) {
+ this.scroller.setScrollTop(scroll.top);
+ }
+ };
+ /* Hit Areas
+ ------------------------------------------------------------------------------------------------------------------*/
+ // forward all hit-related method calls to the grids (dayGrid might not be defined)
+ AgendaView.prototype.getHitFootprint = function (hit) {
+ // TODO: hit.component is set as a hack to identify where the hit came from
+ return hit.component.getHitFootprint(hit);
+ };
+ AgendaView.prototype.getHitEl = function (hit) {
+ // TODO: hit.component is set as a hack to identify where the hit came from
+ return hit.component.getHitEl(hit);
+ };
+ /* Event Rendering
+ ------------------------------------------------------------------------------------------------------------------*/
+ AgendaView.prototype.executeEventRender = function (eventsPayload) {
+ var dayEventsPayload = {};
+ var timedEventsPayload = {};
+ var id;
+ var eventInstanceGroup;
+ // separate the events into all-day and timed
+ for (id in eventsPayload) {
+ eventInstanceGroup = eventsPayload[id];
+ if (eventInstanceGroup.getEventDef().isAllDay()) {
+ dayEventsPayload[id] = eventInstanceGroup;
+ }
+ else {
+ timedEventsPayload[id] = eventInstanceGroup;
+ }
+ }
+ this.timeGrid.executeEventRender(timedEventsPayload);
+ if (this.dayGrid) {
+ this.dayGrid.executeEventRender(dayEventsPayload);
+ }
+ };
+ /* Dragging/Resizing Routing
+ ------------------------------------------------------------------------------------------------------------------*/
+ // A returned value of `true` signals that a mock "helper" event has been rendered.
+ AgendaView.prototype.renderDrag = function (eventFootprints, seg, isTouch) {
+ var groups = groupEventFootprintsByAllDay(eventFootprints);
+ var renderedHelper = false;
+ renderedHelper = this.timeGrid.renderDrag(groups.timed, seg, isTouch);
+ if (this.dayGrid) {
+ renderedHelper = this.dayGrid.renderDrag(groups.allDay, seg, isTouch) || renderedHelper;
+ }
+ return renderedHelper;
+ };
+ AgendaView.prototype.renderEventResize = function (eventFootprints, seg, isTouch) {
+ var groups = groupEventFootprintsByAllDay(eventFootprints);
+ this.timeGrid.renderEventResize(groups.timed, seg, isTouch);
+ if (this.dayGrid) {
+ this.dayGrid.renderEventResize(groups.allDay, seg, isTouch);
+ }
+ };
+ /* Selection
+ ------------------------------------------------------------------------------------------------------------------*/
+ // Renders a visual indication of a selection
+ AgendaView.prototype.renderSelectionFootprint = function (componentFootprint) {
+ if (!componentFootprint.isAllDay) {
+ this.timeGrid.renderSelectionFootprint(componentFootprint);
+ }
+ else if (this.dayGrid) {
+ this.dayGrid.renderSelectionFootprint(componentFootprint);
+ }
+ };
+ return AgendaView;
+}(View_1.default));
+exports.default = AgendaView;
+AgendaView.prototype.timeGridClass = TimeGrid_1.default;
+AgendaView.prototype.dayGridClass = DayGrid_1.default;
+// Will customize the rendering behavior of the AgendaView's timeGrid
+agendaTimeGridMethods = {
+ // Generates the HTML that will go before the day-of week header cells
+ renderHeadIntroHtml: function () {
+ var view = this.view;
+ var calendar = view.calendar;
+ var weekStart = calendar.msToUtcMoment(this.dateProfile.renderUnzonedRange.startMs, true);
+ var weekText;
+ if (this.opt('weekNumbers')) {
+ weekText = weekStart.format(this.opt('smallWeekFormat'));
+ return '' +
+ '';
+ }
+ else {
+ return '';
+ }
+ },
+ // Generates the HTML that goes before the bg of the TimeGrid slot area. Long vertical column.
+ renderBgIntroHtml: function () {
+ var view = this.view;
+ return ' | ';
+ },
+ // Generates the HTML that goes before all other types of cells.
+ // Affects content-skeleton, helper-skeleton, highlight-skeleton for both the time-grid and day-grid.
+ renderIntroHtml: function () {
+ var view = this.view;
+ return ' | ';
+ }
+};
+// Will customize the rendering behavior of the AgendaView's dayGrid
+agendaDayGridMethods = {
+ // Generates the HTML that goes before the all-day cells
+ renderBgIntroHtml: function () {
+ var view = this.view;
+ return '' +
+ '' +
+ '' + // needed for matchCellWidths
+ view.getAllDayHtml() +
+ '' +
+ ' | ';
+ },
+ // Generates the HTML that goes before all other types of cells.
+ // Affects content-skeleton, helper-skeleton, highlight-skeleton for both the time-grid and day-grid.
+ renderIntroHtml: function () {
+ var view = this.view;
+ return ' | ';
+ }
+};
+function groupEventFootprintsByAllDay(eventFootprints) {
+ var allDay = [];
+ var timed = [];
+ var i;
+ for (i = 0; i < eventFootprints.length; i++) {
+ if (eventFootprints[i].componentFootprint.isAllDay) {
+ allDay.push(eventFootprints[i]);
+ }
+ else {
+ timed.push(eventFootprints[i]);
+ }
+ }
+ return { allDay: allDay, timed: timed };
+}
+
+
+/***/ }),
+/* 227 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var moment = __webpack_require__(0);
+var util_1 = __webpack_require__(4);
+var InteractiveDateComponent_1 = __webpack_require__(40);
+var BusinessHourRenderer_1 = __webpack_require__(56);
+var StandardInteractionsMixin_1 = __webpack_require__(60);
+var DayTableMixin_1 = __webpack_require__(55);
+var CoordCache_1 = __webpack_require__(53);
+var UnzonedRange_1 = __webpack_require__(5);
+var ComponentFootprint_1 = __webpack_require__(12);
+var TimeGridEventRenderer_1 = __webpack_require__(246);
+var TimeGridHelperRenderer_1 = __webpack_require__(247);
+var TimeGridFillRenderer_1 = __webpack_require__(248);
+/* A component that renders one or more columns of vertical time slots
+----------------------------------------------------------------------------------------------------------------------*/
+// We mixin DayTable, even though there is only a single row of days
+// potential nice values for the slot-duration and interval-duration
+// from largest to smallest
+var AGENDA_STOCK_SUB_DURATIONS = [
+ { hours: 1 },
+ { minutes: 30 },
+ { minutes: 15 },
+ { seconds: 30 },
+ { seconds: 15 }
+];
+var TimeGrid = /** @class */ (function (_super) {
+ tslib_1.__extends(TimeGrid, _super);
+ function TimeGrid(view) {
+ var _this = _super.call(this, view) || this;
+ _this.processOptions();
+ return _this;
+ }
+ // Slices up the given span (unzoned start/end with other misc data) into an array of segments
+ TimeGrid.prototype.componentFootprintToSegs = function (componentFootprint) {
+ var segs = this.sliceRangeByTimes(componentFootprint.unzonedRange);
+ var i;
+ for (i = 0; i < segs.length; i++) {
+ if (this.isRTL) {
+ segs[i].col = this.daysPerRow - 1 - segs[i].dayIndex;
+ }
+ else {
+ segs[i].col = segs[i].dayIndex;
+ }
+ }
+ return segs;
+ };
+ /* Date Handling
+ ------------------------------------------------------------------------------------------------------------------*/
+ TimeGrid.prototype.sliceRangeByTimes = function (unzonedRange) {
+ var segs = [];
+ var segRange;
+ var dayIndex;
+ for (dayIndex = 0; dayIndex < this.daysPerRow; dayIndex++) {
+ segRange = unzonedRange.intersect(this.dayRanges[dayIndex]);
+ if (segRange) {
+ segs.push({
+ startMs: segRange.startMs,
+ endMs: segRange.endMs,
+ isStart: segRange.isStart,
+ isEnd: segRange.isEnd,
+ dayIndex: dayIndex
+ });
+ }
+ }
+ return segs;
+ };
+ /* Options
+ ------------------------------------------------------------------------------------------------------------------*/
+ // Parses various options into properties of this object
+ TimeGrid.prototype.processOptions = function () {
+ var slotDuration = this.opt('slotDuration');
+ var snapDuration = this.opt('snapDuration');
+ var input;
+ slotDuration = moment.duration(slotDuration);
+ snapDuration = snapDuration ? moment.duration(snapDuration) : slotDuration;
+ this.slotDuration = slotDuration;
+ this.snapDuration = snapDuration;
+ this.snapsPerSlot = slotDuration / snapDuration; // TODO: ensure an integer multiple?
+ // might be an array value (for TimelineView).
+ // if so, getting the most granular entry (the last one probably).
+ input = this.opt('slotLabelFormat');
+ if ($.isArray(input)) {
+ input = input[input.length - 1];
+ }
+ this.labelFormat = input ||
+ this.opt('smallTimeFormat'); // the computed default
+ input = this.opt('slotLabelInterval');
+ this.labelInterval = input ?
+ moment.duration(input) :
+ this.computeLabelInterval(slotDuration);
+ };
+ // Computes an automatic value for slotLabelInterval
+ TimeGrid.prototype.computeLabelInterval = function (slotDuration) {
+ var i;
+ var labelInterval;
+ var slotsPerLabel;
+ // find the smallest stock label interval that results in more than one slots-per-label
+ for (i = AGENDA_STOCK_SUB_DURATIONS.length - 1; i >= 0; i--) {
+ labelInterval = moment.duration(AGENDA_STOCK_SUB_DURATIONS[i]);
+ slotsPerLabel = util_1.divideDurationByDuration(labelInterval, slotDuration);
+ if (util_1.isInt(slotsPerLabel) && slotsPerLabel > 1) {
+ return labelInterval;
+ }
+ }
+ return moment.duration(slotDuration); // fall back. clone
+ };
+ /* Date Rendering
+ ------------------------------------------------------------------------------------------------------------------*/
+ TimeGrid.prototype.renderDates = function (dateProfile) {
+ this.dateProfile = dateProfile;
+ this.updateDayTable();
+ this.renderSlats();
+ this.renderColumns();
+ };
+ TimeGrid.prototype.unrenderDates = function () {
+ // this.unrenderSlats(); // don't need this because repeated .html() calls clear
+ this.unrenderColumns();
+ };
+ TimeGrid.prototype.renderSkeleton = function () {
+ var theme = this.view.calendar.theme;
+ this.el.html('' +
+ '' +
+ '');
+ this.bottomRuleEl = this.el.find('hr');
+ };
+ TimeGrid.prototype.renderSlats = function () {
+ var theme = this.view.calendar.theme;
+ this.slatContainerEl = this.el.find('> .fc-slats')
+ .html(// avoids needing ::unrenderSlats()
+ '' +
+ this.renderSlatRowHtml() +
+ ' ');
+ this.slatEls = this.slatContainerEl.find('tr');
+ this.slatCoordCache = new CoordCache_1.default({
+ els: this.slatEls,
+ isVertical: true
+ });
+ };
+ // Generates the HTML for the horizontal "slats" that run width-wise. Has a time axis on a side. Depends on RTL.
+ TimeGrid.prototype.renderSlatRowHtml = function () {
+ var view = this.view;
+ var calendar = view.calendar;
+ var theme = calendar.theme;
+ var isRTL = this.isRTL;
+ var dateProfile = this.dateProfile;
+ var html = '';
+ var slotTime = moment.duration(+dateProfile.minTime); // wish there was .clone() for durations
+ var slotIterator = moment.duration(0);
+ var slotDate; // will be on the view's first day, but we only care about its time
+ var isLabeled;
+ var axisHtml;
+ // Calculate the time for each slot
+ while (slotTime < dateProfile.maxTime) {
+ slotDate = calendar.msToUtcMoment(dateProfile.renderUnzonedRange.startMs).time(slotTime);
+ isLabeled = util_1.isInt(util_1.divideDurationByDuration(slotIterator, this.labelInterval));
+ axisHtml =
+ '' +
+ (isLabeled ?
+ '' + // for matchCellWidths
+ util_1.htmlEscape(slotDate.format(this.labelFormat)) +
+ '' :
+ '') +
+ ' | ';
+ html +=
+ '' +
+ (!isRTL ? axisHtml : '') +
+ ' | ' +
+ (isRTL ? axisHtml : '') +
+ ' ';
+ slotTime.add(this.slotDuration);
+ slotIterator.add(this.slotDuration);
+ }
+ return html;
+ };
+ TimeGrid.prototype.renderColumns = function () {
+ var dateProfile = this.dateProfile;
+ var theme = this.view.calendar.theme;
+ this.dayRanges = this.dayDates.map(function (dayDate) {
+ return new UnzonedRange_1.default(dayDate.clone().add(dateProfile.minTime), dayDate.clone().add(dateProfile.maxTime));
+ });
+ if (this.headContainerEl) {
+ this.headContainerEl.html(this.renderHeadHtml());
+ }
+ this.el.find('> .fc-bg').html('' +
+ this.renderBgTrHtml(0) + // row=0
+ ' ');
+ this.colEls = this.el.find('.fc-day, .fc-disabled-day');
+ this.colCoordCache = new CoordCache_1.default({
+ els: this.colEls,
+ isHorizontal: true
+ });
+ this.renderContentSkeleton();
+ };
+ TimeGrid.prototype.unrenderColumns = function () {
+ this.unrenderContentSkeleton();
+ };
+ /* Content Skeleton
+ ------------------------------------------------------------------------------------------------------------------*/
+ // Renders the DOM that the view's content will live in
+ TimeGrid.prototype.renderContentSkeleton = function () {
+ var cellHtml = '';
+ var i;
+ var skeletonEl;
+ for (i = 0; i < this.colCnt; i++) {
+ cellHtml +=
+ '' +
+ '' +
+ ' ' +
+ ' ' +
+ ' ' +
+ ' ' +
+ ' ' +
+ ' | ';
+ }
+ skeletonEl = this.contentSkeletonEl = $('' +
+ ' ' +
+ '' + cellHtml + ' ' +
+ ' ' +
+ ' ' + // TODO: try less wraps
+ ' ' +
+ ' ' +
+ util_1.htmlEscape(this.opt('noEventsMessage')) +
+ ' ' +
+ ' ' +
+ ' ' +
+ '' +
+ ' ';
+ };
+ return ListView;
+}(View_1.default));
+exports.default = ListView;
+ListView.prototype.eventRendererClass = ListEventRenderer_1.default;
+ListView.prototype.eventPointingClass = ListEventPointing_1.default;
+
+
+/***/ }),
+/* 231 */,
+/* 232 */,
+/* 233 */,
+/* 234 */,
+/* 235 */,
+/* 236 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $ = __webpack_require__(3);
+var exportHooks = __webpack_require__(16);
+var util_1 = __webpack_require__(4);
+var Calendar_1 = __webpack_require__(220);
+// for intentional side-effects
+__webpack_require__(10);
+__webpack_require__(47);
+__webpack_require__(256);
+__webpack_require__(257);
+__webpack_require__(260);
+__webpack_require__(261);
+__webpack_require__(262);
+__webpack_require__(263);
+$.fullCalendar = exportHooks;
+$.fn.fullCalendar = function (options) {
+ var args = Array.prototype.slice.call(arguments, 1); // for a possible method call
+ var res = this; // what this function will return (this jQuery object by default)
+ this.each(function (i, _element) {
+ var element = $(_element);
+ var calendar = element.data('fullCalendar'); // get the existing calendar object (if any)
+ var singleRes; // the returned value of this single method call
+ // a method call
+ if (typeof options === 'string') {
+ if (options === 'getCalendar') {
+ if (!i) {
+ res = calendar;
+ }
+ }
+ else if (options === 'destroy') {
+ if (calendar) {
+ calendar.destroy();
+ element.removeData('fullCalendar');
+ }
+ }
+ else if (!calendar) {
+ util_1.warn('Attempting to call a FullCalendar method on an element with no calendar.');
+ }
+ else if ($.isFunction(calendar[options])) {
+ singleRes = calendar[options].apply(calendar, args);
+ if (!i) {
+ res = singleRes; // record the first method call result
+ }
+ if (options === 'destroy') {
+ element.removeData('fullCalendar');
+ }
+ }
+ else {
+ util_1.warn("'" + options + "' is an unknown FullCalendar method.");
+ }
+ }
+ else if (!calendar) {
+ calendar = new Calendar_1.default(element, options);
+ element.data('fullCalendar', calendar);
+ calendar.render();
+ }
+ });
+ return res;
+};
+module.exports = exportHooks;
+
+
+/***/ }),
+/* 237 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var Model_1 = __webpack_require__(48);
+var Component = /** @class */ (function (_super) {
+ tslib_1.__extends(Component, _super);
+ function Component() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Component.prototype.setElement = function (el) {
+ this.el = el;
+ this.bindGlobalHandlers();
+ this.renderSkeleton();
+ this.set('isInDom', true);
+ };
+ Component.prototype.removeElement = function () {
+ this.unset('isInDom');
+ this.unrenderSkeleton();
+ this.unbindGlobalHandlers();
+ this.el.remove();
+ // NOTE: don't null-out this.el in case the View was destroyed within an API callback.
+ // We don't null-out the View's other jQuery element references upon destroy,
+ // so we shouldn't kill this.el either.
+ };
+ Component.prototype.bindGlobalHandlers = function () {
+ // subclasses can override
+ };
+ Component.prototype.unbindGlobalHandlers = function () {
+ // subclasses can override
+ };
+ /*
+ NOTE: Can't have a `render` method. Read the deprecation notice in View::executeDateRender
+ */
+ // Renders the basic structure of the view before any content is rendered
+ Component.prototype.renderSkeleton = function () {
+ // subclasses should implement
+ };
+ // Unrenders the basic structure of the view
+ Component.prototype.unrenderSkeleton = function () {
+ // subclasses should implement
+ };
+ return Component;
+}(Model_1.default));
+exports.default = Component;
+
+
+/***/ }),
+/* 238 */
+/***/ (function(module, exports) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var Iterator = /** @class */ (function () {
+ function Iterator(items) {
+ this.items = items || [];
+ }
+ /* Calls a method on every item passing the arguments through */
+ Iterator.prototype.proxyCall = function (methodName) {
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ var results = [];
+ this.items.forEach(function (item) {
+ results.push(item[methodName].apply(item, args));
+ });
+ return results;
+ };
+ return Iterator;
+}());
+exports.default = Iterator;
+
+
+/***/ }),
+/* 239 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var $ = __webpack_require__(3);
+var util_1 = __webpack_require__(4);
+/* Toolbar with buttons and title
+----------------------------------------------------------------------------------------------------------------------*/
+var Toolbar = /** @class */ (function () {
+ function Toolbar(calendar, toolbarOptions) {
+ this.el = null; // mirrors local `el`
+ this.viewsWithButtons = [];
+ this.calendar = calendar;
+ this.toolbarOptions = toolbarOptions;
+ }
+ // method to update toolbar-specific options, not calendar-wide options
+ Toolbar.prototype.setToolbarOptions = function (newToolbarOptions) {
+ this.toolbarOptions = newToolbarOptions;
+ };
+ // can be called repeatedly and will rerender
+ Toolbar.prototype.render = function () {
+ var sections = this.toolbarOptions.layout;
+ var el = this.el;
+ if (sections) {
+ if (!el) {
+ el = this.el = $("");
+ }
+ else {
+ el.empty();
+ }
+ el.append(this.renderSection('left'))
+ .append(this.renderSection('right'))
+ .append(this.renderSection('center'))
+ .append('');
+ }
+ else {
+ this.removeElement();
+ }
+ };
+ Toolbar.prototype.removeElement = function () {
+ if (this.el) {
+ this.el.remove();
+ this.el = null;
+ }
+ };
+ Toolbar.prototype.renderSection = function (position) {
+ var _this = this;
+ var calendar = this.calendar;
+ var theme = calendar.theme;
+ var optionsManager = calendar.optionsManager;
+ var viewSpecManager = calendar.viewSpecManager;
+ var sectionEl = $('');
+ var buttonStr = this.toolbarOptions.layout[position];
+ var calendarCustomButtons = optionsManager.get('customButtons') || {};
+ var calendarButtonTextOverrides = optionsManager.overrides.buttonText || {};
+ var calendarButtonText = optionsManager.get('buttonText') || {};
+ if (buttonStr) {
+ $.each(buttonStr.split(' '), function (i, buttonGroupStr) {
+ var groupChildren = $();
+ var isOnlyButtons = true;
+ var groupEl;
+ $.each(buttonGroupStr.split(','), function (j, buttonName) {
+ var customButtonProps;
+ var viewSpec;
+ var buttonClick;
+ var buttonIcon; // only one of these will be set
+ var buttonText; // "
+ var buttonInnerHtml;
+ var buttonClasses;
+ var buttonEl;
+ var buttonAriaAttr;
+ if (buttonName === 'title') {
+ groupChildren = groupChildren.add($(' ')); // we always want it to take up height
+ isOnlyButtons = false;
+ }
+ else {
+ if ((customButtonProps = calendarCustomButtons[buttonName])) {
+ buttonClick = function (ev) {
+ if (customButtonProps.click) {
+ customButtonProps.click.call(buttonEl[0], ev);
+ }
+ };
+ (buttonIcon = theme.getCustomButtonIconClass(customButtonProps)) ||
+ (buttonIcon = theme.getIconClass(buttonName)) ||
+ (buttonText = customButtonProps.text);
+ }
+ else if ((viewSpec = viewSpecManager.getViewSpec(buttonName))) {
+ _this.viewsWithButtons.push(buttonName);
+ buttonClick = function () {
+ calendar.changeView(buttonName);
+ };
+ (buttonText = viewSpec.buttonTextOverride) ||
+ (buttonIcon = theme.getIconClass(buttonName)) ||
+ (buttonText = viewSpec.buttonTextDefault);
+ }
+ else if (calendar[buttonName]) {
+ buttonClick = function () {
+ calendar[buttonName]();
+ };
+ (buttonText = calendarButtonTextOverrides[buttonName]) ||
+ (buttonIcon = theme.getIconClass(buttonName)) ||
+ (buttonText = calendarButtonText[buttonName]);
+ // ^ everything else is considered default
+ }
+ if (buttonClick) {
+ buttonClasses = [
+ 'fc-' + buttonName + '-button',
+ theme.getClass('button'),
+ theme.getClass('stateDefault')
+ ];
+ if (buttonText) {
+ buttonInnerHtml = util_1.htmlEscape(buttonText);
+ buttonAriaAttr = '';
+ }
+ else if (buttonIcon) {
+ buttonInnerHtml = "";
+ buttonAriaAttr = ' aria-label="' + buttonName + '"';
+ }
+ buttonEl = $(// type="button" so that it doesn't submit a form
+ '')
+ .click(function (ev) {
+ // don't process clicks for disabled buttons
+ if (!buttonEl.hasClass(theme.getClass('stateDisabled'))) {
+ buttonClick(ev);
+ // after the click action, if the button becomes the "active" tab, or disabled,
+ // it should never have a hover class, so remove it now.
+ if (buttonEl.hasClass(theme.getClass('stateActive')) ||
+ buttonEl.hasClass(theme.getClass('stateDisabled'))) {
+ buttonEl.removeClass(theme.getClass('stateHover'));
+ }
+ }
+ })
+ .mousedown(function () {
+ // the *down* effect (mouse pressed in).
+ // only on buttons that are not the "active" tab, or disabled
+ buttonEl
+ .not('.' + theme.getClass('stateActive'))
+ .not('.' + theme.getClass('stateDisabled'))
+ .addClass(theme.getClass('stateDown'));
+ })
+ .mouseup(function () {
+ // undo the *down* effect
+ buttonEl.removeClass(theme.getClass('stateDown'));
+ })
+ .hover(function () {
+ // the *hover* effect.
+ // only on buttons that are not the "active" tab, or disabled
+ buttonEl
+ .not('.' + theme.getClass('stateActive'))
+ .not('.' + theme.getClass('stateDisabled'))
+ .addClass(theme.getClass('stateHover'));
+ }, function () {
+ // undo the *hover* effect
+ buttonEl
+ .removeClass(theme.getClass('stateHover'))
+ .removeClass(theme.getClass('stateDown')); // if mouseleave happens before mouseup
+ });
+ groupChildren = groupChildren.add(buttonEl);
+ }
+ }
+ });
+ if (isOnlyButtons) {
+ groupChildren
+ .first().addClass(theme.getClass('cornerLeft')).end()
+ .last().addClass(theme.getClass('cornerRight')).end();
+ }
+ if (groupChildren.length > 1) {
+ groupEl = $('');
+ if (isOnlyButtons) {
+ groupEl.addClass(theme.getClass('buttonGroup'));
+ }
+ groupEl.append(groupChildren);
+ sectionEl.append(groupEl);
+ }
+ else {
+ sectionEl.append(groupChildren); // 1 or 0 children
+ }
+ });
+ }
+ return sectionEl;
+ };
+ Toolbar.prototype.updateTitle = function (text) {
+ if (this.el) {
+ this.el.find('h2').text(text);
+ }
+ };
+ Toolbar.prototype.activateButton = function (buttonName) {
+ if (this.el) {
+ this.el.find('.fc-' + buttonName + '-button')
+ .addClass(this.calendar.theme.getClass('stateActive'));
+ }
+ };
+ Toolbar.prototype.deactivateButton = function (buttonName) {
+ if (this.el) {
+ this.el.find('.fc-' + buttonName + '-button')
+ .removeClass(this.calendar.theme.getClass('stateActive'));
+ }
+ };
+ Toolbar.prototype.disableButton = function (buttonName) {
+ if (this.el) {
+ this.el.find('.fc-' + buttonName + '-button')
+ .prop('disabled', true)
+ .addClass(this.calendar.theme.getClass('stateDisabled'));
+ }
+ };
+ Toolbar.prototype.enableButton = function (buttonName) {
+ if (this.el) {
+ this.el.find('.fc-' + buttonName + '-button')
+ .prop('disabled', false)
+ .removeClass(this.calendar.theme.getClass('stateDisabled'));
+ }
+ };
+ Toolbar.prototype.getViewsWithButtons = function () {
+ return this.viewsWithButtons;
+ };
+ return Toolbar;
+}());
+exports.default = Toolbar;
+
+
+/***/ }),
+/* 240 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var util_1 = __webpack_require__(4);
+var options_1 = __webpack_require__(32);
+var locale_1 = __webpack_require__(31);
+var Model_1 = __webpack_require__(48);
+var OptionsManager = /** @class */ (function (_super) {
+ tslib_1.__extends(OptionsManager, _super);
+ function OptionsManager(_calendar, overrides) {
+ var _this = _super.call(this) || this;
+ _this._calendar = _calendar;
+ _this.overrides = $.extend({}, overrides); // make a copy
+ _this.dynamicOverrides = {};
+ _this.compute();
+ return _this;
+ }
+ OptionsManager.prototype.add = function (newOptionHash) {
+ var optionCnt = 0;
+ var optionName;
+ this.recordOverrides(newOptionHash); // will trigger this model's watchers
+ for (optionName in newOptionHash) {
+ optionCnt++;
+ }
+ // special-case handling of single option change.
+ // if only one option change, `optionName` will be its name.
+ if (optionCnt === 1) {
+ if (optionName === 'height' || optionName === 'contentHeight' || optionName === 'aspectRatio') {
+ this._calendar.updateViewSize(true); // isResize=true
+ return;
+ }
+ else if (optionName === 'defaultDate') {
+ return; // can't change date this way. use gotoDate instead
+ }
+ else if (optionName === 'businessHours') {
+ return; // this model already reacts to this
+ }
+ else if (/^(event|select)(Overlap|Constraint|Allow)$/.test(optionName)) {
+ return; // doesn't affect rendering. only interactions.
+ }
+ else if (optionName === 'timezone') {
+ this._calendar.view.flash('initialEvents');
+ return;
+ }
+ }
+ // catch-all. rerender the header and footer and rebuild/rerender the current view
+ this._calendar.renderHeader();
+ this._calendar.renderFooter();
+ // even non-current views will be affected by this option change. do before rerender
+ // TODO: detangle
+ this._calendar.viewsByType = {};
+ this._calendar.reinitView();
+ };
+ // Computes the flattened options hash for the calendar and assigns to `this.options`.
+ // Assumes this.overrides and this.dynamicOverrides have already been initialized.
+ OptionsManager.prototype.compute = function () {
+ var locale;
+ var localeDefaults;
+ var isRTL;
+ var dirDefaults;
+ var rawOptions;
+ locale = util_1.firstDefined(// explicit locale option given?
+ this.dynamicOverrides.locale, this.overrides.locale);
+ localeDefaults = locale_1.localeOptionHash[locale];
+ if (!localeDefaults) {
+ locale = options_1.globalDefaults.locale;
+ localeDefaults = locale_1.localeOptionHash[locale] || {};
+ }
+ isRTL = util_1.firstDefined(// based on options computed so far, is direction RTL?
+ this.dynamicOverrides.isRTL, this.overrides.isRTL, localeDefaults.isRTL, options_1.globalDefaults.isRTL);
+ dirDefaults = isRTL ? options_1.rtlDefaults : {};
+ this.dirDefaults = dirDefaults;
+ this.localeDefaults = localeDefaults;
+ rawOptions = options_1.mergeOptions([
+ options_1.globalDefaults,
+ dirDefaults,
+ localeDefaults,
+ this.overrides,
+ this.dynamicOverrides
+ ]);
+ locale_1.populateInstanceComputableOptions(rawOptions); // fill in gaps with computed options
+ this.reset(rawOptions);
+ };
+ // stores the new options internally, but does not rerender anything.
+ OptionsManager.prototype.recordOverrides = function (newOptionHash) {
+ var optionName;
+ for (optionName in newOptionHash) {
+ this.dynamicOverrides[optionName] = newOptionHash[optionName];
+ }
+ this._calendar.viewSpecManager.clearCache(); // the dynamic override invalidates the options in this cache, so just clear it
+ this.compute(); // this.options needs to be recomputed after the dynamic override
+ };
+ return OptionsManager;
+}(Model_1.default));
+exports.default = OptionsManager;
+
+
+/***/ }),
+/* 241 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var moment = __webpack_require__(0);
+var $ = __webpack_require__(3);
+var ViewRegistry_1 = __webpack_require__(22);
+var util_1 = __webpack_require__(4);
+var options_1 = __webpack_require__(32);
+var locale_1 = __webpack_require__(31);
+var ViewSpecManager = /** @class */ (function () {
+ function ViewSpecManager(optionsManager, _calendar) {
+ this.optionsManager = optionsManager;
+ this._calendar = _calendar;
+ this.clearCache();
+ }
+ ViewSpecManager.prototype.clearCache = function () {
+ this.viewSpecCache = {};
+ };
+ // Gets information about how to create a view. Will use a cache.
+ ViewSpecManager.prototype.getViewSpec = function (viewType) {
+ var cache = this.viewSpecCache;
+ return cache[viewType] || (cache[viewType] = this.buildViewSpec(viewType));
+ };
+ // Given a duration singular unit, like "week" or "day", finds a matching view spec.
+ // Preference is given to views that have corresponding buttons.
+ ViewSpecManager.prototype.getUnitViewSpec = function (unit) {
+ var viewTypes;
+ var i;
+ var spec;
+ if ($.inArray(unit, util_1.unitsDesc) !== -1) {
+ // put views that have buttons first. there will be duplicates, but oh well
+ viewTypes = this._calendar.header.getViewsWithButtons(); // TODO: include footer as well?
+ $.each(ViewRegistry_1.viewHash, function (viewType) {
+ viewTypes.push(viewType);
+ });
+ for (i = 0; i < viewTypes.length; i++) {
+ spec = this.getViewSpec(viewTypes[i]);
+ if (spec) {
+ if (spec.singleUnit === unit) {
+ return spec;
+ }
+ }
+ }
+ }
+ };
+ // Builds an object with information on how to create a given view
+ ViewSpecManager.prototype.buildViewSpec = function (requestedViewType) {
+ var viewOverrides = this.optionsManager.overrides.views || {};
+ var specChain = []; // for the view. lowest to highest priority
+ var defaultsChain = []; // for the view. lowest to highest priority
+ var overridesChain = []; // for the view. lowest to highest priority
+ var viewType = requestedViewType;
+ var spec; // for the view
+ var overrides; // for the view
+ var durationInput;
+ var duration;
+ var unit;
+ // iterate from the specific view definition to a more general one until we hit an actual View class
+ while (viewType) {
+ spec = ViewRegistry_1.viewHash[viewType];
+ overrides = viewOverrides[viewType];
+ viewType = null; // clear. might repopulate for another iteration
+ if (typeof spec === 'function') {
+ spec = { 'class': spec };
+ }
+ if (spec) {
+ specChain.unshift(spec);
+ defaultsChain.unshift(spec.defaults || {});
+ durationInput = durationInput || spec.duration;
+ viewType = viewType || spec.type;
+ }
+ if (overrides) {
+ overridesChain.unshift(overrides); // view-specific option hashes have options at zero-level
+ durationInput = durationInput || overrides.duration;
+ viewType = viewType || overrides.type;
+ }
+ }
+ spec = util_1.mergeProps(specChain);
+ spec.type = requestedViewType;
+ if (!spec['class']) {
+ return false;
+ }
+ // fall back to top-level `duration` option
+ durationInput = durationInput ||
+ this.optionsManager.dynamicOverrides.duration ||
+ this.optionsManager.overrides.duration;
+ if (durationInput) {
+ duration = moment.duration(durationInput);
+ if (duration.valueOf()) {
+ unit = util_1.computeDurationGreatestUnit(duration, durationInput);
+ spec.duration = duration;
+ spec.durationUnit = unit;
+ // view is a single-unit duration, like "week" or "day"
+ // incorporate options for this. lowest priority
+ if (duration.as(unit) === 1) {
+ spec.singleUnit = unit;
+ overridesChain.unshift(viewOverrides[unit] || {});
+ }
+ }
+ }
+ spec.defaults = options_1.mergeOptions(defaultsChain);
+ spec.overrides = options_1.mergeOptions(overridesChain);
+ this.buildViewSpecOptions(spec);
+ this.buildViewSpecButtonText(spec, requestedViewType);
+ return spec;
+ };
+ // Builds and assigns a view spec's options object from its already-assigned defaults and overrides
+ ViewSpecManager.prototype.buildViewSpecOptions = function (spec) {
+ var optionsManager = this.optionsManager;
+ spec.options = options_1.mergeOptions([
+ options_1.globalDefaults,
+ spec.defaults,
+ optionsManager.dirDefaults,
+ optionsManager.localeDefaults,
+ optionsManager.overrides,
+ spec.overrides,
+ optionsManager.dynamicOverrides // dynamically set via setter. highest precedence
+ ]);
+ locale_1.populateInstanceComputableOptions(spec.options);
+ };
+ // Computes and assigns a view spec's buttonText-related options
+ ViewSpecManager.prototype.buildViewSpecButtonText = function (spec, requestedViewType) {
+ var optionsManager = this.optionsManager;
+ // given an options object with a possible `buttonText` hash, lookup the buttonText for the
+ // requested view, falling back to a generic unit entry like "week" or "day"
+ function queryButtonText(options) {
+ var buttonText = options.buttonText || {};
+ return buttonText[requestedViewType] ||
+ // view can decide to look up a certain key
+ (spec.buttonTextKey ? buttonText[spec.buttonTextKey] : null) ||
+ // a key like "month"
+ (spec.singleUnit ? buttonText[spec.singleUnit] : null);
+ }
+ // highest to lowest priority
+ spec.buttonTextOverride =
+ queryButtonText(optionsManager.dynamicOverrides) ||
+ queryButtonText(optionsManager.overrides) || // constructor-specified buttonText lookup hash takes precedence
+ spec.overrides.buttonText; // `buttonText` for view-specific options is a string
+ // highest to lowest priority. mirrors buildViewSpecOptions
+ spec.buttonTextDefault =
+ queryButtonText(optionsManager.localeDefaults) ||
+ queryButtonText(optionsManager.dirDefaults) ||
+ spec.defaults.buttonText || // a single string. from ViewSubclass.defaults
+ queryButtonText(options_1.globalDefaults) ||
+ (spec.duration ? this._calendar.humanizeDuration(spec.duration) : null) || // like "3 days"
+ requestedViewType; // fall back to given view name
+ };
+ return ViewSpecManager;
+}());
+exports.default = ViewSpecManager;
+
+
+/***/ }),
+/* 242 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var $ = __webpack_require__(3);
+var util_1 = __webpack_require__(4);
+var EventPeriod_1 = __webpack_require__(243);
+var ArrayEventSource_1 = __webpack_require__(52);
+var EventSource_1 = __webpack_require__(6);
+var EventSourceParser_1 = __webpack_require__(38);
+var SingleEventDef_1 = __webpack_require__(13);
+var EventInstanceGroup_1 = __webpack_require__(18);
+var EmitterMixin_1 = __webpack_require__(11);
+var ListenerMixin_1 = __webpack_require__(7);
+var EventManager = /** @class */ (function () {
+ function EventManager(calendar) {
+ this.calendar = calendar;
+ this.stickySource = new ArrayEventSource_1.default(calendar);
+ this.otherSources = [];
+ }
+ EventManager.prototype.requestEvents = function (start, end, timezone, force) {
+ if (force ||
+ !this.currentPeriod ||
+ !this.currentPeriod.isWithinRange(start, end) ||
+ timezone !== this.currentPeriod.timezone) {
+ this.setPeriod(// will change this.currentPeriod
+ new EventPeriod_1.default(start, end, timezone));
+ }
+ return this.currentPeriod.whenReleased();
+ };
+ // Source Adding/Removing
+ // -----------------------------------------------------------------------------------------------------------------
+ EventManager.prototype.addSource = function (eventSource) {
+ this.otherSources.push(eventSource);
+ if (this.currentPeriod) {
+ this.currentPeriod.requestSource(eventSource); // might release
+ }
+ };
+ EventManager.prototype.removeSource = function (doomedSource) {
+ util_1.removeExact(this.otherSources, doomedSource);
+ if (this.currentPeriod) {
+ this.currentPeriod.purgeSource(doomedSource); // might release
+ }
+ };
+ EventManager.prototype.removeAllSources = function () {
+ this.otherSources = [];
+ if (this.currentPeriod) {
+ this.currentPeriod.purgeAllSources(); // might release
+ }
+ };
+ // Source Refetching
+ // -----------------------------------------------------------------------------------------------------------------
+ EventManager.prototype.refetchSource = function (eventSource) {
+ var currentPeriod = this.currentPeriod;
+ if (currentPeriod) {
+ currentPeriod.freeze();
+ currentPeriod.purgeSource(eventSource);
+ currentPeriod.requestSource(eventSource);
+ currentPeriod.thaw();
+ }
+ };
+ EventManager.prototype.refetchAllSources = function () {
+ var currentPeriod = this.currentPeriod;
+ if (currentPeriod) {
+ currentPeriod.freeze();
+ currentPeriod.purgeAllSources();
+ currentPeriod.requestSources(this.getSources());
+ currentPeriod.thaw();
+ }
+ };
+ // Source Querying
+ // -----------------------------------------------------------------------------------------------------------------
+ EventManager.prototype.getSources = function () {
+ return [this.stickySource].concat(this.otherSources);
+ };
+ // like querySources, but accepts multple match criteria (like multiple IDs)
+ EventManager.prototype.multiQuerySources = function (matchInputs) {
+ // coerce into an array
+ if (!matchInputs) {
+ matchInputs = [];
+ }
+ else if (!$.isArray(matchInputs)) {
+ matchInputs = [matchInputs];
+ }
+ var matchingSources = [];
+ var i;
+ // resolve raw inputs to real event source objects
+ for (i = 0; i < matchInputs.length; i++) {
+ matchingSources.push.apply(// append
+ matchingSources, this.querySources(matchInputs[i]));
+ }
+ return matchingSources;
+ };
+ // matchInput can either by a real event source object, an ID, or the function/URL for the source.
+ // returns an array of matching source objects.
+ EventManager.prototype.querySources = function (matchInput) {
+ var sources = this.otherSources;
+ var i;
+ var source;
+ // given a proper event source object
+ for (i = 0; i < sources.length; i++) {
+ source = sources[i];
+ if (source === matchInput) {
+ return [source];
+ }
+ }
+ // an ID match
+ source = this.getSourceById(EventSource_1.default.normalizeId(matchInput));
+ if (source) {
+ return [source];
+ }
+ // parse as an event source
+ matchInput = EventSourceParser_1.default.parse(matchInput, this.calendar);
+ if (matchInput) {
+ return $.grep(sources, function (source) {
+ return isSourcesEquivalent(matchInput, source);
+ });
+ }
+ };
+ /*
+ ID assumed to already be normalized
+ */
+ EventManager.prototype.getSourceById = function (id) {
+ return $.grep(this.otherSources, function (source) {
+ return source.id && source.id === id;
+ })[0];
+ };
+ // Event-Period
+ // -----------------------------------------------------------------------------------------------------------------
+ EventManager.prototype.setPeriod = function (eventPeriod) {
+ if (this.currentPeriod) {
+ this.unbindPeriod(this.currentPeriod);
+ this.currentPeriod = null;
+ }
+ this.currentPeriod = eventPeriod;
+ this.bindPeriod(eventPeriod);
+ eventPeriod.requestSources(this.getSources());
+ };
+ EventManager.prototype.bindPeriod = function (eventPeriod) {
+ this.listenTo(eventPeriod, 'release', function (eventsPayload) {
+ this.trigger('release', eventsPayload);
+ });
+ };
+ EventManager.prototype.unbindPeriod = function (eventPeriod) {
+ this.stopListeningTo(eventPeriod);
+ };
+ // Event Getting/Adding/Removing
+ // -----------------------------------------------------------------------------------------------------------------
+ EventManager.prototype.getEventDefByUid = function (uid) {
+ if (this.currentPeriod) {
+ return this.currentPeriod.getEventDefByUid(uid);
+ }
+ };
+ EventManager.prototype.addEventDef = function (eventDef, isSticky) {
+ if (isSticky) {
+ this.stickySource.addEventDef(eventDef);
+ }
+ if (this.currentPeriod) {
+ this.currentPeriod.addEventDef(eventDef); // might release
+ }
+ };
+ EventManager.prototype.removeEventDefsById = function (eventId) {
+ this.getSources().forEach(function (eventSource) {
+ eventSource.removeEventDefsById(eventId);
+ });
+ if (this.currentPeriod) {
+ this.currentPeriod.removeEventDefsById(eventId); // might release
+ }
+ };
+ EventManager.prototype.removeAllEventDefs = function () {
+ this.getSources().forEach(function (eventSource) {
+ eventSource.removeAllEventDefs();
+ });
+ if (this.currentPeriod) {
+ this.currentPeriod.removeAllEventDefs();
+ }
+ };
+ // Event Mutating
+ // -----------------------------------------------------------------------------------------------------------------
+ /*
+ Returns an undo function.
+ */
+ EventManager.prototype.mutateEventsWithId = function (eventDefId, eventDefMutation) {
+ var currentPeriod = this.currentPeriod;
+ var eventDefs;
+ var undoFuncs = [];
+ if (currentPeriod) {
+ currentPeriod.freeze();
+ eventDefs = currentPeriod.getEventDefsById(eventDefId);
+ eventDefs.forEach(function (eventDef) {
+ // add/remove esp because id might change
+ currentPeriod.removeEventDef(eventDef);
+ undoFuncs.push(eventDefMutation.mutateSingle(eventDef));
+ currentPeriod.addEventDef(eventDef);
+ });
+ currentPeriod.thaw();
+ return function () {
+ currentPeriod.freeze();
+ for (var i = 0; i < eventDefs.length; i++) {
+ currentPeriod.removeEventDef(eventDefs[i]);
+ undoFuncs[i]();
+ currentPeriod.addEventDef(eventDefs[i]);
+ }
+ currentPeriod.thaw();
+ };
+ }
+ return function () { };
+ };
+ /*
+ copies and then mutates
+ */
+ EventManager.prototype.buildMutatedEventInstanceGroup = function (eventDefId, eventDefMutation) {
+ var eventDefs = this.getEventDefsById(eventDefId);
+ var i;
+ var defCopy;
+ var allInstances = [];
+ for (i = 0; i < eventDefs.length; i++) {
+ defCopy = eventDefs[i].clone();
+ if (defCopy instanceof SingleEventDef_1.default) {
+ eventDefMutation.mutateSingle(defCopy);
+ allInstances.push.apply(allInstances, // append
+ defCopy.buildInstances());
+ }
+ }
+ return new EventInstanceGroup_1.default(allInstances);
+ };
+ // Freezing
+ // -----------------------------------------------------------------------------------------------------------------
+ EventManager.prototype.freeze = function () {
+ if (this.currentPeriod) {
+ this.currentPeriod.freeze();
+ }
+ };
+ EventManager.prototype.thaw = function () {
+ if (this.currentPeriod) {
+ this.currentPeriod.thaw();
+ }
+ };
+ // methods that simply forward to EventPeriod
+ EventManager.prototype.getEventDefsById = function (eventDefId) {
+ return this.currentPeriod.getEventDefsById(eventDefId);
+ };
+ EventManager.prototype.getEventInstances = function () {
+ return this.currentPeriod.getEventInstances();
+ };
+ EventManager.prototype.getEventInstancesWithId = function (eventDefId) {
+ return this.currentPeriod.getEventInstancesWithId(eventDefId);
+ };
+ EventManager.prototype.getEventInstancesWithoutId = function (eventDefId) {
+ return this.currentPeriod.getEventInstancesWithoutId(eventDefId);
+ };
+ return EventManager;
+}());
+exports.default = EventManager;
+EmitterMixin_1.default.mixInto(EventManager);
+ListenerMixin_1.default.mixInto(EventManager);
+function isSourcesEquivalent(source0, source1) {
+ return source0.getPrimitive() === source1.getPrimitive();
+}
+
+
+/***/ }),
+/* 243 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var $ = __webpack_require__(3);
+var util_1 = __webpack_require__(4);
+var Promise_1 = __webpack_require__(20);
+var EmitterMixin_1 = __webpack_require__(11);
+var UnzonedRange_1 = __webpack_require__(5);
+var EventInstanceGroup_1 = __webpack_require__(18);
+var EventPeriod = /** @class */ (function () {
+ function EventPeriod(start, end, timezone) {
+ this.pendingCnt = 0;
+ this.freezeDepth = 0;
+ this.stuntedReleaseCnt = 0;
+ this.releaseCnt = 0;
+ this.start = start;
+ this.end = end;
+ this.timezone = timezone;
+ this.unzonedRange = new UnzonedRange_1.default(start.clone().stripZone(), end.clone().stripZone());
+ this.requestsByUid = {};
+ this.eventDefsByUid = {};
+ this.eventDefsById = {};
+ this.eventInstanceGroupsById = {};
+ }
+ EventPeriod.prototype.isWithinRange = function (start, end) {
+ // TODO: use a range util function?
+ return !start.isBefore(this.start) && !end.isAfter(this.end);
+ };
+ // Requesting and Purging
+ // -----------------------------------------------------------------------------------------------------------------
+ EventPeriod.prototype.requestSources = function (sources) {
+ this.freeze();
+ for (var i = 0; i < sources.length; i++) {
+ this.requestSource(sources[i]);
+ }
+ this.thaw();
+ };
+ EventPeriod.prototype.requestSource = function (source) {
+ var _this = this;
+ var request = { source: source, status: 'pending', eventDefs: null };
+ this.requestsByUid[source.uid] = request;
+ this.pendingCnt += 1;
+ source.fetch(this.start, this.end, this.timezone).then(function (eventDefs) {
+ if (request.status !== 'cancelled') {
+ request.status = 'completed';
+ request.eventDefs = eventDefs;
+ _this.addEventDefs(eventDefs);
+ _this.pendingCnt--;
+ _this.tryRelease();
+ }
+ }, function () {
+ if (request.status !== 'cancelled') {
+ request.status = 'failed';
+ _this.pendingCnt--;
+ _this.tryRelease();
+ }
+ });
+ };
+ EventPeriod.prototype.purgeSource = function (source) {
+ var request = this.requestsByUid[source.uid];
+ if (request) {
+ delete this.requestsByUid[source.uid];
+ if (request.status === 'pending') {
+ request.status = 'cancelled';
+ this.pendingCnt--;
+ this.tryRelease();
+ }
+ else if (request.status === 'completed') {
+ request.eventDefs.forEach(this.removeEventDef.bind(this));
+ }
+ }
+ };
+ EventPeriod.prototype.purgeAllSources = function () {
+ var requestsByUid = this.requestsByUid;
+ var uid;
+ var request;
+ var completedCnt = 0;
+ for (uid in requestsByUid) {
+ request = requestsByUid[uid];
+ if (request.status === 'pending') {
+ request.status = 'cancelled';
+ }
+ else if (request.status === 'completed') {
+ completedCnt++;
+ }
+ }
+ this.requestsByUid = {};
+ this.pendingCnt = 0;
+ if (completedCnt) {
+ this.removeAllEventDefs(); // might release
+ }
+ };
+ // Event Definitions
+ // -----------------------------------------------------------------------------------------------------------------
+ EventPeriod.prototype.getEventDefByUid = function (eventDefUid) {
+ return this.eventDefsByUid[eventDefUid];
+ };
+ EventPeriod.prototype.getEventDefsById = function (eventDefId) {
+ var a = this.eventDefsById[eventDefId];
+ if (a) {
+ return a.slice(); // clone
+ }
+ return [];
+ };
+ EventPeriod.prototype.addEventDefs = function (eventDefs) {
+ for (var i = 0; i < eventDefs.length; i++) {
+ this.addEventDef(eventDefs[i]);
+ }
+ };
+ EventPeriod.prototype.addEventDef = function (eventDef) {
+ var eventDefsById = this.eventDefsById;
+ var eventDefId = eventDef.id;
+ var eventDefs = eventDefsById[eventDefId] || (eventDefsById[eventDefId] = []);
+ var eventInstances = eventDef.buildInstances(this.unzonedRange);
+ var i;
+ eventDefs.push(eventDef);
+ this.eventDefsByUid[eventDef.uid] = eventDef;
+ for (i = 0; i < eventInstances.length; i++) {
+ this.addEventInstance(eventInstances[i], eventDefId);
+ }
+ };
+ EventPeriod.prototype.removeEventDefsById = function (eventDefId) {
+ var _this = this;
+ this.getEventDefsById(eventDefId).forEach(function (eventDef) {
+ _this.removeEventDef(eventDef);
+ });
+ };
+ EventPeriod.prototype.removeAllEventDefs = function () {
+ var isEmpty = $.isEmptyObject(this.eventDefsByUid);
+ this.eventDefsByUid = {};
+ this.eventDefsById = {};
+ this.eventInstanceGroupsById = {};
+ if (!isEmpty) {
+ this.tryRelease();
+ }
+ };
+ EventPeriod.prototype.removeEventDef = function (eventDef) {
+ var eventDefsById = this.eventDefsById;
+ var eventDefs = eventDefsById[eventDef.id];
+ delete this.eventDefsByUid[eventDef.uid];
+ if (eventDefs) {
+ util_1.removeExact(eventDefs, eventDef);
+ if (!eventDefs.length) {
+ delete eventDefsById[eventDef.id];
+ }
+ this.removeEventInstancesForDef(eventDef);
+ }
+ };
+ // Event Instances
+ // -----------------------------------------------------------------------------------------------------------------
+ EventPeriod.prototype.getEventInstances = function () {
+ var eventInstanceGroupsById = this.eventInstanceGroupsById;
+ var eventInstances = [];
+ var id;
+ for (id in eventInstanceGroupsById) {
+ eventInstances.push.apply(eventInstances, // append
+ eventInstanceGroupsById[id].eventInstances);
+ }
+ return eventInstances;
+ };
+ EventPeriod.prototype.getEventInstancesWithId = function (eventDefId) {
+ var eventInstanceGroup = this.eventInstanceGroupsById[eventDefId];
+ if (eventInstanceGroup) {
+ return eventInstanceGroup.eventInstances.slice(); // clone
+ }
+ return [];
+ };
+ EventPeriod.prototype.getEventInstancesWithoutId = function (eventDefId) {
+ var eventInstanceGroupsById = this.eventInstanceGroupsById;
+ var matchingInstances = [];
+ var id;
+ for (id in eventInstanceGroupsById) {
+ if (id !== eventDefId) {
+ matchingInstances.push.apply(matchingInstances, // append
+ eventInstanceGroupsById[id].eventInstances);
+ }
+ }
+ return matchingInstances;
+ };
+ EventPeriod.prototype.addEventInstance = function (eventInstance, eventDefId) {
+ var eventInstanceGroupsById = this.eventInstanceGroupsById;
+ var eventInstanceGroup = eventInstanceGroupsById[eventDefId] ||
+ (eventInstanceGroupsById[eventDefId] = new EventInstanceGroup_1.default());
+ eventInstanceGroup.eventInstances.push(eventInstance);
+ this.tryRelease();
+ };
+ EventPeriod.prototype.removeEventInstancesForDef = function (eventDef) {
+ var eventInstanceGroupsById = this.eventInstanceGroupsById;
+ var eventInstanceGroup = eventInstanceGroupsById[eventDef.id];
+ var removeCnt;
+ if (eventInstanceGroup) {
+ removeCnt = util_1.removeMatching(eventInstanceGroup.eventInstances, function (currentEventInstance) {
+ return currentEventInstance.def === eventDef;
+ });
+ if (!eventInstanceGroup.eventInstances.length) {
+ delete eventInstanceGroupsById[eventDef.id];
+ }
+ if (removeCnt) {
+ this.tryRelease();
+ }
+ }
+ };
+ // Releasing and Freezing
+ // -----------------------------------------------------------------------------------------------------------------
+ EventPeriod.prototype.tryRelease = function () {
+ if (!this.pendingCnt) {
+ if (!this.freezeDepth) {
+ this.release();
+ }
+ else {
+ this.stuntedReleaseCnt++;
+ }
+ }
+ };
+ EventPeriod.prototype.release = function () {
+ this.releaseCnt++;
+ this.trigger('release', this.eventInstanceGroupsById);
+ };
+ EventPeriod.prototype.whenReleased = function () {
+ var _this = this;
+ if (this.releaseCnt) {
+ return Promise_1.default.resolve(this.eventInstanceGroupsById);
+ }
+ else {
+ return Promise_1.default.construct(function (onResolve) {
+ _this.one('release', onResolve);
+ });
+ }
+ };
+ EventPeriod.prototype.freeze = function () {
+ if (!(this.freezeDepth++)) {
+ this.stuntedReleaseCnt = 0;
+ }
+ };
+ EventPeriod.prototype.thaw = function () {
+ if (!(--this.freezeDepth) && this.stuntedReleaseCnt && !this.pendingCnt) {
+ this.release();
+ }
+ };
+ return EventPeriod;
+}());
+exports.default = EventPeriod;
+EmitterMixin_1.default.mixInto(EventPeriod);
+
+
+/***/ }),
+/* 244 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var $ = __webpack_require__(3);
+var util_1 = __webpack_require__(4);
+var ListenerMixin_1 = __webpack_require__(7);
+/* Creates a clone of an element and lets it track the mouse as it moves
+----------------------------------------------------------------------------------------------------------------------*/
+var MouseFollower = /** @class */ (function () {
+ function MouseFollower(sourceEl, options) {
+ this.isFollowing = false;
+ this.isHidden = false;
+ this.isAnimating = false; // doing the revert animation?
+ this.options = options = options || {};
+ this.sourceEl = sourceEl;
+ this.parentEl = options.parentEl ? $(options.parentEl) : sourceEl.parent(); // default to sourceEl's parent
+ }
+ // Causes the element to start following the mouse
+ MouseFollower.prototype.start = function (ev) {
+ if (!this.isFollowing) {
+ this.isFollowing = true;
+ this.y0 = util_1.getEvY(ev);
+ this.x0 = util_1.getEvX(ev);
+ this.topDelta = 0;
+ this.leftDelta = 0;
+ if (!this.isHidden) {
+ this.updatePosition();
+ }
+ if (util_1.getEvIsTouch(ev)) {
+ this.listenTo($(document), 'touchmove', this.handleMove);
+ }
+ else {
+ this.listenTo($(document), 'mousemove', this.handleMove);
+ }
+ }
+ };
+ // Causes the element to stop following the mouse. If shouldRevert is true, will animate back to original position.
+ // `callback` gets invoked when the animation is complete. If no animation, it is invoked immediately.
+ MouseFollower.prototype.stop = function (shouldRevert, callback) {
+ var _this = this;
+ var revertDuration = this.options.revertDuration;
+ var complete = function () {
+ _this.isAnimating = false;
+ _this.removeElement();
+ _this.top0 = _this.left0 = null; // reset state for future updatePosition calls
+ if (callback) {
+ callback();
+ }
+ };
+ if (this.isFollowing && !this.isAnimating) {
+ this.isFollowing = false;
+ this.stopListeningTo($(document));
+ if (shouldRevert && revertDuration && !this.isHidden) {
+ this.isAnimating = true;
+ this.el.animate({
+ top: this.top0,
+ left: this.left0
+ }, {
+ duration: revertDuration,
+ complete: complete
+ });
+ }
+ else {
+ complete();
+ }
+ }
+ };
+ // Gets the tracking element. Create it if necessary
+ MouseFollower.prototype.getEl = function () {
+ var el = this.el;
+ if (!el) {
+ el = this.el = this.sourceEl.clone()
+ .addClass(this.options.additionalClass || '')
+ .css({
+ position: 'absolute',
+ visibility: '',
+ display: this.isHidden ? 'none' : '',
+ margin: 0,
+ right: 'auto',
+ bottom: 'auto',
+ width: this.sourceEl.width(),
+ height: this.sourceEl.height(),
+ opacity: this.options.opacity || '',
+ zIndex: this.options.zIndex
+ });
+ // we don't want long taps or any mouse interaction causing selection/menus.
+ // would use preventSelection(), but that prevents selectstart, causing problems.
+ el.addClass('fc-unselectable');
+ el.appendTo(this.parentEl);
+ }
+ return el;
+ };
+ // Removes the tracking element if it has already been created
+ MouseFollower.prototype.removeElement = function () {
+ if (this.el) {
+ this.el.remove();
+ this.el = null;
+ }
+ };
+ // Update the CSS position of the tracking element
+ MouseFollower.prototype.updatePosition = function () {
+ var sourceOffset;
+ var origin;
+ this.getEl(); // ensure this.el
+ // make sure origin info was computed
+ if (this.top0 == null) {
+ sourceOffset = this.sourceEl.offset();
+ origin = this.el.offsetParent().offset();
+ this.top0 = sourceOffset.top - origin.top;
+ this.left0 = sourceOffset.left - origin.left;
+ }
+ this.el.css({
+ top: this.top0 + this.topDelta,
+ left: this.left0 + this.leftDelta
+ });
+ };
+ // Gets called when the user moves the mouse
+ MouseFollower.prototype.handleMove = function (ev) {
+ this.topDelta = util_1.getEvY(ev) - this.y0;
+ this.leftDelta = util_1.getEvX(ev) - this.x0;
+ if (!this.isHidden) {
+ this.updatePosition();
+ }
+ };
+ // Temporarily makes the tracking element invisible. Can be called before following starts
+ MouseFollower.prototype.hide = function () {
+ if (!this.isHidden) {
+ this.isHidden = true;
+ if (this.el) {
+ this.el.hide();
+ }
+ }
+ };
+ // Show the tracking element after it has been temporarily hidden
+ MouseFollower.prototype.show = function () {
+ if (this.isHidden) {
+ this.isHidden = false;
+ this.updatePosition();
+ this.getEl().show();
+ }
+ };
+ return MouseFollower;
+}());
+exports.default = MouseFollower;
+ListenerMixin_1.default.mixInto(MouseFollower);
+
+
+/***/ }),
+/* 245 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var HitDragListener_1 = __webpack_require__(23);
+var Interaction_1 = __webpack_require__(15);
+var DateClicking = /** @class */ (function (_super) {
+ tslib_1.__extends(DateClicking, _super);
+ /*
+ component must implement:
+ - bindDateHandlerToEl
+ - getSafeHitFootprint
+ - getHitEl
+ */
+ function DateClicking(component) {
+ var _this = _super.call(this, component) || this;
+ _this.dragListener = _this.buildDragListener();
+ return _this;
+ }
+ DateClicking.prototype.end = function () {
+ this.dragListener.endInteraction();
+ };
+ DateClicking.prototype.bindToEl = function (el) {
+ var component = this.component;
+ var dragListener = this.dragListener;
+ component.bindDateHandlerToEl(el, 'mousedown', function (ev) {
+ if (!component.shouldIgnoreMouse()) {
+ dragListener.startInteraction(ev);
+ }
+ });
+ component.bindDateHandlerToEl(el, 'touchstart', function (ev) {
+ if (!component.shouldIgnoreTouch()) {
+ dragListener.startInteraction(ev);
+ }
+ });
+ };
+ // Creates a listener that tracks the user's drag across day elements, for day clicking.
+ DateClicking.prototype.buildDragListener = function () {
+ var _this = this;
+ var component = this.component;
+ var dayClickHit; // null if invalid dayClick
+ var dragListener = new HitDragListener_1.default(component, {
+ scroll: this.opt('dragScroll'),
+ interactionStart: function () {
+ dayClickHit = dragListener.origHit;
+ },
+ hitOver: function (hit, isOrig, origHit) {
+ // if user dragged to another cell at any point, it can no longer be a dayClick
+ if (!isOrig) {
+ dayClickHit = null;
+ }
+ },
+ hitOut: function () {
+ dayClickHit = null;
+ },
+ interactionEnd: function (ev, isCancelled) {
+ var componentFootprint;
+ if (!isCancelled && dayClickHit) {
+ componentFootprint = component.getSafeHitFootprint(dayClickHit);
+ if (componentFootprint) {
+ _this.view.triggerDayClick(componentFootprint, component.getHitEl(dayClickHit), ev);
+ }
+ }
+ }
+ });
+ // because dragListener won't be called with any time delay, "dragging" will begin immediately,
+ // which will kill any touchmoving/scrolling. Prevent this.
+ dragListener.shouldCancelTouchScroll = false;
+ dragListener.scrollAlwaysKills = true;
+ return dragListener;
+ };
+ return DateClicking;
+}(Interaction_1.default));
+exports.default = DateClicking;
+
+
+/***/ }),
+/* 246 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var util_1 = __webpack_require__(4);
+var EventRenderer_1 = __webpack_require__(42);
+/*
+Only handles foreground segs.
+Does not own rendering. Use for low-level util methods by TimeGrid.
+*/
+var TimeGridEventRenderer = /** @class */ (function (_super) {
+ tslib_1.__extends(TimeGridEventRenderer, _super);
+ function TimeGridEventRenderer(timeGrid, fillRenderer) {
+ var _this = _super.call(this, timeGrid, fillRenderer) || this;
+ _this.timeGrid = timeGrid;
+ return _this;
+ }
+ TimeGridEventRenderer.prototype.renderFgSegs = function (segs) {
+ this.renderFgSegsIntoContainers(segs, this.timeGrid.fgContainerEls);
+ };
+ // Given an array of foreground segments, render a DOM element for each, computes position,
+ // and attaches to the column inner-container elements.
+ TimeGridEventRenderer.prototype.renderFgSegsIntoContainers = function (segs, containerEls) {
+ var segsByCol;
+ var col;
+ segsByCol = this.timeGrid.groupSegsByCol(segs);
+ for (col = 0; col < this.timeGrid.colCnt; col++) {
+ this.updateFgSegCoords(segsByCol[col]);
+ }
+ this.timeGrid.attachSegsByCol(segsByCol, containerEls);
+ };
+ TimeGridEventRenderer.prototype.unrenderFgSegs = function () {
+ if (this.fgSegs) {
+ this.fgSegs.forEach(function (seg) {
+ seg.el.remove();
+ });
+ }
+ };
+ // Computes a default event time formatting string if `timeFormat` is not explicitly defined
+ TimeGridEventRenderer.prototype.computeEventTimeFormat = function () {
+ return this.opt('noMeridiemTimeFormat'); // like "6:30" (no AM/PM)
+ };
+ // Computes a default `displayEventEnd` value if one is not expliclty defined
+ TimeGridEventRenderer.prototype.computeDisplayEventEnd = function () {
+ return true;
+ };
+ // Renders the HTML for a single event segment's default rendering
+ TimeGridEventRenderer.prototype.fgSegHtml = function (seg, disableResizing) {
+ var view = this.view;
+ var calendar = view.calendar;
+ var componentFootprint = seg.footprint.componentFootprint;
+ var isAllDay = componentFootprint.isAllDay;
+ var eventDef = seg.footprint.eventDef;
+ var isDraggable = view.isEventDefDraggable(eventDef);
+ var isResizableFromStart = !disableResizing && seg.isStart && view.isEventDefResizableFromStart(eventDef);
+ var isResizableFromEnd = !disableResizing && seg.isEnd && view.isEventDefResizableFromEnd(eventDef);
+ var classes = this.getSegClasses(seg, isDraggable, isResizableFromStart || isResizableFromEnd);
+ var skinCss = util_1.cssToStr(this.getSkinCss(eventDef));
+ var timeText;
+ var fullTimeText; // more verbose time text. for the print stylesheet
+ var startTimeText; // just the start time text
+ classes.unshift('fc-time-grid-event', 'fc-v-event');
+ // if the event appears to span more than one day...
+ if (view.isMultiDayRange(componentFootprint.unzonedRange)) {
+ // Don't display time text on segments that run entirely through a day.
+ // That would appear as midnight-midnight and would look dumb.
+ // Otherwise, display the time text for the *segment's* times (like 6pm-midnight or midnight-10am)
+ if (seg.isStart || seg.isEnd) {
+ var zonedStart = calendar.msToMoment(seg.startMs);
+ var zonedEnd = calendar.msToMoment(seg.endMs);
+ timeText = this._getTimeText(zonedStart, zonedEnd, isAllDay);
+ fullTimeText = this._getTimeText(zonedStart, zonedEnd, isAllDay, 'LT');
+ startTimeText = this._getTimeText(zonedStart, zonedEnd, isAllDay, null, false); // displayEnd=false
+ }
+ }
+ else {
+ // Display the normal time text for the *event's* times
+ timeText = this.getTimeText(seg.footprint);
+ fullTimeText = this.getTimeText(seg.footprint, 'LT');
+ startTimeText = this.getTimeText(seg.footprint, null, false); // displayEnd=false
+ }
+ return '' +
+ '' +
+ (timeText ?
+ ' ' +
+ '' + util_1.htmlEscape(timeText) + '' +
+ ' ' :
+ '') +
+ (eventDef.title ?
+ ' ' +
+ util_1.htmlEscape(eventDef.title) +
+ ' ' :
+ '') +
+ ' elements of the level+col matrix
+ var loneCellMatrix = []; // lookup for | elements that only take up a single column
+ var i;
+ var levelSegs;
+ var col;
+ var tr;
+ var j;
+ var seg;
+ var td;
+ // populates empty cells from the current column (`col`) to `endCol`
+ function emptyCellsUntil(endCol) {
+ while (col < endCol) {
+ // try to grab a cell from the level above and extend its rowspan. otherwise, create a fresh cell
+ td = (loneCellMatrix[i - 1] || [])[col];
+ if (td) {
+ td.attr('rowspan', parseInt(td.attr('rowspan') || 1, 10) + 1);
+ }
+ else {
+ td = $(' | | ');
+ tr.append(td);
+ }
+ cellMatrix[i][col] = td;
+ loneCellMatrix[i][col] = td;
+ col++;
+ }
+ }
+ for (i = 0; i < levelCnt; i++) {
+ levelSegs = segLevels[i];
+ col = 0;
+ tr = $('|
');
+ segMatrix.push([]);
+ cellMatrix.push([]);
+ loneCellMatrix.push([]);
+ // levelCnt might be 1 even though there are no actual levels. protect against this.
+ // this single empty row is useful for styling.
+ if (levelSegs) {
+ for (j = 0; j < levelSegs.length; j++) {
+ seg = levelSegs[j];
+ emptyCellsUntil(seg.leftCol);
+ // create a container that occupies or more columns. append the event element.
+ td = $(' | ').append(seg.el);
+ if (seg.leftCol !== seg.rightCol) {
+ td.attr('colspan', seg.rightCol - seg.leftCol + 1);
+ }
+ else {
+ loneCellMatrix[i][col] = td;
+ }
+ while (col <= seg.rightCol) {
+ cellMatrix[i][col] = td;
+ segMatrix[i][col] = seg;
+ col++;
+ }
+ tr.append(td);
+ }
+ }
+ emptyCellsUntil(colCnt); // finish off the row
+ this.dayGrid.bookendCells(tr);
+ tbody.append(tr);
+ }
+ return {
+ row: row,
+ tbodyEl: tbody,
+ cellMatrix: cellMatrix,
+ segMatrix: segMatrix,
+ segLevels: segLevels,
+ segs: rowSegs
+ };
+ };
+ // Stacks a flat array of segments, which are all assumed to be in the same row, into subarrays of vertical levels.
+ // NOTE: modifies segs
+ DayGridEventRenderer.prototype.buildSegLevels = function (segs) {
+ var levels = [];
+ var i;
+ var seg;
+ var j;
+ // Give preference to elements with certain criteria, so they have
+ // a chance to be closer to the top.
+ this.sortEventSegs(segs);
+ for (i = 0; i < segs.length; i++) {
+ seg = segs[i];
+ // loop through levels, starting with the topmost, until the segment doesn't collide with other segments
+ for (j = 0; j < levels.length; j++) {
+ if (!isDaySegCollision(seg, levels[j])) {
+ break;
+ }
+ }
+ // `j` now holds the desired subrow index
+ seg.level = j;
+ // create new level array if needed and append segment
+ (levels[j] || (levels[j] = [])).push(seg);
+ }
+ // order segments left-to-right. very important if calendar is RTL
+ for (j = 0; j < levels.length; j++) {
+ levels[j].sort(compareDaySegCols);
+ }
+ return levels;
+ };
+ // Given a flat array of segments, return an array of sub-arrays, grouped by each segment's row
+ DayGridEventRenderer.prototype.groupSegRows = function (segs) {
+ var segRows = [];
+ var i;
+ for (i = 0; i < this.dayGrid.rowCnt; i++) {
+ segRows.push([]);
+ }
+ for (i = 0; i < segs.length; i++) {
+ segRows[segs[i].row].push(segs[i]);
+ }
+ return segRows;
+ };
+ // Computes a default event time formatting string if `timeFormat` is not explicitly defined
+ DayGridEventRenderer.prototype.computeEventTimeFormat = function () {
+ return this.opt('extraSmallTimeFormat'); // like "6p" or "6:30p"
+ };
+ // Computes a default `displayEventEnd` value if one is not expliclty defined
+ DayGridEventRenderer.prototype.computeDisplayEventEnd = function () {
+ return this.dayGrid.colCnt === 1; // we'll likely have space if there's only one day
+ };
+ // Builds the HTML to be used for the default element for an individual segment
+ DayGridEventRenderer.prototype.fgSegHtml = function (seg, disableResizing) {
+ var view = this.view;
+ var eventDef = seg.footprint.eventDef;
+ var isAllDay = seg.footprint.componentFootprint.isAllDay;
+ var isDraggable = view.isEventDefDraggable(eventDef);
+ var isResizableFromStart = !disableResizing && isAllDay &&
+ seg.isStart && view.isEventDefResizableFromStart(eventDef);
+ var isResizableFromEnd = !disableResizing && isAllDay &&
+ seg.isEnd && view.isEventDefResizableFromEnd(eventDef);
+ var classes = this.getSegClasses(seg, isDraggable, isResizableFromStart || isResizableFromEnd);
+ var skinCss = util_1.cssToStr(this.getSkinCss(eventDef));
+ var timeHtml = '';
+ var timeText;
+ var titleHtml;
+ classes.unshift('fc-day-grid-event', 'fc-h-event');
+ // Only display a timed events time if it is the starting segment
+ if (seg.isStart) {
+ timeText = this.getTimeText(seg.footprint);
+ if (timeText) {
+ timeHtml = '' + util_1.htmlEscape(timeText) + '';
+ }
+ }
+ titleHtml =
+ '' +
+ (util_1.htmlEscape(eventDef.title || '') || ' ') + // we always want one line of height
+ '';
+ return '' +
+ '' +
+ (this.dayGrid.isRTL ?
+ titleHtml + ' ' + timeHtml : // put a natural space in between
+ timeHtml + ' ' + titleHtml //
+ ) +
+ ' ' +
+ (isResizableFromStart ?
+ '' :
+ '') +
+ (isResizableFromEnd ?
+ '' :
+ '') +
+ '';
+ };
+ return DayGridEventRenderer;
+}(EventRenderer_1.default));
+exports.default = DayGridEventRenderer;
+// Computes whether two segments' columns collide. They are assumed to be in the same row.
+function isDaySegCollision(seg, otherSegs) {
+ var i;
+ var otherSeg;
+ for (i = 0; i < otherSegs.length; i++) {
+ otherSeg = otherSegs[i];
+ if (otherSeg.leftCol <= seg.rightCol &&
+ otherSeg.rightCol >= seg.leftCol) {
+ return true;
+ }
+ }
+ return false;
+}
+// A cmp function for determining the leftmost event
+function compareDaySegCols(a, b) {
+ return a.leftCol - b.leftCol;
+}
+
+
+/***/ }),
+/* 251 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var HelperRenderer_1 = __webpack_require__(58);
+var DayGridHelperRenderer = /** @class */ (function (_super) {
+ tslib_1.__extends(DayGridHelperRenderer, _super);
+ function DayGridHelperRenderer() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ // Renders a mock "helper" event. `sourceSeg` is the associated internal segment object. It can be null.
+ DayGridHelperRenderer.prototype.renderSegs = function (segs, sourceSeg) {
+ var helperNodes = [];
+ var rowStructs;
+ // TODO: not good to call eventRenderer this way
+ rowStructs = this.eventRenderer.renderSegRows(segs);
+ // inject each new event skeleton into each associated row
+ this.component.rowEls.each(function (row, rowNode) {
+ var rowEl = $(rowNode); // the .fc-row
+ var skeletonEl = $(''); // will be absolutely positioned
+ var skeletonTopEl;
+ var skeletonTop;
+ // If there is an original segment, match the top position. Otherwise, put it at the row's top level
+ if (sourceSeg && sourceSeg.row === row) {
+ skeletonTop = sourceSeg.el.position().top;
+ }
+ else {
+ skeletonTopEl = rowEl.find('.fc-content-skeleton tbody');
+ if (!skeletonTopEl.length) {
+ skeletonTopEl = rowEl.find('.fc-content-skeleton table');
+ }
+ skeletonTop = skeletonTopEl.position().top;
+ }
+ skeletonEl.css('top', skeletonTop)
+ .find('table')
+ .append(rowStructs[row].tbodyEl);
+ rowEl.append(skeletonEl);
+ helperNodes.push(skeletonEl[0]);
+ });
+ return $(helperNodes); // must return the elements rendered
+ };
+ return DayGridHelperRenderer;
+}(HelperRenderer_1.default));
+exports.default = DayGridHelperRenderer;
+
+
+/***/ }),
+/* 252 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var FillRenderer_1 = __webpack_require__(57);
+var DayGridFillRenderer = /** @class */ (function (_super) {
+ tslib_1.__extends(DayGridFillRenderer, _super);
+ function DayGridFillRenderer() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.fillSegTag = 'td'; // override the default tag name
+ return _this;
+ }
+ DayGridFillRenderer.prototype.attachSegEls = function (type, segs) {
+ var nodes = [];
+ var i;
+ var seg;
+ var skeletonEl;
+ for (i = 0; i < segs.length; i++) {
+ seg = segs[i];
+ skeletonEl = this.renderFillRow(type, seg);
+ this.component.rowEls.eq(seg.row).append(skeletonEl);
+ nodes.push(skeletonEl[0]);
+ }
+ return nodes;
+ };
+ // Generates the HTML needed for one row of a fill. Requires the seg's el to be rendered.
+ DayGridFillRenderer.prototype.renderFillRow = function (type, seg) {
+ var colCnt = this.component.colCnt;
+ var startCol = seg.leftCol;
+ var endCol = seg.rightCol + 1;
+ var className;
+ var skeletonEl;
+ var trEl;
+ if (type === 'businessHours') {
+ className = 'bgevent';
+ }
+ else {
+ className = type.toLowerCase();
+ }
+ skeletonEl = $('');
+ trEl = skeletonEl.find('tr');
+ if (startCol > 0) {
+ trEl.append(' | ');
+ }
+ trEl.append(seg.el.attr('colspan', endCol - startCol));
+ if (endCol < colCnt) {
+ trEl.append(' | ');
+ }
+ this.component.bookendCells(trEl);
+ return skeletonEl;
+ };
+ return DayGridFillRenderer;
+}(FillRenderer_1.default));
+exports.default = DayGridFillRenderer;
+
+
+/***/ }),
+/* 253 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var BasicViewDateProfileGenerator_1 = __webpack_require__(228);
+var UnzonedRange_1 = __webpack_require__(5);
+var MonthViewDateProfileGenerator = /** @class */ (function (_super) {
+ tslib_1.__extends(MonthViewDateProfileGenerator, _super);
+ function MonthViewDateProfileGenerator() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ // Computes the date range that will be rendered.
+ MonthViewDateProfileGenerator.prototype.buildRenderRange = function (currentUnzonedRange, currentRangeUnit, isRangeAllDay) {
+ var renderUnzonedRange = _super.prototype.buildRenderRange.call(this, currentUnzonedRange, currentRangeUnit, isRangeAllDay);
+ var start = this.msToUtcMoment(renderUnzonedRange.startMs, isRangeAllDay);
+ var end = this.msToUtcMoment(renderUnzonedRange.endMs, isRangeAllDay);
+ var rowCnt;
+ // ensure 6 weeks
+ if (this.opt('fixedWeekCount')) {
+ rowCnt = Math.ceil(// could be partial weeks due to hiddenDays
+ end.diff(start, 'weeks', true) // dontRound=true
+ );
+ end.add(6 - rowCnt, 'weeks');
+ }
+ return new UnzonedRange_1.default(start, end);
+ };
+ return MonthViewDateProfileGenerator;
+}(BasicViewDateProfileGenerator_1.default));
+exports.default = MonthViewDateProfileGenerator;
+
+
+/***/ }),
+/* 254 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var util_1 = __webpack_require__(4);
+var EventRenderer_1 = __webpack_require__(42);
+var ListEventRenderer = /** @class */ (function (_super) {
+ tslib_1.__extends(ListEventRenderer, _super);
+ function ListEventRenderer() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ ListEventRenderer.prototype.renderFgSegs = function (segs) {
+ if (!segs.length) {
+ this.component.renderEmptyMessage();
+ }
+ else {
+ this.component.renderSegList(segs);
+ }
+ };
+ // generates the HTML for a single event row
+ ListEventRenderer.prototype.fgSegHtml = function (seg) {
+ var view = this.view;
+ var calendar = view.calendar;
+ var theme = calendar.theme;
+ var eventFootprint = seg.footprint;
+ var eventDef = eventFootprint.eventDef;
+ var componentFootprint = eventFootprint.componentFootprint;
+ var url = eventDef.url;
+ var classes = ['fc-list-item'].concat(this.getClasses(eventDef));
+ var bgColor = this.getBgColor(eventDef);
+ var timeHtml;
+ if (componentFootprint.isAllDay) {
+ timeHtml = view.getAllDayHtml();
+ }
+ else if (view.isMultiDayRange(componentFootprint.unzonedRange)) {
+ if (seg.isStart || seg.isEnd) {
+ timeHtml = util_1.htmlEscape(this._getTimeText(calendar.msToMoment(seg.startMs), calendar.msToMoment(seg.endMs), componentFootprint.isAllDay));
+ }
+ else {
+ timeHtml = view.getAllDayHtml();
+ }
+ }
+ else {
+ // Display the normal time text for the *event's* times
+ timeHtml = util_1.htmlEscape(this.getTimeText(eventFootprint));
+ }
+ if (url) {
+ classes.push('fc-has-url');
+ }
+ return '' +
+ (this.displayEventTime ?
+ '| ' +
+ (timeHtml || '') +
+ ' | ' :
+ '') +
+ '' +
+ '' +
+ ' | ' +
+ '' +
+ '' +
+ util_1.htmlEscape(eventDef.title || '') +
+ '' +
+ ' | ' +
+ ' ';
+ };
+ // like "4:00am"
+ ListEventRenderer.prototype.computeEventTimeFormat = function () {
+ return this.opt('mediumTimeFormat');
+ };
+ return ListEventRenderer;
+}(EventRenderer_1.default));
+exports.default = ListEventRenderer;
+
+
+/***/ }),
+/* 255 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var $ = __webpack_require__(3);
+var EventPointing_1 = __webpack_require__(59);
+var ListEventPointing = /** @class */ (function (_super) {
+ tslib_1.__extends(ListEventPointing, _super);
+ function ListEventPointing() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ // for events with a url, the whole should be clickable,
+ // but it's impossible to wrap with an tag. simulate this.
+ ListEventPointing.prototype.handleClick = function (seg, ev) {
+ var url;
+ _super.prototype.handleClick.call(this, seg, ev); // might prevent the default action
+ // not clicking on or within an with an href
+ if (!$(ev.target).closest('a[href]').length) {
+ url = seg.footprint.eventDef.url;
+ if (url && !ev.isDefaultPrevented()) {
+ window.location.href = url; // simulate link click
+ }
+ }
+ };
+ return ListEventPointing;
+}(EventPointing_1.default));
+exports.default = ListEventPointing;
+
+
+/***/ }),
+/* 256 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var EventSourceParser_1 = __webpack_require__(38);
+var ArrayEventSource_1 = __webpack_require__(52);
+var FuncEventSource_1 = __webpack_require__(215);
+var JsonFeedEventSource_1 = __webpack_require__(216);
+EventSourceParser_1.default.registerClass(ArrayEventSource_1.default);
+EventSourceParser_1.default.registerClass(FuncEventSource_1.default);
+EventSourceParser_1.default.registerClass(JsonFeedEventSource_1.default);
+
+
+/***/ }),
+/* 257 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var ThemeRegistry_1 = __webpack_require__(51);
+var StandardTheme_1 = __webpack_require__(213);
+var JqueryUiTheme_1 = __webpack_require__(214);
+var Bootstrap3Theme_1 = __webpack_require__(258);
+var Bootstrap4Theme_1 = __webpack_require__(259);
+ThemeRegistry_1.defineThemeSystem('standard', StandardTheme_1.default);
+ThemeRegistry_1.defineThemeSystem('jquery-ui', JqueryUiTheme_1.default);
+ThemeRegistry_1.defineThemeSystem('bootstrap3', Bootstrap3Theme_1.default);
+ThemeRegistry_1.defineThemeSystem('bootstrap4', Bootstrap4Theme_1.default);
+
+
+/***/ }),
+/* 258 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var Theme_1 = __webpack_require__(19);
+var Bootstrap3Theme = /** @class */ (function (_super) {
+ tslib_1.__extends(Bootstrap3Theme, _super);
+ function Bootstrap3Theme() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ return Bootstrap3Theme;
+}(Theme_1.default));
+exports.default = Bootstrap3Theme;
+Bootstrap3Theme.prototype.classes = {
+ widget: 'fc-bootstrap3',
+ tableGrid: 'table-bordered',
+ tableList: 'table',
+ tableListHeading: 'active',
+ buttonGroup: 'btn-group',
+ button: 'btn btn-default',
+ stateActive: 'active',
+ stateDisabled: 'disabled',
+ today: 'alert alert-info',
+ popover: 'panel panel-default',
+ popoverHeader: 'panel-heading',
+ popoverContent: 'panel-body',
+ // day grid
+ // for left/right border color when border is inset from edges (all-day in agenda view)
+ // avoid `panel` class b/c don't want margins/radius. only border color.
+ headerRow: 'panel-default',
+ dayRow: 'panel-default',
+ // list view
+ listView: 'panel panel-default'
+};
+Bootstrap3Theme.prototype.baseIconClass = 'glyphicon';
+Bootstrap3Theme.prototype.iconClasses = {
+ close: 'glyphicon-remove',
+ prev: 'glyphicon-chevron-left',
+ next: 'glyphicon-chevron-right',
+ prevYear: 'glyphicon-backward',
+ nextYear: 'glyphicon-forward'
+};
+Bootstrap3Theme.prototype.iconOverrideOption = 'bootstrapGlyphicons';
+Bootstrap3Theme.prototype.iconOverrideCustomButtonOption = 'bootstrapGlyphicon';
+Bootstrap3Theme.prototype.iconOverridePrefix = 'glyphicon-';
+
+
+/***/ }),
+/* 259 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(2);
+var Theme_1 = __webpack_require__(19);
+var Bootstrap4Theme = /** @class */ (function (_super) {
+ tslib_1.__extends(Bootstrap4Theme, _super);
+ function Bootstrap4Theme() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ return Bootstrap4Theme;
+}(Theme_1.default));
+exports.default = Bootstrap4Theme;
+Bootstrap4Theme.prototype.classes = {
+ widget: 'fc-bootstrap4',
+ tableGrid: 'table-bordered',
+ tableList: 'table',
+ tableListHeading: 'table-active',
+ buttonGroup: 'btn-group',
+ button: 'btn btn-primary',
+ stateActive: 'active',
+ stateDisabled: 'disabled',
+ today: 'alert alert-info',
+ popover: 'card card-primary',
+ popoverHeader: 'card-header',
+ popoverContent: 'card-body',
+ // day grid
+ // for left/right border color when border is inset from edges (all-day in agenda view)
+ // avoid `table` class b/c don't want margins/padding/structure. only border color.
+ headerRow: 'table-bordered',
+ dayRow: 'table-bordered',
+ // list view
+ listView: 'card card-primary'
+};
+Bootstrap4Theme.prototype.baseIconClass = 'fa';
+Bootstrap4Theme.prototype.iconClasses = {
+ close: 'fa-times',
+ prev: 'fa-chevron-left',
+ next: 'fa-chevron-right',
+ prevYear: 'fa-angle-double-left',
+ nextYear: 'fa-angle-double-right'
+};
+Bootstrap4Theme.prototype.iconOverrideOption = 'bootstrapFontAwesome';
+Bootstrap4Theme.prototype.iconOverrideCustomButtonOption = 'bootstrapFontAwesome';
+Bootstrap4Theme.prototype.iconOverridePrefix = 'fa-';
+
+
+/***/ }),
+/* 260 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var ViewRegistry_1 = __webpack_require__(22);
+var BasicView_1 = __webpack_require__(62);
+var MonthView_1 = __webpack_require__(229);
+ViewRegistry_1.defineView('basic', {
+ 'class': BasicView_1.default
+});
+ViewRegistry_1.defineView('basicDay', {
+ type: 'basic',
+ duration: { days: 1 }
+});
+ViewRegistry_1.defineView('basicWeek', {
+ type: 'basic',
+ duration: { weeks: 1 }
+});
+ViewRegistry_1.defineView('month', {
+ 'class': MonthView_1.default,
+ duration: { months: 1 },
+ defaults: {
+ fixedWeekCount: true
+ }
+});
+
+
+/***/ }),
+/* 261 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var ViewRegistry_1 = __webpack_require__(22);
+var AgendaView_1 = __webpack_require__(226);
+ViewRegistry_1.defineView('agenda', {
+ 'class': AgendaView_1.default,
+ defaults: {
+ allDaySlot: true,
+ slotDuration: '00:30:00',
+ slotEventOverlap: true // a bad name. confused with overlap/constraint system
+ }
+});
+ViewRegistry_1.defineView('agendaDay', {
+ type: 'agenda',
+ duration: { days: 1 }
+});
+ViewRegistry_1.defineView('agendaWeek', {
+ type: 'agenda',
+ duration: { weeks: 1 }
+});
+
+
+/***/ }),
+/* 262 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var ViewRegistry_1 = __webpack_require__(22);
+var ListView_1 = __webpack_require__(230);
+ViewRegistry_1.defineView('list', {
+ 'class': ListView_1.default,
+ buttonTextKey: 'list',
+ defaults: {
+ buttonText: 'list',
+ listDayFormat: 'LL',
+ noEventsMessage: 'No events to display'
+ }
+});
+ViewRegistry_1.defineView('listDay', {
+ type: 'list',
+ duration: { days: 1 },
+ defaults: {
+ listDayFormat: 'dddd' // day-of-week is all we need. full date is probably in header
+ }
+});
+ViewRegistry_1.defineView('listWeek', {
+ type: 'list',
+ duration: { weeks: 1 },
+ defaults: {
+ listDayFormat: 'dddd',
+ listDayAltFormat: 'LL'
+ }
+});
+ViewRegistry_1.defineView('listMonth', {
+ type: 'list',
+ duration: { month: 1 },
+ defaults: {
+ listDayAltFormat: 'dddd' // day-of-week is nice-to-have
+ }
+});
+ViewRegistry_1.defineView('listYear', {
+ type: 'list',
+ duration: { year: 1 },
+ defaults: {
+ listDayAltFormat: 'dddd' // day-of-week is nice-to-have
+ }
+});
+
+
+/***/ }),
+/* 263 */
+/***/ (function(module, exports) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+/***/ })
+/******/ ]);
+});
\ No newline at end of file
diff --git a/public/lib/fc/fullcalendar.min.css b/public/lib/fc/fullcalendar.min.css
new file mode 100644
index 0000000000..cf86d29318
--- /dev/null
+++ b/public/lib/fc/fullcalendar.min.css
@@ -0,0 +1,5 @@
+/*!
+ * FullCalendar v3.9.0
+ * Docs & License: https://fullcalendar.io/
+ * (c) 2018 Adam Shaw
+ */.fc button,.fc table,body .fc{font-size:1em}.fc-bg,.fc-row .fc-bgevent-skeleton,.fc-row .fc-highlight-skeleton{bottom:0}.fc-icon,.fc-unselectable{-webkit-touch-callout:none;-khtml-user-select:none}.fc{direction:ltr;text-align:left}.fc-rtl{text-align:right}.fc th,.fc-basic-view td.fc-week-number,.fc-icon,.fc-toolbar{text-align:center}.fc-highlight{background:#bce8f1;opacity:.3}.fc-bgevent{background:#8fdf82;opacity:.3}.fc-nonbusiness{background:#d7d7d7}.fc button{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box;margin:0;height:2.1em;padding:0 .6em;white-space:nowrap;cursor:pointer}.fc button::-moz-focus-inner{margin:0;padding:0}.fc-state-default{border:1px solid;background-color:#f5f5f5;background-image:-moz-linear-gradient(top,#fff,#e6e6e6);background-image:-webkit-gradient(linear,0 0,0 100%,from(#fff),to(#e6e6e6));background-image:-webkit-linear-gradient(top,#fff,#e6e6e6);background-image:-o-linear-gradient(top,#fff,#e6e6e6);background-image:linear-gradient(to bottom,#fff,#e6e6e6);background-repeat:repeat-x;border-color:#e6e6e6 #e6e6e6 #bfbfbf;border-color:rgba(0,0,0,.1) rgba(0,0,0,.1) rgba(0,0,0,.25);color:#333;text-shadow:0 1px 1px rgba(255,255,255,.75);box-shadow:inset 0 1px 0 rgba(255,255,255,.2),0 1px 2px rgba(0,0,0,.05)}.fc-state-default.fc-corner-left{border-top-left-radius:4px;border-bottom-left-radius:4px}.fc-state-default.fc-corner-right{border-top-right-radius:4px;border-bottom-right-radius:4px}.fc button .fc-icon{position:relative;top:-.05em;margin:0 .2em;vertical-align:middle}.fc-state-active,.fc-state-disabled,.fc-state-down,.fc-state-hover{color:#333;background-color:#e6e6e6}.fc-state-hover{color:#333;text-decoration:none;background-position:0 -15px;-webkit-transition:background-position .1s linear;-moz-transition:background-position .1s linear;-o-transition:background-position .1s linear;transition:background-position .1s linear}.fc-state-active,.fc-state-down{background-color:#ccc;background-image:none;box-shadow:inset 0 2px 4px rgba(0,0,0,.15),0 1px 2px rgba(0,0,0,.05)}.fc-state-disabled{cursor:default;background-image:none;opacity:.65;box-shadow:none}.fc-event.fc-draggable,.fc-event[href],.fc-popover .fc-header .fc-close,a[data-goto]{cursor:pointer}.fc-button-group{display:inline-block}.fc .fc-button-group>*{float:left;margin:0 0 0 -1px}.fc .fc-button-group>:first-child{margin-left:0}.fc-popover{position:absolute;box-shadow:0 2px 6px rgba(0,0,0,.15)}.fc-popover .fc-header{padding:2px 4px}.fc-popover .fc-header .fc-title{margin:0 2px}.fc-ltr .fc-popover .fc-header .fc-title,.fc-rtl .fc-popover .fc-header .fc-close{float:left}.fc-ltr .fc-popover .fc-header .fc-close,.fc-rtl .fc-popover .fc-header .fc-title{float:right}.fc-divider{border-style:solid;border-width:1px}hr.fc-divider{height:0;margin:0;padding:0 0 2px;border-width:1px 0}.fc-bg table,.fc-row .fc-bgevent-skeleton table,.fc-row .fc-highlight-skeleton table{height:100%}.fc-clear{clear:both}.fc-bg,.fc-bgevent-skeleton,.fc-helper-skeleton,.fc-highlight-skeleton{position:absolute;top:0;left:0;right:0}.fc table{width:100%;box-sizing:border-box;table-layout:fixed;border-collapse:collapse;border-spacing:0}.fc td,.fc th{border-style:solid;border-width:1px;padding:0;vertical-align:top}.fc td.fc-today{border-style:double}a[data-goto]:hover{text-decoration:underline}.fc .fc-row{border-style:solid;border-width:0}.fc-row table{border-left:0 hidden transparent;border-right:0 hidden transparent;border-bottom:0 hidden transparent}.fc-row:first-child table{border-top:0 hidden transparent}.fc-row{position:relative}.fc-row .fc-bg{z-index:1}.fc-row .fc-bgevent-skeleton td,.fc-row .fc-highlight-skeleton td{border-color:transparent}.fc-row .fc-bgevent-skeleton{z-index:2}.fc-row .fc-highlight-skeleton{z-index:3}.fc-row .fc-content-skeleton{position:relative;z-index:4;padding-bottom:2px}.fc-row .fc-helper-skeleton{z-index:5}.fc .fc-row .fc-content-skeleton table,.fc .fc-row .fc-content-skeleton td,.fc .fc-row .fc-helper-skeleton td{background:0 0;border-color:transparent}.fc-row .fc-content-skeleton td,.fc-row .fc-helper-skeleton td{border-bottom:0}.fc-row .fc-content-skeleton tbody td,.fc-row .fc-helper-skeleton tbody td{border-top:0}.fc-scroller{-webkit-overflow-scrolling:touch}.fc-icon,.fc-row.fc-rigid,.fc-time-grid-event{overflow:hidden}.fc-scroller>.fc-day-grid,.fc-scroller>.fc-time-grid{position:relative;width:100%}.fc-event{position:relative;display:block;font-size:.85em;line-height:1.3;border-radius:3px;border:1px solid #3a87ad}.fc-event,.fc-event-dot{background-color:#3a87ad}.fc-event,.fc-event:hover{color:#fff;text-decoration:none}.fc-not-allowed,.fc-not-allowed .fc-event{cursor:not-allowed}.fc-event .fc-bg{z-index:1;background:#fff;opacity:.25}.fc-event .fc-content{position:relative;z-index:2}.fc-event .fc-resizer{position:absolute;z-index:4;display:none}.fc-event.fc-allow-mouse-resize .fc-resizer,.fc-event.fc-selected .fc-resizer{display:block}.fc-event.fc-selected .fc-resizer:before{content:"";position:absolute;z-index:9999;top:50%;left:50%;width:40px;height:40px;margin-left:-20px;margin-top:-20px}.fc-event.fc-selected{z-index:9999!important;box-shadow:0 2px 5px rgba(0,0,0,.2)}.fc-event.fc-selected.fc-dragging{box-shadow:0 2px 7px rgba(0,0,0,.3)}.fc-h-event.fc-selected:before{content:"";position:absolute;z-index:3;top:-10px;bottom:-10px;left:0;right:0}.fc-ltr .fc-h-event.fc-not-start,.fc-rtl .fc-h-event.fc-not-end{margin-left:0;border-left-width:0;padding-left:1px;border-top-left-radius:0;border-bottom-left-radius:0}.fc-ltr .fc-h-event.fc-not-end,.fc-rtl .fc-h-event.fc-not-start{margin-right:0;border-right-width:0;padding-right:1px;border-top-right-radius:0;border-bottom-right-radius:0}.fc-ltr .fc-h-event .fc-start-resizer,.fc-rtl .fc-h-event .fc-end-resizer{cursor:w-resize;left:-1px}.fc-ltr .fc-h-event .fc-end-resizer,.fc-rtl .fc-h-event .fc-start-resizer{cursor:e-resize;right:-1px}.fc-h-event.fc-allow-mouse-resize .fc-resizer{width:7px;top:-1px;bottom:-1px}.fc-h-event.fc-selected .fc-resizer{border-radius:4px;border-width:1px;width:6px;height:6px;border-style:solid;border-color:inherit;background:#fff;top:50%;margin-top:-4px}.fc-ltr .fc-h-event.fc-selected .fc-start-resizer,.fc-rtl .fc-h-event.fc-selected .fc-end-resizer{margin-left:-4px}.fc-ltr .fc-h-event.fc-selected .fc-end-resizer,.fc-rtl .fc-h-event.fc-selected .fc-start-resizer{margin-right:-4px}.fc-day-grid-event{margin:1px 2px 0;padding:0 1px}tr:first-child>td>.fc-day-grid-event{margin-top:2px}.fc-day-grid-event.fc-selected:after{content:"";position:absolute;z-index:1;top:-1px;right:-1px;bottom:-1px;left:-1px;background:#000;opacity:.25}.fc-day-grid-event .fc-content{white-space:nowrap;overflow:hidden}.fc-day-grid-event .fc-time{font-weight:700}.fc-ltr .fc-day-grid-event.fc-allow-mouse-resize .fc-start-resizer,.fc-rtl .fc-day-grid-event.fc-allow-mouse-resize .fc-end-resizer{margin-left:-2px}.fc-ltr .fc-day-grid-event.fc-allow-mouse-resize .fc-end-resizer,.fc-rtl .fc-day-grid-event.fc-allow-mouse-resize .fc-start-resizer{margin-right:-2px}a.fc-more{margin:1px 3px;font-size:.85em;cursor:pointer;text-decoration:none}a.fc-more:hover{text-decoration:underline}.fc.fc-bootstrap3 a,.ui-widget .fc-event{text-decoration:none}.fc-limited{display:none}.fc-icon,.fc-toolbar .fc-center{display:inline-block}.fc-day-grid .fc-row{z-index:1}.fc-more-popover{z-index:2;width:220px}.fc-more-popover .fc-event-container{padding:10px}.fc-bootstrap3 .fc-popover .panel-body,.fc-bootstrap4 .fc-popover .card-body{padding:0}.fc-now-indicator{position:absolute;border:0 solid red}.fc-bootstrap3 .fc-today.alert,.fc-bootstrap4 .fc-today.alert{border-radius:0}.fc-unselectable{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-tap-highlight-color:transparent}.fc-unthemed .fc-content,.fc-unthemed .fc-divider,.fc-unthemed .fc-list-heading td,.fc-unthemed .fc-list-view,.fc-unthemed .fc-popover,.fc-unthemed .fc-row,.fc-unthemed tbody,.fc-unthemed td,.fc-unthemed th,.fc-unthemed thead{border-color:#ddd}.fc-unthemed .fc-popover{background-color:#fff;border-width:1px;border-style:solid}.fc-unthemed .fc-divider,.fc-unthemed .fc-list-heading td,.fc-unthemed .fc-popover .fc-header{background:#eee}.fc-unthemed td.fc-today{background:#fcf8e3}.fc-unthemed .fc-disabled-day{background:#d7d7d7;opacity:.3}.fc-icon{height:1em;line-height:1em;font-size:1em;font-family:"Courier New",Courier,monospace;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.fc-icon:after{position:relative}.fc-icon-left-single-arrow:after{content:"\2039";font-weight:700;font-size:200%;top:-7%}.fc-icon-right-single-arrow:after{content:"\203A";font-weight:700;font-size:200%;top:-7%}.fc-icon-left-double-arrow:after{content:"\AB";font-size:160%;top:-7%}.fc-icon-right-double-arrow:after{content:"\BB";font-size:160%;top:-7%}.fc-icon-left-triangle:after{content:"\25C4";font-size:125%;top:3%}.fc-icon-right-triangle:after{content:"\25BA";font-size:125%;top:3%}.fc-icon-down-triangle:after{content:"\25BC";font-size:125%;top:2%}.fc-icon-x:after{content:"\D7";font-size:200%;top:6%}.fc-unthemed .fc-popover .fc-header .fc-close{color:#666;font-size:.9em;margin-top:2px}.fc-unthemed .fc-list-item:hover td{background-color:#f5f5f5}.ui-widget .fc-disabled-day{background-image:none}.fc-bootstrap3 .fc-time-grid .fc-slats table,.fc-bootstrap4 .fc-time-grid .fc-slats table,.fc-time-grid .fc-slats .ui-widget-content{background:0 0}.fc-popover>.ui-widget-header+.ui-widget-content{border-top:0}.fc-bootstrap3 hr.fc-divider,.fc-bootstrap4 hr.fc-divider{border-color:inherit}.ui-widget .fc-event{color:#fff;font-weight:400}.ui-widget td.fc-axis{font-weight:400}.fc.fc-bootstrap3 a[data-goto]:hover{text-decoration:underline}.fc.fc-bootstrap4 a{text-decoration:none}.fc.fc-bootstrap4 a[data-goto]:hover{text-decoration:underline}.fc-bootstrap4 a.fc-event:not([href]):not([tabindex]){color:#fff}.fc-bootstrap4 .fc-popover.card{position:absolute}.fc-toolbar.fc-header-toolbar{margin-bottom:1em}.fc-toolbar.fc-footer-toolbar{margin-top:1em}.fc-toolbar .fc-left{float:left}.fc-toolbar .fc-right{float:right}.fc .fc-toolbar>*>*{float:left;margin-left:.75em}.fc .fc-toolbar>*>:first-child{margin-left:0}.fc-toolbar h2{margin:0}.fc-toolbar button{position:relative}.fc-toolbar .fc-state-hover,.fc-toolbar .ui-state-hover{z-index:2}.fc-toolbar .fc-state-down{z-index:3}.fc-toolbar .fc-state-active,.fc-toolbar .ui-state-active{z-index:4}.fc-toolbar button:focus{z-index:5}.fc-view-container *,.fc-view-container :after,.fc-view-container :before{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}.fc-view,.fc-view>table{position:relative;z-index:1}.fc-basicDay-view .fc-content-skeleton,.fc-basicWeek-view .fc-content-skeleton{padding-bottom:1em}.fc-basic-view .fc-body .fc-row{min-height:4em}.fc-row.fc-rigid .fc-content-skeleton{position:absolute;top:0;left:0;right:0}.fc-day-top.fc-other-month{opacity:.3}.fc-basic-view .fc-day-number,.fc-basic-view .fc-week-number{padding:2px}.fc-basic-view th.fc-day-number,.fc-basic-view th.fc-week-number{padding:0 2px}.fc-ltr .fc-basic-view .fc-day-top .fc-day-number{float:right}.fc-rtl .fc-basic-view .fc-day-top .fc-day-number{float:left}.fc-ltr .fc-basic-view .fc-day-top .fc-week-number{float:left;border-radius:0 0 3px}.fc-rtl .fc-basic-view .fc-day-top .fc-week-number{float:right;border-radius:0 0 0 3px}.fc-basic-view .fc-day-top .fc-week-number{min-width:1.5em;text-align:center;background-color:#f2f2f2;color:grey}.fc-basic-view td.fc-week-number>*{display:inline-block;min-width:1.25em}.fc-agenda-view .fc-day-grid{position:relative;z-index:2}.fc-agenda-view .fc-day-grid .fc-row{min-height:3em}.fc-agenda-view .fc-day-grid .fc-row .fc-content-skeleton{padding-bottom:1em}.fc .fc-axis{vertical-align:middle;padding:0 4px;white-space:nowrap}.fc-ltr .fc-axis{text-align:right}.fc-rtl .fc-axis{text-align:left}.fc-time-grid,.fc-time-grid-container{position:relative;z-index:1}.fc-time-grid{min-height:100%}.fc-time-grid table{border:0 hidden transparent}.fc-time-grid>.fc-bg{z-index:1}.fc-time-grid .fc-slats,.fc-time-grid>hr{position:relative;z-index:2}.fc-time-grid .fc-content-col{position:relative}.fc-time-grid .fc-content-skeleton{position:absolute;z-index:3;top:0;left:0;right:0}.fc-time-grid .fc-business-container{position:relative;z-index:1}.fc-time-grid .fc-bgevent-container{position:relative;z-index:2}.fc-time-grid .fc-highlight-container{z-index:3;position:relative}.fc-time-grid .fc-event-container{position:relative;z-index:4}.fc-time-grid .fc-now-indicator-line{z-index:5}.fc-time-grid .fc-helper-container{position:relative;z-index:6}.fc-time-grid .fc-slats td{height:1.5em;border-bottom:0}.fc-time-grid .fc-slats .fc-minor td{border-top-style:dotted}.fc-time-grid .fc-highlight{position:absolute;left:0;right:0}.fc-ltr .fc-time-grid .fc-event-container{margin:0 2.5% 0 2px}.fc-rtl .fc-time-grid .fc-event-container{margin:0 2px 0 2.5%}.fc-time-grid .fc-bgevent,.fc-time-grid .fc-event{position:absolute;z-index:1}.fc-time-grid .fc-bgevent{left:0;right:0}.fc-v-event.fc-not-start{border-top-width:0;padding-top:1px;border-top-left-radius:0;border-top-right-radius:0}.fc-v-event.fc-not-end{border-bottom-width:0;padding-bottom:1px;border-bottom-left-radius:0;border-bottom-right-radius:0}.fc-time-grid-event.fc-selected{overflow:visible}.fc-time-grid-event.fc-selected .fc-bg{display:none}.fc-time-grid-event .fc-content{overflow:hidden}.fc-time-grid-event .fc-time,.fc-time-grid-event .fc-title{padding:0 1px}.fc-time-grid-event .fc-time{font-size:.85em;white-space:nowrap}.fc-time-grid-event.fc-short .fc-content{white-space:nowrap}.fc-time-grid-event.fc-short .fc-time,.fc-time-grid-event.fc-short .fc-title{display:inline-block;vertical-align:top}.fc-time-grid-event.fc-short .fc-time span{display:none}.fc-time-grid-event.fc-short .fc-time:before{content:attr(data-start)}.fc-time-grid-event.fc-short .fc-time:after{content:"\A0-\A0"}.fc-time-grid-event.fc-short .fc-title{font-size:.85em;padding:0}.fc-time-grid-event.fc-allow-mouse-resize .fc-resizer{left:0;right:0;bottom:0;height:8px;overflow:hidden;line-height:8px;font-size:11px;font-family:monospace;text-align:center;cursor:s-resize}.fc-time-grid-event.fc-allow-mouse-resize .fc-resizer:after{content:"="}.fc-time-grid-event.fc-selected .fc-resizer{border-radius:5px;border-width:1px;width:8px;height:8px;border-style:solid;border-color:inherit;background:#fff;left:50%;margin-left:-5px;bottom:-5px}.fc-time-grid .fc-now-indicator-line{border-top-width:1px;left:0;right:0}.fc-time-grid .fc-now-indicator-arrow{margin-top:-5px}.fc-ltr .fc-time-grid .fc-now-indicator-arrow{left:0;border-width:5px 0 5px 6px;border-top-color:transparent;border-bottom-color:transparent}.fc-rtl .fc-time-grid .fc-now-indicator-arrow{right:0;border-width:5px 6px 5px 0;border-top-color:transparent;border-bottom-color:transparent}.fc-event-dot{display:inline-block;width:10px;height:10px;border-radius:5px}.fc-rtl .fc-list-view{direction:rtl}.fc-list-view{border-width:1px;border-style:solid}.fc .fc-list-table{table-layout:auto}.fc-list-table td{border-width:1px 0 0;padding:8px 14px}.fc-list-table tr:first-child td{border-top-width:0}.fc-list-heading{border-bottom-width:1px}.fc-list-heading td{font-weight:700}.fc-ltr .fc-list-heading-main{float:left}.fc-ltr .fc-list-heading-alt,.fc-rtl .fc-list-heading-main{float:right}.fc-rtl .fc-list-heading-alt{float:left}.fc-list-item.fc-has-url{cursor:pointer}.fc-list-item-marker,.fc-list-item-time{white-space:nowrap;width:1px}.fc-ltr .fc-list-item-marker{padding-right:0}.fc-rtl .fc-list-item-marker{padding-left:0}.fc-list-item-title a{text-decoration:none;color:inherit}.fc-list-item-title a[href]:hover{text-decoration:underline}.fc-list-empty-wrap2{position:absolute;top:0;left:0;right:0;bottom:0}.fc-list-empty-wrap1{width:100%;height:100%;display:table}.fc-list-empty{display:table-cell;vertical-align:middle;text-align:center}.fc-unthemed .fc-list-empty{background-color:#eee}
\ No newline at end of file
diff --git a/public/lib/fc/fullcalendar.min.js b/public/lib/fc/fullcalendar.min.js
new file mode 100644
index 0000000000..88045457d9
--- /dev/null
+++ b/public/lib/fc/fullcalendar.min.js
@@ -0,0 +1,12 @@
+/*!
+ * FullCalendar v3.9.0
+ * Docs & License: https://fullcalendar.io/
+ * (c) 2018 Adam Shaw
+ */
+!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e(require("moment"),require("jquery")):"function"==typeof define&&define.amd?define(["moment","jquery"],e):"object"==typeof exports?exports.FullCalendar=e(require("moment"),require("jquery")):t.FullCalendar=e(t.moment,t.jQuery)}("undefined"!=typeof self?self:this,function(t,e){return function(t){function e(i){if(n[i])return n[i].exports;var r=n[i]={i:i,l:!1,exports:{}};return t[i].call(r.exports,r,r.exports,e),r.l=!0,r.exports}var n={};return e.m=t,e.c=n,e.d=function(t,n,i){e.o(t,n)||Object.defineProperty(t,n,{configurable:!1,enumerable:!0,get:i})},e.n=function(t){var n=t&&t.__esModule?function(){return t.default}:function(){return t};return e.d(n,"a",n),n},e.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},e.p="",e(e.s=236)}([function(e,n){e.exports=t},,function(t,e){var n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])};e.__extends=function(t,e){function i(){this.constructor=t}n(t,e),t.prototype=null===e?Object.create(e):(i.prototype=e.prototype,new i)}},function(t,n){t.exports=e},function(t,e,n){function i(t,e){e.left&&t.css({"border-left-width":1,"margin-left":e.left-1}),e.right&&t.css({"border-right-width":1,"margin-right":e.right-1})}function r(t){t.css({"margin-left":"","margin-right":"","border-left-width":"","border-right-width":""})}function o(){ht("body").addClass("fc-not-allowed")}function s(){ht("body").removeClass("fc-not-allowed")}function a(t,e,n){var i=Math.floor(e/t.length),r=Math.floor(e-i*(t.length-1)),o=[],s=[],a=[],u=0;l(t),t.each(function(e,n){var l=e===t.length-1?r:i,d=ht(n).outerHeight(!0);d *").each(function(t,n){var i=ht(n).outerWidth();i>e&&(e=i)}),e++,t.width(e),e}function d(t,e){var n,i=t.add(e);return i.css({position:"relative",left:-1}),n=t.outerHeight()-e.outerHeight(),i.css({position:"",left:""}),n}function c(t){var e=t.css("position"),n=t.parents().filter(function(){var t=ht(this);return/(auto|scroll)/.test(t.css("overflow")+t.css("overflow-y")+t.css("overflow-x"))}).eq(0);return"fixed"!==e&&n.length?n:ht(t[0].ownerDocument||document)}function p(t,e){var n=t.offset(),i=n.left-(e?e.left:0),r=n.top-(e?e.top:0);return{left:i,right:i+t.outerWidth(),top:r,bottom:r+t.outerHeight()}}function h(t,e){var n=t.offset(),i=g(t),r=n.left+b(t,"border-left-width")+i.left-(e?e.left:0),o=n.top+b(t,"border-top-width")+i.top-(e?e.top:0);return{left:r,right:r+t[0].clientWidth,top:o,bottom:o+t[0].clientHeight}}function f(t,e){var n=t.offset(),i=n.left+b(t,"border-left-width")+b(t,"padding-left")-(e?e.left:0),r=n.top+b(t,"border-top-width")+b(t,"padding-top")-(e?e.top:0);return{left:i,right:i+t.width(),top:r,bottom:r+t.height()}}function g(t){var e,n=t[0].offsetWidth-t[0].clientWidth,i=t[0].offsetHeight-t[0].clientHeight;return n=v(n),i=v(i),e={left:0,right:0,top:0,bottom:i},y()&&"rtl"===t.css("direction")?e.left=n:e.right=n,e}function v(t){return t=Math.max(0,t),t=Math.round(t)}function y(){return null===ft&&(ft=m()),ft}function m(){var t=ht("").css({position:"absolute",top:-1e3,left:0,border:0,padding:0,overflow:"scroll",direction:"rtl"}).appendTo("body"),e=t.children(),n=e.offset().left>t.offset().left;return t.remove(),n}function b(t,e){return parseFloat(t.css(e))||0}function w(t){return 1===t.which&&!t.ctrlKey}function D(t){var e=t.originalEvent.touches;return e&&e.length?e[0].pageX:t.pageX}function E(t){var e=t.originalEvent.touches;return e&&e.length?e[0].pageY:t.pageY}function S(t){return/^touch/.test(t.type)}function C(t){t.addClass("fc-unselectable").on("selectstart",T)}function R(t){t.removeClass("fc-unselectable").off("selectstart",T)}function T(t){t.preventDefault()}function M(t,e){var n={left:Math.max(t.left,e.left),right:Math.min(t.right,e.right),top:Math.max(t.top,e.top),bottom:Math.min(t.bottom,e.bottom)};return n.left=1&&ut(o)));i++);return r}function L(t,e){var n=k(t);return"week"===n&&"object"==typeof e&&e.days&&(n="day"),n}function V(t,e,n){return null!=n?n.diff(e,t,!0):pt.isDuration(e)?e.as(t):e.end.diff(e.start,t,!0)}function G(t,e,n){var i;return U(n)?(e-t)/n:(i=n.asMonths(),Math.abs(i)>=1&&ut(i)?e.diff(t,"months",!0)/i:e.diff(t,"days",!0)/n.asDays())}function N(t,e){var n,i;return U(t)||U(e)?t/e:(n=t.asMonths(),i=e.asMonths(),Math.abs(n)>=1&&ut(n)&&Math.abs(i)>=1&&ut(i)?n/i:t.asDays()/e.asDays())}function j(t,e){var n;return U(t)?pt.duration(t*e):(n=t.asMonths(),Math.abs(n)>=1&&ut(n)?pt.duration({months:n*e}):pt.duration({days:t.asDays()*e}))}function U(t){return Boolean(t.hours()||t.minutes()||t.seconds()||t.milliseconds())}function W(t){return"[object Date]"===Object.prototype.toString.call(t)||t instanceof Date}function q(t){return"string"==typeof t&&/^\d+\:\d+(?:\:\d+\.?(?:\d{3})?)?$/.test(t)}function Y(){for(var t=[],e=0;e=0;o--)if("object"==typeof(s=t[o][i]))r.unshift(s);else if(void 0!==s){l[i]=s;break}r.length&&(l[i]=Q(r))}for(n=t.length-1;n>=0;n--){a=t[n];for(i in a)i in l||(l[i]=a[i])}return l}function X(t,e){for(var n in t)$(t,n)&&(e[n]=t[n])}function $(t,e){return gt.call(t,e)}function K(t,e,n){if(ht.isFunction(t)&&(t=[t]),t){var i=void 0,r=void 0;for(i=0;i/g,">").replace(/'/g,"'").replace(/"/g,""").replace(/\n/g,"
")}function rt(t){return t.replace(/&.*?;/g,"")}function ot(t){var e=[];return ht.each(t,function(t,n){null!=n&&e.push(t+":"+n)}),e.join(";")}function st(t){var e=[];return ht.each(t,function(t,n){null!=n&&e.push(t+'="'+it(n)+'"')}),e.join(" ")}function at(t){return t.charAt(0).toUpperCase()+t.slice(1)}function lt(t,e){return t-e}function ut(t){return t%1==0}function dt(t,e){var n=t[e];return function(){return n.apply(t,arguments)}}function ct(t,e,n){void 0===n&&(n=!1);var i,r,o,s,a,l=function(){var u=+new Date-s;ua&&s.push(new t(a,o.startMs)),o.endMs>a&&(a=o.endMs);return at.startMs)&&(null==this.startMs||null==t.endMs||this.startMs=this.startMs)&&(null==this.endMs||null!=t.endMs&&t.endMs<=this.endMs)},t.prototype.containsDate=function(t){var e=t.valueOf();return(null==this.startMs||e>=this.startMs)&&(null==this.endMs||e=this.endMs&&(e=this.endMs-1),e},t.prototype.equals=function(t){return this.startMs===t.startMs&&this.endMs===t.endMs},t.prototype.clone=function(){var e=new t(this.startMs,this.endMs);return e.isStart=this.isStart,e.isEnd=this.isEnd,e},t.prototype.getStart=function(){return null!=this.startMs?o.default.utc(this.startMs).stripZone():null},t.prototype.getEnd=function(){return null!=this.endMs?o.default.utc(this.endMs).stripZone():null},t.prototype.as=function(t){return r.utc(this.endMs).diff(r.utc(this.startMs),t,!0)},t}();e.default=s},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(3),o=n(208),s=n(33),a=n(49),l=function(t){function e(n){var i=t.call(this)||this;return i.calendar=n,i.className=[],i.uid=String(e.uuid++),i}return i.__extends(e,t),e.parse=function(t,e){var n=new this(e);return!("object"!=typeof t||!n.applyProps(t))&&n},e.normalizeId=function(t){return t?String(t):null},e.prototype.fetch=function(t,e,n){},e.prototype.removeEventDefsById=function(t){},e.prototype.removeAllEventDefs=function(){},e.prototype.getPrimitive=function(t){},e.prototype.parseEventDefs=function(t){var e,n,i=[];for(e=0;e0},e}(o.default);e.default=s},function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=function(){function t(t,e){this.isAllDay=!1,this.unzonedRange=t,this.isAllDay=e}return t.prototype.toLegacy=function(t){return{start:t.msToMoment(this.unzonedRange.startMs,this.isAllDay),end:t.msToMoment(this.unzonedRange.endMs,this.isAllDay)}},t}();e.default=n},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(34),o=n(209),s=n(17),a=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return i.__extends(e,t),e.prototype.buildInstances=function(){return[this.buildInstance()]},e.prototype.buildInstance=function(){return new o.default(this,this.dateProfile)},e.prototype.isAllDay=function(){return this.dateProfile.isAllDay()},e.prototype.clone=function(){var e=t.prototype.clone.call(this);return e.dateProfile=this.dateProfile,e},e.prototype.rezone=function(){var t=this.source.calendar,e=this.dateProfile;this.dateProfile=new s.default(t.moment(e.start),e.end?t.moment(e.end):null,t)},e.prototype.applyManualStandardProps=function(e){var n=t.prototype.applyManualStandardProps.call(this,e),i=s.default.parse(e,this.source);return!!i&&(this.dateProfile=i,null!=e.date&&(this.miscProps.date=e.date),n)},e}(r.default);e.default=a,a.defineStandardProps({start:!1,date:!1,end:!1,allDay:!1})},function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=function(){function t(){}return t.mixInto=function(t){var e=this;Object.getOwnPropertyNames(this.prototype).forEach(function(n){t.prototype[n]||(t.prototype[n]=e.prototype[n])})},t.mixOver=function(t){var e=this;Object.getOwnPropertyNames(this.prototype).forEach(function(n){t.prototype[n]=e.prototype[n]})},t}();e.default=n},function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=function(){function t(t){this.view=t._getView(),this.component=t}return t.prototype.opt=function(t){return this.view.opt(t)},t.prototype.end=function(){},t}();e.default=n},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0}),e.version="3.9.0",e.internalApiVersion=12;var i=n(4);e.applyAll=i.applyAll,e.debounce=i.debounce,e.isInt=i.isInt,e.htmlEscape=i.htmlEscape,e.cssToStr=i.cssToStr,e.proxy=i.proxy,e.capitaliseFirstLetter=i.capitaliseFirstLetter,e.getOuterRect=i.getOuterRect,e.getClientRect=i.getClientRect,e.getContentRect=i.getContentRect,e.getScrollbarWidths=i.getScrollbarWidths,e.preventDefault=i.preventDefault,e.parseFieldSpecs=i.parseFieldSpecs,e.compareByFieldSpecs=i.compareByFieldSpecs,e.compareByFieldSpec=i.compareByFieldSpec,e.flexibleCompare=i.flexibleCompare,e.computeGreatestUnit=i.computeGreatestUnit,e.divideRangeByDuration=i.divideRangeByDuration,e.divideDurationByDuration=i.divideDurationByDuration,e.multiplyDuration=i.multiplyDuration,e.durationHasTime=i.durationHasTime,e.log=i.log,e.warn=i.warn,e.removeExact=i.removeExact,e.intersectRects=i.intersectRects;var r=n(47);e.formatDate=r.formatDate,e.formatRange=r.formatRange,e.queryMostGranularFormatUnit=r.queryMostGranularFormatUnit;var o=n(31);e.datepickerLocale=o.datepickerLocale,e.locale=o.locale;var s=n(10);e.moment=s.default;var a=n(11);e.EmitterMixin=a.default;var l=n(7);e.ListenerMixin=l.default;var u=n(48);e.Model=u.default;var d=n(207);e.Constraints=d.default;var c=n(5);e.UnzonedRange=c.default;var p=n(12);e.ComponentFootprint=p.default;var h=n(212);e.BusinessHourGenerator=h.default;var f=n(34);e.EventDef=f.default;var g=n(37);e.EventDefMutation=g.default;var v=n(38);e.EventSourceParser=v.default;var y=n(6);e.EventSource=y.default;var m=n(51);e.defineThemeSystem=m.defineThemeSystem;var b=n(18);e.EventInstanceGroup=b.default;var w=n(52);e.ArrayEventSource=w.default;var D=n(215);e.FuncEventSource=D.default;var E=n(216);e.JsonFeedEventSource=E.default;var S=n(36);e.EventFootprint=S.default;var C=n(33);e.Class=C.default;var R=n(14);e.Mixin=R.default;var T=n(53);e.CoordCache=T.default;var M=n(54);e.DragListener=M.default;var I=n(20);e.Promise=I.default;var H=n(217);e.TaskQueue=H.default;var P=n(218);e.RenderQueue=P.default;var _=n(39);e.Scroller=_.default;var x=n(19);e.Theme=x.default;var O=n(219);e.DateComponent=O.default;var F=n(40);e.InteractiveDateComponent=F.default;var z=n(220);e.Calendar=z.default;var B=n(41);e.View=B.default;var A=n(22);e.defineView=A.defineView,e.getViewConfig=A.getViewConfig;var k=n(55);e.DayTableMixin=k.default;var L=n(56);e.BusinessHourRenderer=L.default;var V=n(42);e.EventRenderer=V.default;var G=n(57);e.FillRenderer=G.default;var N=n(58);e.HelperRenderer=N.default;var j=n(222);e.ExternalDropping=j.default;var U=n(223);e.EventResizing=U.default;var W=n(59);e.EventPointing=W.default;var q=n(224);e.EventDragging=q.default;var Y=n(225);e.DateSelecting=Y.default;var Z=n(60);e.StandardInteractionsMixin=Z.default;var Q=n(226);e.AgendaView=Q.default;var X=n(227);e.TimeGrid=X.default;var $=n(61);e.DayGrid=$.default;var K=n(62);e.BasicView=K.default;var J=n(229);e.MonthView=J.default;var tt=n(230);e.ListView=tt.default},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(5),r=function(){function t(t,e,n){this.start=t,this.end=e||null,this.unzonedRange=this.buildUnzonedRange(n)}return t.parse=function(e,n){var i=e.start||e.date,r=e.end;if(!i)return!1;var o=n.calendar,s=o.moment(i),a=r?o.moment(r):null,l=e.allDay,u=o.opt("forceEventDuration");return!!s.isValid()&&(!a||a.isValid()&&a.isAfter(s)||(a=null),null==l&&null==(l=n.allDayDefault)&&(l=o.opt("allDayDefault")),!0===l?(s.stripTime(),a&&a.stripTime()):!1===l&&(s.hasTime()||s.time(0),a&&!a.hasTime()&&a.time(0)),!a&&u&&(a=o.getDefaultEventEnd(!s.hasTime(),s)),new t(s,a,o))},t.isStandardProp=function(t){return"start"===t||"date"===t||"end"===t||"allDay"===t},t.prototype.isAllDay=function(){return!(this.start.hasTime()||this.end&&this.end.hasTime())},t.prototype.buildUnzonedRange=function(t){var e=this.start.clone().stripZone().valueOf(),n=this.getEnd(t).stripZone().valueOf();return new i.default(e,n)},t.prototype.getEnd=function(t){return this.end?this.end.clone():t.getDefaultEventEnd(this.isAllDay(),this.start)},t}();e.default=r},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(5),r=n(35),o=n(211),s=function(){function t(t){this.eventInstances=t||[]}return t.prototype.getAllEventRanges=function(t){return t?this.sliceNormalRenderRanges(t):this.eventInstances.map(r.eventInstanceToEventRange)},t.prototype.sliceRenderRanges=function(t){return this.isInverse()?this.sliceInverseRenderRanges(t):this.sliceNormalRenderRanges(t)},t.prototype.sliceNormalRenderRanges=function(t){var e,n,i,r=this.eventInstances,s=[];for(e=0;e')},e.prototype.clear=function(){this.setHeight("auto"),this.applyOverflow()},e.prototype.destroy=function(){this.el.remove()},e.prototype.applyOverflow=function(){this.scrollEl.css({"overflow-x":this.overflowX,"overflow-y":this.overflowY})},e.prototype.lockOverflow=function(t){var e=this.overflowX,n=this.overflowY;t=t||this.getScrollbarWidths(),"auto"===e&&(e=t.top||t.bottom||this.scrollEl[0].scrollWidth-1>this.scrollEl[0].clientWidth?"scroll":"hidden"),"auto"===n&&(n=t.left||t.right||this.scrollEl[0].scrollHeight-1>this.scrollEl[0].clientHeight?"scroll":"hidden"),this.scrollEl.css({"overflow-x":e,"overflow-y":n})},e.prototype.setHeight=function(t){this.scrollEl.height(t)},e.prototype.getScrollTop=function(){return this.scrollEl.scrollTop()},e.prototype.setScrollTop=function(t){this.scrollEl.scrollTop(t)},e.prototype.getClientWidth=function(){return this.scrollEl[0].clientWidth},e.prototype.getClientHeight=function(){return this.scrollEl[0].clientHeight},e.prototype.getScrollbarWidths=function(){return o.getScrollbarWidths(this.scrollEl)},e}(s.default);e.default=a},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(3),o=n(4),s=n(219),a=n(21),l=function(t){function e(e,n){var i=t.call(this,e,n)||this;return i.segSelector=".fc-event-container > *",i.dateSelectingClass&&(i.dateClicking=new i.dateClickingClass(i)),i.dateSelectingClass&&(i.dateSelecting=new i.dateSelectingClass(i)),i.eventPointingClass&&(i.eventPointing=new i.eventPointingClass(i)),i.eventDraggingClass&&i.eventPointing&&(i.eventDragging=new i.eventDraggingClass(i,i.eventPointing)),i.eventResizingClass&&i.eventPointing&&(i.eventResizing=new i.eventResizingClass(i,i.eventPointing)),i.externalDroppingClass&&(i.externalDropping=new i.externalDroppingClass(i)),i}return i.__extends(e,t),e.prototype.setElement=function(e){t.prototype.setElement.call(this,e),this.dateClicking&&this.dateClicking.bindToEl(e),this.dateSelecting&&this.dateSelecting.bindToEl(e),this.bindAllSegHandlersToEl(e)},e.prototype.removeElement=function(){this.endInteractions(),t.prototype.removeElement.call(this)},e.prototype.executeEventUnrender=function(){this.endInteractions(),t.prototype.executeEventUnrender.call(this)},e.prototype.bindGlobalHandlers=function(){t.prototype.bindGlobalHandlers.call(this),this.externalDropping&&this.externalDropping.bindToDocument()},e.prototype.unbindGlobalHandlers=function(){t.prototype.unbindGlobalHandlers.call(this),this.externalDropping&&this.externalDropping.unbindFromDocument()},e.prototype.bindDateHandlerToEl=function(t,e,n){var i=this;this.el.on(e,function(t){if(!r(t.target).is(i.segSelector+":not(.fc-helper),"+i.segSelector+":not(.fc-helper) *,.fc-more,a[data-goto]"))return n.call(i,t)})},e.prototype.bindAllSegHandlersToEl=function(t){[this.eventPointing,this.eventDragging,this.eventResizing].forEach(function(e){e&&e.bindToEl(t)})},e.prototype.bindSegHandlerToEl=function(t,e,n){var i=this;t.on(e,this.segSelector,function(t){var e=r(t.currentTarget);if(!e.is(".fc-helper")){var o=e.data("fc-seg");if(o&&!i.shouldIgnoreEventPointing())return n.call(i,o,t)}})},e.prototype.shouldIgnoreMouse=function(){return a.default.get().shouldIgnoreMouse()},e.prototype.shouldIgnoreTouch=function(){var t=this._getView();return t.isSelected||t.selectedEvent},e.prototype.shouldIgnoreEventPointing=function(){return this.eventDragging&&this.eventDragging.isDragging||this.eventResizing&&this.eventResizing.isResizing},e.prototype.canStartSelection=function(t,e){return o.getEvIsTouch(e)&&!this.canStartResize(t,e)&&(this.isEventDefDraggable(t.footprint.eventDef)||this.isEventDefResizable(t.footprint.eventDef))},e.prototype.canStartDrag=function(t,e){return!this.canStartResize(t,e)&&this.isEventDefDraggable(t.footprint.eventDef)},e.prototype.canStartResize=function(t,e){var n=this._getView(),i=t.footprint.eventDef;return(!o.getEvIsTouch(e)||n.isEventDefSelected(i))&&this.isEventDefResizable(i)&&r(e.target).is(".fc-resizer")},e.prototype.endInteractions=function(){[this.dateClicking,this.dateSelecting,this.eventPointing,this.eventDragging,this.eventResizing].forEach(function(t){t&&t.end()})},e.prototype.isEventDefDraggable=function(t){return this.isEventDefStartEditable(t)},e.prototype.isEventDefStartEditable=function(t){var e=t.isStartExplicitlyEditable();return null==e&&null==(e=this.opt("eventStartEditable"))&&(e=this.isEventDefGenerallyEditable(t)),e},e.prototype.isEventDefGenerallyEditable=function(t){var e=t.isExplicitlyEditable();return null==e&&(e=this.opt("editable")),e},e.prototype.isEventDefResizableFromStart=function(t){return this.opt("eventResizableFromStart")&&this.isEventDefResizable(t)},e.prototype.isEventDefResizableFromEnd=function(t){return this.isEventDefResizable(t)},e.prototype.isEventDefResizable=function(t){var e=t.isDurationExplicitlyEditable();return null==e&&null==(e=this.opt("eventDurationEditable"))&&(e=this.isEventDefGenerallyEditable(t)),e},e.prototype.diffDates=function(t,e){return this.largeUnit?o.diffByUnit(t,e,this.largeUnit):o.diffDayTime(t,e)},e.prototype.isEventInstanceGroupAllowed=function(t){var e,n=this._getView(),i=this.dateProfile,r=this.eventRangesToEventFootprints(t.getAllEventRanges());for(e=0;e1?"ll":"LL"},e.prototype.setDate=function(t){var e=this.get("dateProfile"),n=this.dateProfileGenerator.build(t,void 0,!0);e&&e.activeUnzonedRange.equals(n.activeUnzonedRange)||this.set("dateProfile",n)},e.prototype.unsetDate=function(){this.unset("dateProfile")},e.prototype.fetchInitialEvents=function(t){var e=this.calendar,n=t.isRangeAllDay&&!this.usesMinMaxTime;return e.requestEvents(e.msToMoment(t.activeUnzonedRange.startMs,n),e.msToMoment(t.activeUnzonedRange.endMs,n))},e.prototype.bindEventChanges=function(){this.listenTo(this.calendar,"eventsReset",this.resetEvents)},e.prototype.unbindEventChanges=function(){this.stopListeningTo(this.calendar,"eventsReset")},e.prototype.setEvents=function(t){this.set("currentEvents",t),this.set("hasEvents",!0)},e.prototype.unsetEvents=function(){this.unset("currentEvents"),this.unset("hasEvents")},e.prototype.resetEvents=function(t){this.startBatchRender(),this.unsetEvents(),this.setEvents(t),this.stopBatchRender()},e.prototype.requestDateRender=function(t){var e=this;this.requestRender(function(){e.executeDateRender(t)},"date","init")},e.prototype.requestDateUnrender=function(){var t=this;this.requestRender(function(){t.executeDateUnrender()},"date","destroy")},e.prototype.executeDateRender=function(e){t.prototype.executeDateRender.call(this,e),this.render&&this.render(),this.trigger("datesRendered"),this.addScroll({isDateInit:!0}),this.startNowIndicator()},e.prototype.executeDateUnrender=function(){this.unselect(),this.stopNowIndicator(),this.trigger("before:datesUnrendered"),this.destroy&&this.destroy(),t.prototype.executeDateUnrender.call(this)},e.prototype.bindBaseRenderHandlers=function(){var t=this;this.on("datesRendered",function(){t.whenSizeUpdated(t.triggerViewRender)}),this.on("before:datesUnrendered",function(){t.triggerViewDestroy()})},e.prototype.triggerViewRender=function(){this.publiclyTrigger("viewRender",{context:this,args:[this,this.el]})},e.prototype.triggerViewDestroy=function(){this.publiclyTrigger("viewDestroy",{context:this,args:[this,this.el]})},e.prototype.requestEventsRender=function(t){var e=this;this.requestRender(function(){e.executeEventRender(t),e.whenSizeUpdated(e.triggerAfterEventsRendered)},"event","init")},e.prototype.requestEventsUnrender=function(){var t=this;this.requestRender(function(){t.triggerBeforeEventsDestroyed(),t.executeEventUnrender()},"event","destroy")},e.prototype.requestBusinessHoursRender=function(t){var e=this;this.requestRender(function(){e.renderBusinessHours(t)},"businessHours","init")},e.prototype.requestBusinessHoursUnrender=function(){var t=this;this.requestRender(function(){t.unrenderBusinessHours()},"businessHours","destroy")},e.prototype.bindGlobalHandlers=function(){t.prototype.bindGlobalHandlers.call(this),this.listenTo(d.default.get(),{touchstart:this.processUnselect,mousedown:this.handleDocumentMousedown})},e.prototype.unbindGlobalHandlers=function(){t.prototype.unbindGlobalHandlers.call(this),this.stopListeningTo(d.default.get())},e.prototype.startNowIndicator=function(){var t,e,n,i=this;this.opt("nowIndicator")&&(t=this.getNowIndicatorUnit())&&(e=s.proxy(this,"updateNowIndicator"),this.initialNowDate=this.calendar.getNow(),this.initialNowQueriedMs=(new Date).valueOf(),n=this.initialNowDate.clone().startOf(t).add(1,t).valueOf()-this.initialNowDate.valueOf(),this.nowIndicatorTimeoutID=setTimeout(function(){i.nowIndicatorTimeoutID=null,e(),n=+o.duration(1,t),n=Math.max(100,n),i.nowIndicatorIntervalID=setInterval(e,n)},n))},e.prototype.updateNowIndicator=function(){this.isDatesRendered&&this.initialNowDate&&(this.unrenderNowIndicator(),this.renderNowIndicator(this.initialNowDate.clone().add((new Date).valueOf()-this.initialNowQueriedMs)),this.isNowIndicatorRendered=!0)},e.prototype.stopNowIndicator=function(){this.isNowIndicatorRendered&&(this.nowIndicatorTimeoutID&&(clearTimeout(this.nowIndicatorTimeoutID),this.nowIndicatorTimeoutID=null),this.nowIndicatorIntervalID&&(clearInterval(this.nowIndicatorIntervalID),this.nowIndicatorIntervalID=null),this.unrenderNowIndicator(),this.isNowIndicatorRendered=!1)},e.prototype.updateSize=function(e,n,i){this.setHeight?this.setHeight(e,n):t.prototype.updateSize.call(this,e,n,i),this.updateNowIndicator()},e.prototype.addScroll=function(t){var e=this.queuedScroll||(this.queuedScroll={});r.extend(e,t)},e.prototype.popScroll=function(){this.applyQueuedScroll(),this.queuedScroll=null},e.prototype.applyQueuedScroll=function(){this.queuedScroll&&this.applyScroll(this.queuedScroll)},e.prototype.queryScroll=function(){var t={};return this.isDatesRendered&&r.extend(t,this.queryDateScroll()),t},e.prototype.applyScroll=function(t){t.isDateInit&&this.isDatesRendered&&r.extend(t,this.computeInitialDateScroll()),this.isDatesRendered&&this.applyDateScroll(t)},e.prototype.computeInitialDateScroll=function(){return{}},e.prototype.queryDateScroll=function(){return{}},e.prototype.applyDateScroll=function(t){},e.prototype.reportEventDrop=function(t,e,n,i){var r=this.calendar.eventManager,s=r.mutateEventsWithId(t.def.id,e),a=e.dateMutation;a&&(t.dateProfile=a.buildNewDateProfile(t.dateProfile,this.calendar)),this.triggerEventDrop(t,a&&a.dateDelta||o.duration(),s,n,i)},e.prototype.triggerEventDrop=function(t,e,n,i,r){this.publiclyTrigger("eventDrop",{context:i[0],args:[t.toLegacy(),e,n,r,{},this]})},e.prototype.reportExternalDrop=function(t,e,n,i,r,o){e&&this.calendar.eventManager.addEventDef(t,n),this.triggerExternalDrop(t,e,i,r,o)},e.prototype.triggerExternalDrop=function(t,e,n,i,r){this.publiclyTrigger("drop",{context:n[0],args:[t.dateProfile.start.clone(),i,r,this]}),e&&this.publiclyTrigger("eventReceive",{context:this,args:[t.buildInstance().toLegacy(),this]})},e.prototype.reportEventResize=function(t,e,n,i){var r=this.calendar.eventManager,o=r.mutateEventsWithId(t.def.id,e);t.dateProfile=e.dateMutation.buildNewDateProfile(t.dateProfile,this.calendar),this.triggerEventResize(t,e.dateMutation.endDelta,o,n,i)},e.prototype.triggerEventResize=function(t,e,n,i,r){this.publiclyTrigger("eventResize",{context:i[0],args:[t.toLegacy(),e,n,r,{},this]})},e.prototype.select=function(t,e){this.unselect(e),this.renderSelectionFootprint(t),this.reportSelection(t,e)},e.prototype.renderSelectionFootprint=function(e){this.renderSelection?this.renderSelection(e.toLegacy(this.calendar)):t.prototype.renderSelectionFootprint.call(this,e)},e.prototype.reportSelection=function(t,e){this.isSelected=!0,this.triggerSelect(t,e)},e.prototype.triggerSelect=function(t,e){var n=this.calendar.footprintToDateProfile(t);this.publiclyTrigger("select",{context:this,args:[n.start,n.end,e,this]})},e.prototype.unselect=function(t){this.isSelected&&(this.isSelected=!1,this.destroySelection&&this.destroySelection(),this.unrenderSelection(),this.publiclyTrigger("unselect",{context:this,args:[t,this]}))},e.prototype.selectEventInstance=function(t){this.selectedEventInstance&&this.selectedEventInstance===t||(this.unselectEventInstance(),this.getEventSegs().forEach(function(e){e.footprint.eventInstance===t&&e.el&&e.el.addClass("fc-selected")}),this.selectedEventInstance=t)},e.prototype.unselectEventInstance=function(){this.selectedEventInstance&&(this.getEventSegs().forEach(function(t){t.el&&t.el.removeClass("fc-selected")}),this.selectedEventInstance=null)},e.prototype.isEventDefSelected=function(t){return this.selectedEventInstance&&this.selectedEventInstance.def.id===t.id},e.prototype.handleDocumentMousedown=function(t){s.isPrimaryMouseButton(t)&&this.processUnselect(t)},e.prototype.processUnselect=function(t){this.processRangeUnselect(t),this.processEventUnselect(t)},e.prototype.processRangeUnselect=function(t){var e;this.isSelected&&this.opt("unselectAuto")&&((e=this.opt("unselectCancel"))&&r(t.target).closest(e).length||this.unselect(t))},e.prototype.processEventUnselect=function(t){this.selectedEventInstance&&(r(t.target).closest(".fc-selected").length||this.unselectEventInstance())},e.prototype.triggerBaseRendered=function(){this.publiclyTrigger("viewRender",{context:this,args:[this,this.el]})},e.prototype.triggerBaseUnrendered=function(){this.publiclyTrigger("viewDestroy",{context:this,args:[this,this.el]})},e.prototype.triggerDayClick=function(t,e,n){var i=this.calendar.footprintToDateProfile(t);this.publiclyTrigger("dayClick",{context:e,args:[i.start,n,this]})},e.prototype.isDateInOtherMonth=function(t,e){return!1},e.prototype.getUnzonedRangeOption=function(t){var e=this.opt(t);if("function"==typeof e&&(e=e.apply(null,Array.prototype.slice.call(arguments,1))),e)return this.calendar.parseUnzonedRange(e)},e.prototype.initHiddenDays=function(){var t,e=this.opt("hiddenDays")||[],n=[],i=0;for(!1===this.opt("weekends")&&e.push(0,6),t=0;t<7;t++)(n[t]=-1!==r.inArray(t,e))||i++;if(!i)throw new Error("invalid hiddenDays");this.isHiddenDayHash=n},e.prototype.trimHiddenDays=function(t){var e=t.getStart(),n=t.getEnd();return e&&(e=this.skipHiddenDays(e)),n&&(n=this.skipHiddenDays(n,-1,!0)),null===e||null===n||eo&&(!l[s]||u.isSame(d,l[s]))&&(s-1!==o||"."!==c[s]);s--)v=c[s]+v;for(a=o;a<=s;a++)y+=c[a],m+=p[a];return(y||m)&&(b=r?m+i+y:y+i+m),g(h+b+v)}function a(t){return C[t]||(C[t]=l(t))}function l(t){var e=u(t);return{fakeFormatString:c(e),sameUnits:p(e)}}function u(t){for(var e,n=[],i=/\[([^\]]*)\]|\(([^\)]*)\)|(LTS|LT|(\w)\4*o?)|([^\w\[\(]+)/g;e=i.exec(t);)e[1]?n.push.apply(n,d(e[1])):e[2]?n.push({maybe:u(e[2])}):e[3]?n.push({token:e[3]}):e[5]&&n.push.apply(n,d(e[5]));return n}function d(t){return". "===t?["."," "]:[t]}function c(t){var e,n,i=[];for(e=0;er.value)&&(r=i);return r?r.unit:null}Object.defineProperty(e,"__esModule",{value:!0});var y=n(10);y.newMomentProto.format=function(){return this._fullCalendar&&arguments[0]?r(this,arguments[0]):this._ambigTime?y.oldMomentFormat(i(this),"YYYY-MM-DD"):this._ambigZone?y.oldMomentFormat(i(this),"YYYY-MM-DD[T]HH:mm:ss"):this._fullCalendar?y.oldMomentFormat(i(this)):y.oldMomentProto.format.apply(this,arguments)},y.newMomentProto.toISOString=function(){return this._ambigTime?y.oldMomentFormat(i(this),"YYYY-MM-DD"):this._ambigZone?y.oldMomentFormat(i(this),"YYYY-MM-DD[T]HH:mm:ss"):this._fullCalendar?y.oldMomentProto.toISOString.apply(i(this),arguments):y.oldMomentProto.toISOString.apply(this,arguments)};var m="\v",b=" ",w=" ",D=new RegExp(w+"([^"+w+"]*)"+w,"g"),E={t:function(t){return y.oldMomentFormat(t,"a").charAt(0)},T:function(t){return y.oldMomentFormat(t,"A").charAt(0)}},S={Y:{value:1,unit:"year"},M:{value:2,unit:"month"},W:{value:3,unit:"week"},w:{value:3,unit:"week"},D:{value:4,unit:"day"},d:{value:4,unit:"day"}};e.formatDate=r,e.formatRange=o;var C={};e.queryMostGranularFormatUnit=v},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(33),o=n(11),s=n(7),a=function(t){function e(){var e=t.call(this)||this;return e._watchers={},e._props={},e.applyGlobalWatchers(),e.constructed(),e}return i.__extends(e,t),e.watch=function(t){for(var e=[],n=1;n0&&(t=this.els.eq(0).offsetParent()),this.origin=t?t.offset():null,this.boundingRect=this.queryBoundingRect(),this.isHorizontal&&this.buildElHorizontals(),this.isVertical&&this.buildElVerticals()},t.prototype.clear=function(){this.origin=null,this.boundingRect=null,this.lefts=null,this.rights=null,this.tops=null,this.bottoms=null},t.prototype.ensureBuilt=function(){this.origin||this.build()},t.prototype.buildElHorizontals=function(){var t=[],e=[];this.els.each(function(n,r){var o=i(r),s=o.offset().left,a=o.outerWidth();t.push(s),e.push(s+a)}),this.lefts=t,this.rights=e},t.prototype.buildElVerticals=function(){var t=[],e=[];this.els.each(function(n,r){var o=i(r),s=o.offset().top,a=o.outerHeight();t.push(s),e.push(s+a)}),this.tops=t,this.bottoms=e},t.prototype.getHorizontalIndex=function(t){this.ensureBuilt();var e,n=this.lefts,i=this.rights,r=n.length;for(e=0;e=n[e]&&t=n[e]&&t0&&(t=r.getScrollParent(this.els.eq(0)),!t.is(document))?r.getClientRect(t):null},t.prototype.isPointInBounds=function(t,e){return this.isLeftInBounds(t)&&this.isTopInBounds(e)},t.prototype.isLeftInBounds=function(t){return!this.boundingRect||t>=this.boundingRect.left&&t=this.boundingRect.top&&t=i*i&&this.handleDistanceSurpassed(t),this.isDragging&&this.handleDrag(e,n,t)},t.prototype.handleDrag=function(t,e,n){this.trigger("drag",t,e,n),this.updateAutoScroll(n)},t.prototype.endDrag=function(t){this.isDragging&&(this.isDragging=!1,this.handleDragEnd(t))},t.prototype.handleDragEnd=function(t){this.trigger("dragEnd",t)},t.prototype.startDelay=function(t){var e=this;this.delay?this.delayTimeoutId=setTimeout(function(){e.handleDelayEnd(t)},this.delay):this.handleDelayEnd(t)},t.prototype.handleDelayEnd=function(t){this.isDelayEnded=!0,this.isDistanceSurpassed&&this.startDrag(t)},t.prototype.handleDistanceSurpassed=function(t){this.isDistanceSurpassed=!0,this.isDelayEnded&&this.startDrag(t)},t.prototype.handleTouchMove=function(t){this.isDragging&&this.shouldCancelTouchScroll&&t.preventDefault(),this.handleMove(t)},t.prototype.handleMouseMove=function(t){this.handleMove(t)},t.prototype.handleTouchScroll=function(t){this.isDragging&&!this.scrollAlwaysKills||this.endInteraction(t,!0)},t.prototype.trigger=function(t){for(var e=[],n=1;n=0&&e<=1?l=e*this.scrollSpeed*-1:n>=0&&n<=1&&(l=n*this.scrollSpeed),i>=0&&i<=1?u=i*this.scrollSpeed*-1:o>=0&&o<=1&&(u=o*this.scrollSpeed)),this.setScrollVel(l,u)},t.prototype.setScrollVel=function(t,e){this.scrollTopVel=t,this.scrollLeftVel=e,this.constrainScrollVel(),!this.scrollTopVel&&!this.scrollLeftVel||this.scrollIntervalId||(this.scrollIntervalId=setInterval(r.proxy(this,"scrollIntervalFunc"),this.scrollIntervalMs))},t.prototype.constrainScrollVel=function(){var t=this.scrollEl;this.scrollTopVel<0?t.scrollTop()<=0&&(this.scrollTopVel=0):this.scrollTopVel>0&&t.scrollTop()+t[0].clientHeight>=t[0].scrollHeight&&(this.scrollTopVel=0),this.scrollLeftVel<0?t.scrollLeft()<=0&&(this.scrollLeftVel=0):this.scrollLeftVel>0&&t.scrollLeft()+t[0].clientWidth>=t[0].scrollWidth&&(this.scrollLeftVel=0)},t.prototype.scrollIntervalFunc=function(){var t=this.scrollEl,e=this.scrollIntervalMs/1e3;this.scrollTopVel&&t.scrollTop(t.scrollTop()+this.scrollTopVel*e),this.scrollLeftVel&&t.scrollLeft(t.scrollLeft()+this.scrollLeftVel*e),this.constrainScrollVel(),this.scrollTopVel||this.scrollLeftVel||this.endAutoScroll()},t.prototype.endAutoScroll=function(){this.scrollIntervalId&&(clearInterval(this.scrollIntervalId),this.scrollIntervalId=null,this.handleScrollEnd())},t.prototype.handleDebouncedScroll=function(){this.scrollIntervalId||this.handleScrollEnd()},t.prototype.handleScrollEnd=function(){},t}();e.default=a,o.default.mixInto(a)},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(4),o=n(14),s=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return i.__extends(e,t),e.prototype.updateDayTable=function(){for(var t,e,n,i=this,r=i.view,o=r.calendar,s=o.msToUtcMoment(i.dateProfile.renderUnzonedRange.startMs,!0),a=o.msToUtcMoment(i.dateProfile.renderUnzonedRange.endMs,!0),l=-1,u=[],d=[];s.isBefore(a);)r.isHiddenDay(s)?u.push(l+.5):(l++,u.push(l),d.push(s.clone())),s.add(1,"days");if(this.breakOnWeeks){for(e=d[0].day(),t=1;t=e.length?e[e.length-1]+1:e[n]},e.prototype.computeColHeadFormat=function(){return this.rowCnt>1||this.colCnt>10?"ddd":this.colCnt>1?this.opt("dayOfMonthFormat"):"dddd"},e.prototype.sliceRangeByRow=function(t){var e,n,i,r,o,s=this.daysPerRow,a=this.view.computeDayRange(t),l=this.getDateDayIndex(a.start),u=this.getDateDayIndex(a.end.clone().subtract(1,"days")),d=[];for(e=0;e'+this.renderHeadTrHtml()+" "},e.prototype.renderHeadIntroHtml=function(){return this.renderIntroHtml()},e.prototype.renderHeadTrHtml=function(){return""+(this.isRTL?"":this.renderHeadIntroHtml())+this.renderHeadDateCellsHtml()+(this.isRTL?this.renderHeadIntroHtml():"")+" "},e.prototype.renderHeadDateCellsHtml=function(){var t,e,n=[];for(t=0;t1?' colspan="'+e+'"':"")+(n?" "+n:"")+">"+(a?s.buildGotoAnchorHtml({date:t,forceOff:o.rowCnt>1||1===o.colCnt},i):i)+""},e.prototype.renderBgTrHtml=function(t){return""+(this.isRTL?"":this.renderBgIntroHtml(t))+this.renderBgCellsHtml(t)+(this.isRTL?this.renderBgIntroHtml(t):"")+" "},e.prototype.renderBgIntroHtml=function(t){return this.renderIntroHtml()},e.prototype.renderBgCellsHtml=function(t){var e,n,i=[];for(e=0;e"},e.prototype.renderIntroHtml=function(){},e.prototype.bookendCells=function(t){var e=this.renderIntroHtml();e&&(this.isRTL?t.append(e):t.prepend(e))},e}(o.default);e.default=s},function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=function(){function t(t,e){this.component=t,this.fillRenderer=e}return t.prototype.render=function(t){var e=this.component,n=e._getDateProfile().activeUnzonedRange,i=t.buildEventInstanceGroup(e.hasAllDayBusinessHours,n),r=i?e.eventRangesToEventFootprints(i.sliceRenderRanges(n)):[];this.renderEventFootprints(r)},t.prototype.renderEventFootprints=function(t){var e=this.component.eventFootprintsToSegs(t);this.renderSegs(e),this.segs=e},t.prototype.renderSegs=function(t){this.fillRenderer&&this.fillRenderer.renderSegs("businessHours",t,{getClasses:function(t){return["fc-nonbusiness","fc-bgevent"]}})},t.prototype.unrender=function(){this.fillRenderer&&this.fillRenderer.unrender("businessHours"),this.segs=null},t.prototype.getSegs=function(){return this.segs||[]},t}();e.default=n},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(3),r=n(4),o=function(){function t(t){this.fillSegTag="div",this.component=t,this.elsByFill={}}return t.prototype.renderFootprint=function(t,e,n){this.renderSegs(t,this.component.componentFootprintToSegs(e),n)},t.prototype.renderSegs=function(t,e,n){var i;return e=this.buildSegEls(t,e,n),i=this.attachSegEls(t,e),i&&this.reportEls(t,i),e},t.prototype.unrender=function(t){var e=this.elsByFill[t];e&&(e.remove(),delete this.elsByFill[t])},t.prototype.buildSegEls=function(t,e,n){var r,o=this,s="",a=[];if(e.length){for(r=0;r"},t.prototype.attachSegEls=function(t,e){},t.prototype.reportEls=function(t,e){this.elsByFill[t]?this.elsByFill[t]=this.elsByFill[t].add(e):this.elsByFill[t]=i(e)},t}();e.default=o},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(13),r=n(36),o=n(6),s=function(){function t(t,e){this.view=t._getView(),this.component=t,this.eventRenderer=e}return t.prototype.renderComponentFootprint=function(t){this.renderEventFootprints([this.fabricateEventFootprint(t)])},t.prototype.renderEventDraggingFootprints=function(t,e,n){this.renderEventFootprints(t,e,"fc-dragging",n?null:this.view.opt("dragOpacity"))},t.prototype.renderEventResizingFootprints=function(t,e,n){this.renderEventFootprints(t,e,"fc-resizing")},t.prototype.renderEventFootprints=function(t,e,n,i){var r,o=this.component.eventFootprintsToSegs(t),s="fc-helper "+(n||"");for(o=this.eventRenderer.renderFgSegEls(o),r=0;r'+this.renderBgTrHtml(t)+' '+(this.getIsNumbersVisible()?""+this.renderNumberTrHtml(t)+"":"")+" "+(this.isRTL?"":this.renderNumberIntroHtml(t))+this.renderNumberCellsHtml(t)+(this.isRTL?this.renderNumberIntroHtml(t):"")+" "},e.prototype.renderNumberIntroHtml=function(t){return this.renderIntroHtml()},e.prototype.renderNumberCellsHtml=function(t){var e,n,i=[];for(e=0;e",this.cellWeekNumbersVisible&&t.day()===n&&(r+=i.buildGotoAnchorHtml({date:t,type:"week"},{class:"fc-week-number"},t.format("w"))),s&&(r+=i.buildGotoAnchorHtml(t,{class:"fc-day-number"},t.format("D"))),r+=""):" | "},e.prototype.prepareHits=function(){this.colCoordCache.build(),this.rowCoordCache.build(),this.rowCoordCache.bottoms[this.rowCnt-1]+=this.bottomCoordPadding},e.prototype.releaseHits=function(){this.colCoordCache.clear(),this.rowCoordCache.clear()},e.prototype.queryHit=function(t,e){if(this.colCoordCache.isLeftInBounds(t)&&this.rowCoordCache.isTopInBounds(e)){var n=this.colCoordCache.getHorizontalIndex(t),i=this.rowCoordCache.getVerticalIndex(e);if(null!=i&&null!=n)return this.getCellHit(i,n)}},e.prototype.getHitFootprint=function(t){var e=this.getCellRange(t.row,t.col);return new u.default(new l.default(e.start,e.end),!0)},e.prototype.getHitEl=function(t){return this.getCellEl(t.row,t.col)},e.prototype.getCellHit=function(t,e){return{row:t,col:e,component:this,left:this.colCoordCache.getLeftOffset(e),right:this.colCoordCache.getRightOffset(e),top:this.rowCoordCache.getTopOffset(t),bottom:this.rowCoordCache.getBottomOffset(t)}},e.prototype.getCellEl=function(t,e){return this.cellEls.eq(t*this.colCnt+e)},e.prototype.executeEventUnrender=function(){this.removeSegPopover(),t.prototype.executeEventUnrender.call(this)},e.prototype.getOwnEventSegs=function(){
+return t.prototype.getOwnEventSegs.call(this).concat(this.popoverSegs||[])},e.prototype.renderDrag=function(t,e,n){var i;for(i=0;i td > :first-child").each(e),i.position().top+o>a)return n;return!1},e.prototype.limitRow=function(t,e){var n,i,o,s,a,l,u,d,c,p,h,f,g,v,y,m=this,b=this.eventRenderer.rowStructs[t],w=[],D=0,E=function(n){for(;D").append(y),c.append(v),w.push(v[0])),D++};if(e&&e').attr("rowspan",p),l=d[f],y=this.renderMoreLink(t,a.leftCol+f,[a].concat(l)),v=r("").append(y),g.append(v),h.push(g[0]),w.push(g[0]);c.addClass("fc-limited").after(r(h)),o.push(c[0])}}E(this.colCnt),b.moreEls=r(w),b.limitedEls=r(o)}},e.prototype.unlimitRow=function(t){var e=this.eventRenderer.rowStructs[t];e.moreEls&&(e.moreEls.remove(),e.moreEls=null),e.limitedEls&&(e.limitedEls.removeClass("fc-limited"),e.limitedEls=null)},e.prototype.renderMoreLink=function(t,e,n){var i=this,o=this.view;return r('').text(this.getMoreLinkText(n.length)).on("click",function(s){var a=i.opt("eventLimitClick"),l=i.getCellDate(t,e),u=r(s.currentTarget),d=i.getCellEl(t,e),c=i.getCellSegs(t,e),p=i.resliceDaySegs(c,l),h=i.resliceDaySegs(n,l);"function"==typeof a&&(a=i.publiclyTrigger("eventLimitClick",{context:o,args:[{date:l.clone(),dayEl:d,moreEl:u,segs:p,hiddenSegs:h},s,o]})),"popover"===a?i.showSegPopover(t,e,u,p):"string"==typeof a&&o.calendar.zoomTo(l,a)})},e.prototype.showSegPopover=function(t,e,n,i){var r,o,s=this,l=this.view,u=n.parent();r=1===this.rowCnt?l.el:this.rowEls.eq(t),o={className:"fc-more-popover "+l.calendar.theme.getClass("popover"),content:this.renderSegPopoverContent(t,e,i),parentEl:l.el,top:r.offset().top,autoHide:!0,viewportConstrain:this.opt("popoverViewportConstrain"),hide:function(){s.popoverSegs&&s.triggerBeforeEventSegsDestroyed(s.popoverSegs),s.segPopover.removeElement(),s.segPopover=null,s.popoverSegs=null}},this.isRTL?o.right=u.offset().left+u.outerWidth()+1:o.left=u.offset().left-1,this.segPopover=new a.default(o),this.segPopover.show(),this.bindAllSegHandlersToEl(this.segPopover.el),this.triggerAfterEventSegsRendered(i)},e.prototype.renderSegPopoverContent=function(t,e,n){var i,s=this.view,a=s.calendar.theme,l=this.getCellDate(t,e).format(this.opt("dayPopoverFormat")),u=r(''),d=u.find(".fc-event-container");for(n=this.eventRenderer.renderFgSegEls(n,!0),this.popoverSegs=n,i=0;i"+s.htmlEscape(this.opt("weekNumberTitle"))+"":""},e.prototype.renderNumberIntroHtml=function(t){var e=this.view,n=this.getCellDate(t,0);return this.colWeekNumbersVisible?'"+e.buildGotoAnchorHtml({date:n,type:"week",forceOff:1===this.colCnt},n.format("w"))+" | ":""},e.prototype.renderBgIntroHtml=function(){var t=this.view;return this.colWeekNumbersVisible?' | ":""},e.prototype.renderIntroHtml=function(){var t=this.view;return this.colWeekNumbersVisible?' | ":""},e.prototype.getIsNumbersVisible=function(){return d.default.prototype.getIsNumbersVisible.apply(this,arguments)||this.colWeekNumbersVisible},e}(t)}Object.defineProperty(e,"__esModule",{value:!0});var r=n(2),o=n(3),s=n(4),a=n(39),l=n(41),u=n(228),d=n(61),c=function(t){function e(e,n){var i=t.call(this,e,n)||this;return i.dayGrid=i.instantiateDayGrid(),i.dayGrid.isRigid=i.hasRigidRows(),i.opt("weekNumbers")&&(i.opt("weekNumbersWithinDays")?(i.dayGrid.cellWeekNumbersVisible=!0,i.dayGrid.colWeekNumbersVisible=!1):(i.dayGrid.cellWeekNumbersVisible=!1,i.dayGrid.colWeekNumbersVisible=!0)),i.addChild(i.dayGrid),i.scroller=new a.default({overflowX:"hidden",overflowY:"auto"}),i}return r.__extends(e,t),e.prototype.instantiateDayGrid=function(){return new(i(this.dayGridClass))(this)},e.prototype.executeDateRender=function(e){this.dayGrid.breakOnWeeks=/year|month|week/.test(e.currentRangeUnit),t.prototype.executeDateRender.call(this,e)},e.prototype.renderSkeleton=function(){var t,e;this.el.addClass("fc-basic-view").html(this.renderSkeletonHtml()),this.scroller.render(),t=this.scroller.el.addClass("fc-day-grid-container"),e=o('').appendTo(t),this.el.find(".fc-body > tr > td").append(t),this.dayGrid.headContainerEl=this.el.find(".fc-head-container"),this.dayGrid.setElement(e)},e.prototype.unrenderSkeleton=function(){this.dayGrid.removeElement(),this.scroller.destroy()},e.prototype.renderSkeletonHtml=function(){var t=this.calendar.theme;return''+(this.opt("columnHeader")?'| | ':"")+' | '},e.prototype.weekNumberStyleAttr=function(){return null!=this.weekNumberWidth?'style="width:'+this.weekNumberWidth+'px"':""},e.prototype.hasRigidRows=function(){var t=this.opt("eventLimit");return t&&"number"!=typeof t},e.prototype.updateSize=function(e,n,i){var r,o,a=this.opt("eventLimit"),l=this.dayGrid.headContainerEl.find(".fc-row");if(!this.dayGrid.rowEls)return void(n||(r=this.computeScrollerHeight(e),this.scroller.setHeight(r)));t.prototype.updateSize.call(this,e,n,i),this.dayGrid.colWeekNumbersVisible&&(this.weekNumberWidth=s.matchCellWidths(this.el.find(".fc-week-number"))),this.scroller.clear(),s.uncompensateScroll(l),this.dayGrid.removeSegPopover(),a&&"number"==typeof a&&this.dayGrid.limitRows(a),r=this.computeScrollerHeight(e),this.setGridHeight(r,n),a&&"number"!=typeof a&&this.dayGrid.limitRows(a),n||(this.scroller.setHeight(r),o=this.scroller.getScrollbarWidths(),(o.left||o.right)&&(s.compensateScroll(l,o),r=this.computeScrollerHeight(e),this.scroller.setHeight(r)),this.scroller.lockOverflow(o))},e.prototype.computeScrollerHeight=function(t){return t-s.subtractInnerElHeight(this.el,this.scroller.el)},e.prototype.setGridHeight=function(t,e){e?s.undistributeHeight(this.dayGrid.rowEls):s.distributeHeight(this.dayGrid.rowEls,t,!0)},e.prototype.computeInitialDateScroll=function(){return{top:0}},e.prototype.queryDateScroll=function(){return{top:this.scroller.getScrollTop()}},e.prototype.applyDateScroll=function(t){void 0!==t.top&&this.scroller.setScrollTop(t.top)},e}(l.default);e.default=c,c.prototype.dateProfileGeneratorClass=u.default,c.prototype.dayGridClass=d.default},,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,function(t,e,n){function i(t,e,n){var i;for(i=0;i=0;e--)switch(n=i[e],n.type){case"init":r=!1;case"add":case"remove":i.splice(e,1)}return r&&i.push(t),r},e}(r.default);e.default=o},function(t,e,n){function i(t){var e,n,i,r=[];for(e in t)for(n=t[e].eventInstances,i=0;i'+n+"":""+n+""},e.prototype.getAllDayHtml=function(){return this.opt("allDayHtml")||a.htmlEscape(this.opt("allDayText"))},e.prototype.getDayClasses=function(t,e){var n,i=this._getView(),r=[]
+;return this.dateProfile.activeUnzonedRange.containsDate(t)?(r.push("fc-"+a.dayIDs[t.day()]),i.isDateInOtherMonth(t,this.dateProfile)&&r.push("fc-other-month"),n=i.calendar.getNow(),t.isSame(n,"day")?(r.push("fc-today"),!0!==e&&r.push(i.calendar.theme.getClass("today"))):t=this.nextDayThreshold&&o.add(1,"days"),o<=n&&(o=n.clone().add(1,"days")),{start:n,end:o}},e.prototype.isMultiDayRange=function(t){var e=this.computeDayRange(t);return e.end.diff(e.start,"days")>1},e.guid=0,e}(d.default);e.default=p},function(t,e,n){function i(t,e){return null==e?t:r.isFunction(e)?t.filter(e):(e+="",t.filter(function(t){return t.id==e||t._id===e}))}Object.defineProperty(e,"__esModule",{value:!0});var r=n(3),o=n(0),s=n(4),a=n(32),l=n(238),u=n(21),d=n(11),c=n(7),p=n(239),h=n(240),f=n(241),g=n(207),v=n(31),y=n(10),m=n(5),b=n(12),w=n(17),D=n(242),E=n(212),S=n(38),C=n(49),R=n(13),T=n(37),M=n(6),I=n(51),H=function(){function t(t,e){this.loadingLevel=0,this.ignoreUpdateViewSize=0,this.freezeContentHeightDepth=0,u.default.needed(),this.el=t,this.viewsByType={},this.optionsManager=new h.default(this,e),this.viewSpecManager=new f.default(this.optionsManager,this),this.initMomentInternals(),this.initCurrentDate(),this.initEventManager(),this.constraints=new g.default(this.eventManager,this),this.constructed()}return t.prototype.constructed=function(){},t.prototype.getView=function(){return this.view},t.prototype.publiclyTrigger=function(t,e){var n,i,o=this.opt(t);if(r.isPlainObject(e)?(n=e.context,i=e.args):r.isArray(e)&&(i=e),null==n&&(n=this.el[0]),i||(i=[]),this.triggerWith(t,n,i),o)return o.apply(n,i)},t.prototype.hasPublicHandlers=function(t){return this.hasHandlers(t)||this.opt(t)},t.prototype.option=function(t,e){var n;if("string"==typeof t){if(void 0===e)return this.optionsManager.get(t);n={},n[t]=e,this.optionsManager.add(n)}else"object"==typeof t&&this.optionsManager.add(t)},t.prototype.opt=function(t){return this.optionsManager.get(t)},t.prototype.instantiateView=function(t){var e=this.viewSpecManager.getViewSpec(t);if(!e)throw new Error('View type "'+t+'" is not valid');return new e.class(this,e)},t.prototype.isValidViewType=function(t){return Boolean(this.viewSpecManager.getViewSpec(t))},t.prototype.changeView=function(t,e){e&&(e.start&&e.end?this.optionsManager.recordOverrides({visibleRange:e}):this.currentDate=this.moment(e).stripZone()),this.renderView(t)},t.prototype.zoomTo=function(t,e){var n;e=e||"day",n=this.viewSpecManager.getViewSpec(e)||this.viewSpecManager.getUnitViewSpec(e),this.currentDate=t.clone(),this.renderView(n?n.type:null)},t.prototype.initCurrentDate=function(){var t=this.opt("defaultDate");this.currentDate=null!=t?this.moment(t).stripZone():this.getNow()},t.prototype.prev=function(){var t=this.view,e=t.dateProfileGenerator.buildPrev(t.get("dateProfile"));e.isValid&&(this.currentDate=e.date,this.renderView())},t.prototype.next=function(){var t=this.view,e=t.dateProfileGenerator.buildNext(t.get("dateProfile"));e.isValid&&(this.currentDate=e.date,this.renderView())},t.prototype.prevYear=function(){this.currentDate.add(-1,"years"),this.renderView()},t.prototype.nextYear=function(){this.currentDate.add(1,"years"),this.renderView()},t.prototype.today=function(){this.currentDate=this.getNow(),this.renderView()},t.prototype.gotoDate=function(t){this.currentDate=this.moment(t).stripZone(),this.renderView()},t.prototype.incrementDate=function(t){this.currentDate.add(o.duration(t)),this.renderView()},t.prototype.getDate=function(){return this.applyTimezone(this.currentDate)},t.prototype.pushLoading=function(){this.loadingLevel++||this.publiclyTrigger("loading",[!0,this.view])},t.prototype.popLoading=function(){--this.loadingLevel||this.publiclyTrigger("loading",[!1,this.view])},t.prototype.render=function(){this.contentEl?this.elementVisible()&&(this.calcSize(),this.updateViewSize()):this.initialRender()},t.prototype.initialRender=function(){var t=this,e=this.el;e.addClass("fc"),e.on("click.fc","a[data-goto]",function(e){var n=r(e.currentTarget),i=n.data("goto"),o=t.moment(i.date),a=i.type,l=t.view.opt("navLink"+s.capitaliseFirstLetter(a)+"Click");"function"==typeof l?l(o,e):("string"==typeof l&&(a=l),t.zoomTo(o,a))}),this.optionsManager.watch("settingTheme",["?theme","?themeSystem"],function(n){var i=I.getThemeSystemClass(n.themeSystem||n.theme),r=new i(t.optionsManager),o=r.getClass("widget");t.theme=r,o&&e.addClass(o)},function(){var n=t.theme.getClass("widget");t.theme=null,n&&e.removeClass(n)}),this.optionsManager.watch("settingBusinessHourGenerator",["?businessHours"],function(e){t.businessHourGenerator=new E.default(e.businessHours,t),t.view&&t.view.set("businessHourGenerator",t.businessHourGenerator)},function(){t.businessHourGenerator=null}),this.optionsManager.watch("applyingDirClasses",["?isRTL","?locale"],function(t){e.toggleClass("fc-ltr",!t.isRTL),e.toggleClass("fc-rtl",t.isRTL)}),this.contentEl=r("").prependTo(e),this.initToolbars(),this.renderHeader(),this.renderFooter(),this.renderView(this.opt("defaultView")),this.opt("handleWindowResize")&&r(window).resize(this.windowResizeProxy=s.debounce(this.windowResize.bind(this),this.opt("windowResizeDelay")))},t.prototype.destroy=function(){this.view&&this.clearView(),this.toolbarsManager.proxyCall("removeElement"),this.contentEl.remove(),this.el.removeClass("fc fc-ltr fc-rtl"),this.optionsManager.unwatch("settingTheme"),this.optionsManager.unwatch("settingBusinessHourGenerator"),this.el.off(".fc"),this.windowResizeProxy&&(r(window).unbind("resize",this.windowResizeProxy),this.windowResizeProxy=null),u.default.unneeded()},t.prototype.elementVisible=function(){return this.el.is(":visible")},t.prototype.bindViewHandlers=function(t){var e=this;t.watch("titleForCalendar",["title"],function(n){t===e.view&&e.setToolbarsTitle(n.title)}),t.watch("dateProfileForCalendar",["dateProfile"],function(n){t===e.view&&(e.currentDate=n.dateProfile.date,e.updateToolbarButtons(n.dateProfile))})},t.prototype.unbindViewHandlers=function(t){t.unwatch("titleForCalendar"),t.unwatch("dateProfileForCalendar")},t.prototype.renderView=function(t){var e,n=this.view;this.freezeContentHeight(),n&&t&&n.type!==t&&this.clearView(),!this.view&&t&&(e=this.view=this.viewsByType[t]||(this.viewsByType[t]=this.instantiateView(t)),this.bindViewHandlers(e),e.startBatchRender(),e.setElement(r("").appendTo(this.contentEl)),this.toolbarsManager.proxyCall("activateButton",t)),this.view&&(this.view.get("businessHourGenerator")!==this.businessHourGenerator&&this.view.set("businessHourGenerator",this.businessHourGenerator),this.view.setDate(this.currentDate),e&&e.stopBatchRender()),this.thawContentHeight()},t.prototype.clearView=function(){var t=this.view;this.toolbarsManager.proxyCall("deactivateButton",t.type),this.unbindViewHandlers(t),t.removeElement(),t.unsetDate(),this.view=null},t.prototype.reinitView=function(){var t=this.view,e=t.queryScroll();this.freezeContentHeight(),this.clearView(),this.calcSize(),this.renderView(t.type),this.view.applyScroll(e),this.thawContentHeight()},t.prototype.getSuggestedViewHeight=function(){return null==this.suggestedViewHeight&&this.calcSize(),this.suggestedViewHeight},t.prototype.isHeightAuto=function(){return"auto"===this.opt("contentHeight")||"auto"===this.opt("height")},t.prototype.updateViewSize=function(t){void 0===t&&(t=!1);var e,n=this.view;if(!this.ignoreUpdateViewSize&&n)return t&&(this.calcSize(),e=n.queryScroll()),this.ignoreUpdateViewSize++,n.updateSize(this.getSuggestedViewHeight(),this.isHeightAuto(),t),this.ignoreUpdateViewSize--,t&&n.applyScroll(e),!0},t.prototype.calcSize=function(){this.elementVisible()&&this._calcSize()},t.prototype._calcSize=function(){var t=this.opt("contentHeight"),e=this.opt("height");this.suggestedViewHeight="number"==typeof t?t:"function"==typeof t?t():"number"==typeof e?e-this.queryToolbarsHeight():"function"==typeof e?e()-this.queryToolbarsHeight():"parent"===e?this.el.parent().height()-this.queryToolbarsHeight():Math.round(this.contentEl.width()/Math.max(this.opt("aspectRatio"),.5))},t.prototype.windowResize=function(t){t.target===window&&this.view&&this.view.isDatesRendered&&this.updateViewSize(!0)&&this.publiclyTrigger("windowResize",[this.view])},t.prototype.freezeContentHeight=function(){this.freezeContentHeightDepth++||this.forceFreezeContentHeight()},t.prototype.forceFreezeContentHeight=function(){this.contentEl.css({width:"100%",height:this.contentEl.height(),overflow:"hidden"})},t.prototype.thawContentHeight=function(){this.freezeContentHeightDepth--,this.contentEl.css({width:"",height:"",overflow:""}),this.freezeContentHeightDepth&&this.forceFreezeContentHeight()},t.prototype.initToolbars=function(){this.header=new p.default(this,this.computeHeaderOptions()),this.footer=new p.default(this,this.computeFooterOptions()),this.toolbarsManager=new l.default([this.header,this.footer])},t.prototype.computeHeaderOptions=function(){return{extraClasses:"fc-header-toolbar",layout:this.opt("header")}},t.prototype.computeFooterOptions=function(){return{extraClasses:"fc-footer-toolbar",layout:this.opt("footer")}},t.prototype.renderHeader=function(){var t=this.header;t.setToolbarOptions(this.computeHeaderOptions()),t.render(),t.el&&this.el.prepend(t.el)},t.prototype.renderFooter=function(){var t=this.footer;t.setToolbarOptions(this.computeFooterOptions()),t.render(),t.el&&this.el.append(t.el)},t.prototype.setToolbarsTitle=function(t){this.toolbarsManager.proxyCall("updateTitle",t)},t.prototype.updateToolbarButtons=function(t){var e=this.getNow(),n=this.view,i=n.dateProfileGenerator.build(e),r=n.dateProfileGenerator.buildPrev(n.get("dateProfile")),o=n.dateProfileGenerator.buildNext(n.get("dateProfile"));this.toolbarsManager.proxyCall(i.isValid&&!t.currentUnzonedRange.containsDate(e)?"enableButton":"disableButton","today"),this.toolbarsManager.proxyCall(r.isValid?"enableButton":"disableButton","prev"),this.toolbarsManager.proxyCall(o.isValid?"enableButton":"disableButton","next")},t.prototype.queryToolbarsHeight=function(){return this.toolbarsManager.items.reduce(function(t,e){return t+(e.el?e.el.outerHeight(!0):0)},0)},t.prototype.select=function(t,e){this.view.select(this.buildSelectFootprint.apply(this,arguments))},t.prototype.unselect=function(){this.view&&this.view.unselect()},t.prototype.buildSelectFootprint=function(t,e){var n,i=this.moment(t).stripZone();return n=e?this.moment(e).stripZone():i.hasTime()?i.clone().add(this.defaultTimedEventDuration):i.clone().add(this.defaultAllDayEventDuration),new b.default(new m.default(i,n),!i.hasTime())},t.prototype.initMomentInternals=function(){var t=this;this.defaultAllDayEventDuration=o.duration(this.opt("defaultAllDayEventDuration")),this.defaultTimedEventDuration=o.duration(this.opt("defaultTimedEventDuration")),this.optionsManager.watch("buildingMomentLocale",["?locale","?monthNames","?monthNamesShort","?dayNames","?dayNamesShort","?firstDay","?weekNumberCalculation"],function(e){var n,i=e.weekNumberCalculation,r=e.firstDay;"iso"===i&&(i="ISO");var o=Object.create(v.getMomentLocaleData(e.locale));e.monthNames&&(o._months=e.monthNames),e.monthNamesShort&&(o._monthsShort=e.monthNamesShort),e.dayNames&&(o._weekdays=e.dayNames),e.dayNamesShort&&(o._weekdaysShort=e.dayNamesShort),null==r&&"ISO"===i&&(r=1),null!=r&&(n=Object.create(o._week),n.dow=r,o._week=n),"ISO"!==i&&"local"!==i&&"function"!=typeof i||(o._fullCalendar_weekCalc=i),t.localeData=o,t.currentDate&&t.localizeMoment(t.currentDate)})},t.prototype.moment=function(){for(var t=[],e=0;e864e5&&r.time(n-864e5)),new o.default(i,r)},t.prototype.buildRangeFromDuration=function(t,e,n,s){function a(){d=t.clone().startOf(h),c=d.clone().add(n),p=new o.default(d,c)}var l,u,d,c,p,h=this.opt("dateAlignment");return h||(l=this.opt("dateIncrement"),l?(u=i.duration(l),h=uo.getStart()&&(i=new a.default,i.setEndDelta(l),r=new s.default,r.setDateMutation(i),r)},e}(u.default);e.default=d},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(4),o=n(37),s=n(50),a=n(54),l=n(23),u=n(244),d=n(15),c=function(t){function e(e,n){var i=t.call(this,e)||this;return i.isDragging=!1,i.eventPointing=n,i}return i.__extends(e,t),e.prototype.end=function(){this.dragListener&&this.dragListener.endInteraction()},e.prototype.getSelectionDelay=function(){var t=this.opt("eventLongPressDelay");return null==t&&(t=this.opt("longPressDelay")),t},e.prototype.bindToEl=function(t){var e=this.component;e.bindSegHandlerToEl(t,"mousedown",this.handleMousedown.bind(this)),e.bindSegHandlerToEl(t,"touchstart",this.handleTouchStart.bind(this))},e.prototype.handleMousedown=function(t,e){!this.component.shouldIgnoreMouse()&&this.component.canStartDrag(t,e)&&this.buildDragListener(t).startInteraction(e,{distance:5})},e.prototype.handleTouchStart=function(t,e){var n=this.component,i={delay:this.view.isEventDefSelected(t.footprint.eventDef)?0:this.getSelectionDelay()};n.canStartDrag(t,e)?this.buildDragListener(t).startInteraction(e,i):n.canStartSelection(t,e)&&this.buildSelectListener(t).startInteraction(e,i)},e.prototype.buildSelectListener=function(t){var e=this,n=this.view,i=t.footprint.eventDef,r=t.footprint.eventInstance;if(this.dragListener)return this.dragListener;var o=this.dragListener=new a.default({dragStart:function(t){o.isTouch&&!n.isEventDefSelected(i)&&r&&n.selectEventInstance(r)},interactionEnd:function(t){e.dragListener=null}});return o},e.prototype.buildDragListener=function(t){var e,n,i,o=this,s=this.component,a=this.view,d=a.calendar,c=d.eventManager,p=t.el,h=t.footprint.eventDef,f=t.footprint.eventInstance;if(this.dragListener)return this.dragListener;var g=this.dragListener=new l.default(a,{scroll:this.opt("dragScroll"),subjectEl:p,subjectCenter:!0,interactionStart:function(i){t.component=s,e=!1,n=new u.default(t.el,{additionalClass:"fc-dragging",parentEl:a.el,opacity:g.isTouch?null:o.opt("dragOpacity"),revertDuration:o.opt("dragRevertDuration"),zIndex:2}),n.hide(),n.start(i)},dragStart:function(n){g.isTouch&&!a.isEventDefSelected(h)&&f&&a.selectEventInstance(f),e=!0,o.eventPointing.handleMouseout(t,n),o.segDragStart(t,n),a.hideEventsWithId(t.footprint.eventDef.id)},hitOver:function(e,l,u){var p,f,v,y=!0;t.hit&&(u=t.hit),p=u.component.getSafeHitFootprint(u),f=e.component.getSafeHitFootprint(e),p&&f?(i=o.computeEventDropMutation(p,f,h),i?(v=c.buildMutatedEventInstanceGroup(h.id,i),y=s.isEventInstanceGroupAllowed(v)):y=!1):y=!1,y||(i=null,r.disableCursor()),i&&a.renderDrag(s.eventRangesToEventFootprints(v.sliceRenderRanges(s.dateProfile.renderUnzonedRange,d)),t,g.isTouch)?n.hide():n.show(),l&&(i=null)},hitOut:function(){a.unrenderDrag(t),n.show(),i=null},hitDone:function(){r.enableCursor()},interactionEnd:function(r){delete t.component,n.stop(!i,function(){e&&(a.unrenderDrag(t),o.segDragStop(t,r)),a.showEventsWithId(t.footprint.eventDef.id),i&&a.reportEventDrop(f,i,p,r)}),o.dragListener=null}});return g},e.prototype.segDragStart=function(t,e){this.isDragging=!0,this.component.publiclyTrigger("eventDragStart",{context:t.el[0],args:[t.footprint.getEventLegacy(),e,{},this.view]})},e.prototype.segDragStop=function(t,e){this.isDragging=!1,this.component.publiclyTrigger("eventDragStop",{context:t.el[0],args:[t.footprint.getEventLegacy(),e,{},this.view]})},e.prototype.computeEventDropMutation=function(t,e,n){var i=new o.default;return i.setDateMutation(this.computeEventDateMutation(t,e)),i},e.prototype.computeEventDateMutation=function(t,e){var n,i,r=t.unzonedRange.getStart(),o=e.unzonedRange.getStart(),a=!1,l=!1,u=!1;return t.isAllDay!==e.isAllDay&&(a=!0,e.isAllDay?(u=!0,r.stripTime()):l=!0),n=this.component.diffDates(o,r),i=new s.default,i.clearEnd=a,i.forceTimed=l,i.forceAllDay=u,i.setDateDelta(n),i},e}(d.default);e.default=c},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(4),o=n(23),s=n(12),a=n(5),l=n(15),u=function(t){function e(e){var n=t.call(this,e)||this;return n.dragListener=n.buildDragListener(),n}return i.__extends(e,t),e.prototype.end=function(){this.dragListener.endInteraction()},e.prototype.getDelay=function(){var t=this.opt("selectLongPressDelay");return null==t&&(t=this.opt("longPressDelay")),t},e.prototype.bindToEl=function(t){var e=this,n=this.component,i=this.dragListener;n.bindDateHandlerToEl(t,"mousedown",function(t){e.opt("selectable")&&!n.shouldIgnoreMouse()&&i.startInteraction(t,{distance:e.opt("selectMinDistance")})}),n.bindDateHandlerToEl(t,"touchstart",function(t){e.opt("selectable")&&!n.shouldIgnoreTouch()&&i.startInteraction(t,{delay:e.getDelay()})}),r.preventSelection(t)},e.prototype.buildDragListener=function(){var t,e=this,n=this.component;return new o.default(n,{scroll:this.opt("dragScroll"),interactionStart:function(){t=null},dragStart:function(t){e.view.unselect(t)},hitOver:function(i,o,s){var a,l;s&&(a=n.getSafeHitFootprint(s),l=n.getSafeHitFootprint(i),t=a&&l?e.computeSelection(a,l):null,t?n.renderSelectionFootprint(t):!1===t&&r.disableCursor())},hitOut:function(){t=null,n.unrenderSelection()},hitDone:function(){r.enableCursor()},interactionEnd:function(n,i){!i&&t&&e.view.reportSelection(t,n)}})},e.prototype.computeSelection=function(t,e){var n=this.computeSelectionFootprint(t,e);return!(n&&!this.isSelectionFootprintAllowed(n))&&n},e.prototype.computeSelectionFootprint=function(t,e){var n=[t.unzonedRange.startMs,t.unzonedRange.endMs,e.unzonedRange.startMs,e.unzonedRange.endMs];return n.sort(r.compareNumbers),new s.default(new a.default(n[0],n[3]),t.isAllDay)},e.prototype.isSelectionFootprintAllowed=function(t){return this.component.dateProfile.validUnzonedRange.containsRange(t.unzonedRange)&&this.view.calendar.constraints.isSelectionFootprintAllowed(t)},e}(l.default);e.default=u},function(t,e,n){function i(t){var e,n=[],i=[];for(e=0;e').appendTo(t),this.el.find(".fc-body > tr > td").append(t),this.timeGrid.headContainerEl=this.el.find(".fc-head-container"),this.timeGrid.setElement(e),this.dayGrid&&(this.dayGrid.setElement(this.el.find(".fc-day-grid")),this.dayGrid.bottomCoordPadding=this.dayGrid.el.next("hr").outerHeight())},e.prototype.unrenderSkeleton=function(){this.timeGrid.removeElement(),this.dayGrid&&this.dayGrid.removeElement(),this.scroller.destroy()},e.prototype.renderSkeletonHtml=function(){var t=this.calendar.theme;return''+(this.opt("columnHeader")?'| | ':"")+''+(this.dayGrid?'
':"")+" | "},e.prototype.axisStyleAttr=function(){return null!=this.axisWidth?'style="width:'+this.axisWidth+'px"':""},e.prototype.getNowIndicatorUnit=function(){return this.timeGrid.getNowIndicatorUnit()},e.prototype.updateSize=function(e,n,i){var r,o,s;if(t.prototype.updateSize.call(this,e,n,i),this.axisWidth=u.matchCellWidths(this.el.find(".fc-axis")),!this.timeGrid.colEls)return void(n||(o=this.computeScrollerHeight(e),this.scroller.setHeight(o)));var a=this.el.find(".fc-row:not(.fc-scroller *)");this.timeGrid.bottomRuleEl.hide(),this.scroller.clear(),u.uncompensateScroll(a),this.dayGrid&&(this.dayGrid.removeSegPopover(),r=this.opt("eventLimit"),r&&"number"!=typeof r&&(r=5),r&&this.dayGrid.limitRows(r)),n||(o=this.computeScrollerHeight(e),this.scroller.setHeight(o),s=this.scroller.getScrollbarWidths(),(s.left||s.right)&&(u.compensateScroll(a,s),o=this.computeScrollerHeight(e),this.scroller.setHeight(o)),this.scroller.lockOverflow(s),this.timeGrid.getTotalSlatHeight()"+e.buildGotoAnchorHtml({date:i,type:"week",forceOff:this.colCnt>1},u.htmlEscape(t))+""):' | "},renderBgIntroHtml:function(){var t=this.view;return' | "},renderIntroHtml:function(){return' | "}},o={renderBgIntroHtml:function(){var t=this.view;return'"+t.getAllDayHtml()+" | "},renderIntroHtml:function(){return' | "}}},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(3),o=n(0),s=n(4),a=n(40),l=n(56),u=n(60),d=n(55),c=n(53),p=n(5),h=n(12),f=n(246),g=n(247),v=n(248),y=[{hours:1},{minutes:30},{minutes:15},{seconds:30},{seconds:15}],m=function(t){function e(e){var n=t.call(this,e)||this;return n.processOptions(),n}return i.__extends(e,t),e.prototype.componentFootprintToSegs=function(t){var e,n=this.sliceRangeByTimes(t.unzonedRange);for(e=0;e=0;e--)if(n=o.duration(y[e]),i=s.divideDurationByDuration(n,t),s.isInt(i)&&i>1)return n;return o.duration(t)},e.prototype.renderDates=function(t){this.dateProfile=t,this.updateDayTable(),this.renderSlats(),this.renderColumns()},e.prototype.unrenderDates=function(){this.unrenderColumns()},e.prototype.renderSkeleton=function(){var t=this.view.calendar.theme;this.el.html('
'),this.bottomRuleEl=this.el.find("hr")},e.prototype.renderSlats=function(){var t=this.view.calendar.theme;this.slatContainerEl=this.el.find("> .fc-slats").html(''+this.renderSlatRowHtml()+" "),this.slatEls=this.slatContainerEl.find("tr"),this.slatCoordCache=new c.default({els:this.slatEls,isVertical:!0})},e.prototype.renderSlatRowHtml=function(){for(var t,e,n,i=this.view,r=i.calendar,a=r.theme,l=this.isRTL,u=this.dateProfile,d="",c=o.duration(+u.minTime),p=o.duration(0);c"+(e?""+s.htmlEscape(t.format(this.labelFormat))+"":"")+"",d+='"+(l?"":n)+' | '+(l?n:"")+" ",c.add(this.slotDuration),p.add(this.slotDuration);return d},e.prototype.renderColumns=function(){var t=this.dateProfile,e=this.view.calendar.theme;this.dayRanges=this.dayDates.map(function(e){return new p.default(e.clone().add(t.minTime),e.clone().add(t.maxTime))}),this.headContainerEl&&this.headContainerEl.html(this.renderHeadHtml()),this.el.find("> .fc-bg").html(''+this.renderBgTrHtml(0)+" "),this.colEls=this.el.find(".fc-day, .fc-disabled-day"),this.colCoordCache=new c.default({els:this.colEls,isHorizontal:!0}),this.renderContentSkeleton()},e.prototype.unrenderColumns=function(){this.unrenderContentSkeleton()},e.prototype.renderContentSkeleton=function(){var t,e,n="";for(t=0;t';e=this.contentSkeletonEl=r('"),this.colContainerEls=e.find(".fc-content-col"),this.helperContainerEls=e.find(".fc-helper-container"),this.fgContainerEls=e.find(".fc-event-container:not(.fc-helper-container)"),this.bgContainerEls=e.find(".fc-bgevent-container"),this.highlightContainerEls=e.find(".fc-highlight-container"),this.businessContainerEls=e.find(".fc-business-container"),this.bookendCells(e.find("tr")),this.el.append(e)},e.prototype.unrenderContentSkeleton=function(){this.contentSkeletonEl&&(this.contentSkeletonEl.remove(),this.contentSkeletonEl=null,this.colContainerEls=null,this.helperContainerEls=null,this.fgContainerEls=null,this.bgContainerEls=null,this.highlightContainerEls=null,this.businessContainerEls=null)},e.prototype.groupSegsByCol=function(t){var e,n=[];for(e=0;e').css("top",i).appendTo(this.colContainerEls.eq(n[e].col))[0]);n.length>0&&o.push(r('').css("top",i).appendTo(this.el.find(".fc-content-skeleton"))[0]),this.nowIndicatorEls=r(o)}},e.prototype.unrenderNowIndicator=function(){this.nowIndicatorEls&&(this.nowIndicatorEls.remove(),this.nowIndicatorEls=null)},e.prototype.updateSize=function(e,n,i){t.prototype.updateSize.call(this,e,n,i),this.slatCoordCache.build(),i&&this.updateSegVerticals([].concat(this.eventRenderer.getSegs(),this.businessSegs||[]))},e.prototype.getTotalSlatHeight=function(){return this.slatContainerEl.outerHeight()},e.prototype.computeDateTop=function(t,e){return this.computeTimeTop(o.duration(t-e.clone().stripTime()))},e.prototype.computeTimeTop=function(t){var e,n,i=this.slatEls.length,r=this.dateProfile,o=(t-r.minTime)/this.slotDuration;return o=Math.max(0,o),o=Math.min(i,o),e=Math.floor(o),e=Math.min(e,i-1),n=o-e,this.slatCoordCache.getTopPosition(e)+this.slatCoordCache.getHeight(e)*n},e.prototype.updateSegVerticals=function(t){this.computeSegVerticals(t),this.assignSegVerticals(t)},e.prototype.computeSegVerticals=function(t){var e,n,i,r=this.opt("agendaEventMinHeight");for(e=0;e'+o.htmlEscape(this.opt("noEventsMessage"))+" '+(e?this.buildGotoAnchorHtml(t,{class:"fc-list-heading-main"},o.htmlEscape(t.format(e))):"")+(n?this.buildGotoAnchorHtml(t,{class:"fc-list-heading-alt"},o.htmlEscape(t.format(n))):"")+" | "},e}(a.default);e.default=c,c.prototype.eventRendererClass=u.default,c.prototype.eventPointingClass=d.default},,,,,,function(t,e,n){var i=n(3),r=n(16),o=n(4),s=n(220);n(10),n(47),n(256),n(257),n(260),n(261),n(262),n(263),i.fullCalendar=r,i.fn.fullCalendar=function(t){var e=Array.prototype.slice.call(arguments,1),n=this;return this.each(function(r,a){var l,u=i(a),d=u.data("fullCalendar");"string"==typeof t?"getCalendar"===t?r||(n=d):"destroy"===t?d&&(d.destroy(),u.removeData("fullCalendar")):d?i.isFunction(d[t])?(l=d[t].apply(d,e),r||(n=l),"destroy"===t&&u.removeData("fullCalendar")):o.warn("'"+t+"' is an unknown FullCalendar method."):o.warn("Attempting to call a FullCalendar method on an element with no calendar."):d||(d=new s.default(u,t),u.data("fullCalendar",d),d.render())}),n},t.exports=r},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(48),o=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return i.__extends(e,t),e.prototype.setElement=function(t){this.el=t,this.bindGlobalHandlers(),this.renderSkeleton(),this.set("isInDom",!0)},e.prototype.removeElement=function(){this.unset("isInDom"),this.unrenderSkeleton(),this.unbindGlobalHandlers(),this.el.remove()},e.prototype.bindGlobalHandlers=function(){},e.prototype.unbindGlobalHandlers=function(){},e.prototype.renderSkeleton=function(){},e.prototype.unrenderSkeleton=function(){},e}(r.default);e.default=o},function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=function(){function t(t){this.items=t||[]}return t.prototype.proxyCall=function(t){for(var e=[],n=1;n"),e.append(this.renderSection("left")).append(this.renderSection("right")).append(this.renderSection("center")).append('')):this.removeElement()},t.prototype.removeElement=function(){this.el&&(this.el.remove(),this.el=null)},t.prototype.renderSection=function(t){var e=this,n=this.calendar,o=n.theme,s=n.optionsManager,a=n.viewSpecManager,l=i(''),u=this.toolbarOptions.layout[t],d=s.get("customButtons")||{},c=s.overrides.buttonText||{},p=s.get("buttonText")||{};return u&&i.each(u.split(" "),function(t,s){var u,h=i(),f=!0;i.each(s.split(","),function(t,s){var l,u,g,v,y,m,b,w,D;"title"===s?(h=h.add(i(" ")),f=!1):((l=d[s])?(g=function(t){l.click&&l.click.call(w[0],t)},(v=o.getCustomButtonIconClass(l))||(v=o.getIconClass(s))||(y=l.text)):(u=a.getViewSpec(s))?(e.viewsWithButtons.push(s),g=function(){n.changeView(s)},(y=u.buttonTextOverride)||(v=o.getIconClass(s))||(y=u.buttonTextDefault)):n[s]&&(g=function(){n[s]()},(y=c[s])||(v=o.getIconClass(s))||(y=p[s])),g&&(b=["fc-"+s+"-button",o.getClass("button"),o.getClass("stateDefault")],y?(m=r.htmlEscape(y),D=""):v&&(m="",D=' aria-label="'+s+'"'),w=i('").click(function(t){w.hasClass(o.getClass("stateDisabled"))||(g(t),(w.hasClass(o.getClass("stateActive"))||w.hasClass(o.getClass("stateDisabled")))&&w.removeClass(o.getClass("stateHover")))}).mousedown(function(){w.not("."+o.getClass("stateActive")).not("."+o.getClass("stateDisabled")).addClass(o.getClass("stateDown"))}).mouseup(function(){w.removeClass(o.getClass("stateDown"))}).hover(function(){w.not("."+o.getClass("stateActive")).not("."+o.getClass("stateDisabled")).addClass(o.getClass("stateHover"))},function(){w.removeClass(o.getClass("stateHover")).removeClass(o.getClass("stateDown"))}),h=h.add(w)))}),f&&h.first().addClass(o.getClass("cornerLeft")).end().last().addClass(o.getClass("cornerRight")).end(),h.length>1?(u=i(""),f&&u.addClass(o.getClass("buttonGroup")),u.append(h),l.append(u)):l.append(h)}),l},t.prototype.updateTitle=function(t){this.el&&this.el.find("h2").text(t)},t.prototype.activateButton=function(t){this.el&&this.el.find(".fc-"+t+"-button").addClass(this.calendar.theme.getClass("stateActive"))},t.prototype.deactivateButton=function(t){this.el&&this.el.find(".fc-"+t+"-button").removeClass(this.calendar.theme.getClass("stateActive"))},t.prototype.disableButton=function(t){this.el&&this.el.find(".fc-"+t+"-button").prop("disabled",!0).addClass(this.calendar.theme.getClass("stateDisabled"))},t.prototype.enableButton=function(t){this.el&&this.el.find(".fc-"+t+"-button").prop("disabled",!1).removeClass(this.calendar.theme.getClass("stateDisabled"))},t.prototype.getViewsWithButtons=function(){return this.viewsWithButtons},t}();e.default=o},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(3),o=n(4),s=n(32),a=n(31),l=n(48),u=function(t){function e(e,n){var i=t.call(this)||this;return i._calendar=e,i.overrides=r.extend({},n),i.dynamicOverrides={},i.compute(),i}return i.__extends(e,t),e.prototype.add=function(t){var e,n=0;this.recordOverrides(t);for(e in t)n++;if(1===n){if("height"===e||"contentHeight"===e||"aspectRatio"===e)return void this._calendar.updateViewSize(!0);if("defaultDate"===e)return;if("businessHours"===e)return;if(/^(event|select)(Overlap|Constraint|Allow)$/.test(e))return;if("timezone"===e)return void this._calendar.view.flash("initialEvents")}this._calendar.renderHeader(),this._calendar.renderFooter(),this._calendar.viewsByType={},this._calendar.reinitView()},e.prototype.compute=function(){var t,e,n,i,r;t=o.firstDefined(this.dynamicOverrides.locale,this.overrides.locale),e=a.localeOptionHash[t],e||(t=s.globalDefaults.locale,e=a.localeOptionHash[t]||{}),n=o.firstDefined(this.dynamicOverrides.isRTL,this.overrides.isRTL,e.isRTL,s.globalDefaults.isRTL),i=n?s.rtlDefaults:{},this.dirDefaults=i,this.localeDefaults=e,r=s.mergeOptions([s.globalDefaults,i,e,this.overrides,this.dynamicOverrides]),a.populateInstanceComputableOptions(r),this.reset(r)},e.prototype.recordOverrides=function(t){var e;for(e in t)this.dynamicOverrides[e]=t[e];this._calendar.viewSpecManager.clearCache(),this.compute()},e}(l.default);e.default=u},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(0),r=n(3),o=n(22),s=n(4),a=n(32),l=n(31),u=function(){function t(t,e){this.optionsManager=t,this._calendar=e,this.clearCache()}return t.prototype.clearCache=function(){this.viewSpecCache={}},t.prototype.getViewSpec=function(t){var e=this.viewSpecCache;return e[t]||(e[t]=this.buildViewSpec(t))},t.prototype.getUnitViewSpec=function(t){var e,n,i;if(-1!==r.inArray(t,s.unitsDesc))for(e=this._calendar.header.getViewsWithButtons(),r.each(o.viewHash,function(t){e.push(t)}),n=0;ne.top&&t.top'+(n?' '+u.htmlEscape(n)+" ":"")+(d.title?' '+u.htmlEscape(d.title)+" ":"")+' '+(this.dayGrid.isRTL?i+" "+h:h+" "+i)+" "+(u?'':"")+(d?'':"")+""},e}(l.default);e.default=u},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(3),o=n(58),s=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return i.__extends(e,t),e.prototype.renderSegs=function(t,e){var n,i=[];return n=this.eventRenderer.renderSegRows(t),this.component.rowEls.each(function(t,o){var s,a,l=r(o),u=r('');e&&e.row===t?a=e.el.position().top:(s=l.find(".fc-content-skeleton tbody"),s.length||(s=l.find(".fc-content-skeleton table")),a=s.position().top),u.css("top",a).find("table").append(n[t].tbodyEl),l.append(u),i.push(u[0])}),r(i)},e}(o.default);e.default=s},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(3),o=n(57),s=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.fillSegTag="td",e}return i.__extends(e,t),e.prototype.attachSegEls=function(t,e){var n,i,r,o=[];for(n=0;n | | '),o.append(e.el.attr("colspan",l-a)),l'),this.component.bookendCells(o),i},e}(o.default);e.default=s},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(228),o=n(5),s=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return i.__extends(e,t),e.prototype.buildRenderRange=function(e,n,i){var r,s=t.prototype.buildRenderRange.call(this,e,n,i),a=this.msToUtcMoment(s.startMs,i),l=this.msToUtcMoment(s.endMs,i);return this.opt("fixedWeekCount")&&(r=Math.ceil(l.diff(a,"weeks",!0)),l.add(6-r,"weeks")),new o.default(a,l)},e}(r.default);e.default=s},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var i=n(2),r=n(4),o=n(42),s=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return i.__extends(e,t),e.prototype.renderFgSegs=function(t){t.length?this.component.renderSegList(t):this.component.renderEmptyMessage()},e.prototype.fgSegHtml=function(t){var e,n=this.view,i=n.calendar,o=i.theme,s=t.footprint,a=s.eventDef,l=s.componentFootprint,u=a.url,d=["fc-list-item"].concat(this.getClasses(a)),c=this.getBgColor(a);return e=l.isAllDay?n.getAllDayHtml():n.isMultiDayRange(l.unzonedRange)?t.isStart||t.isEnd?r.htmlEscape(this._getTimeText(i.msToMoment(t.startMs),i.msToMoment(t.endMs),l.isAllDay)):n.getAllDayHtml():r.htmlEscape(this.getTimeText(s)),u&&d.push("fc-has-url"),'