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);
/***/ }),
/* 67 */
/***/ (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__(41);
var View_1 = __webpack_require__(43);
var BasicViewDateProfileGenerator_1 = __webpack_require__(68);
var DayGrid_1 = __webpack_require__(66);
/* 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) { // should we force dimensions of the scroll container?
this.scroller.setHeight(scrollerHeight);
scrollbarWidths = this.scroller.getScrollbarWidths();
if (scrollbarWidths.left || scrollbarWidths.right) { // using scrollbars?
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));
}
/***/ }),
/* 68 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = __webpack_require__(2);
var UnzonedRange_1 = __webpack_require__(5);
var DateProfileGenerator_1 = __webpack_require__(55);
var BasicViewDateProfileGenerator = /** @class */ (function (_super) {
tslib_1.__extends(BasicViewDateProfileGenerator, _super);
function BasicViewDateProfileGenerator() {
return _super !== null && _super.apply(this, arguments) || this;
}
// Computes the date range that will be rendered.
BasicViewDateProfileGenerator.prototype.buildRenderRange = function (currentUnzonedRange, currentRangeUnit, isRangeAllDay) {
var renderUnzonedRange = _super.prototype.buildRenderRange.call(this, currentUnzonedRange, currentRangeUnit, isRangeAllDay); // an UnzonedRange
var start = this.msToUtcMoment(renderUnzonedRange.startMs, isRangeAllDay);
var end = this.msToUtcMoment(renderUnzonedRange.endMs, isRangeAllDay);
// year and month views should be aligned with weeks. this is already done for week
if (/^(year|month)$/.test(currentRangeUnit)) {
start.startOf('week');
// make end-of-week if not already
if (end.weekday()) {
end.add(1, 'week').startOf('week'); // exclusively move backwards
}
}
return new UnzonedRange_1.default(start, end);
};
return BasicViewDateProfileGenerator;
}(DateProfileGenerator_1.default));
exports.default = BasicViewDateProfileGenerator;
/***/ }),
/* 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 */,
/* 208 */,
/* 209 */,
/* 210 */,
/* 211 */,
/* 212 */,
/* 213 */,
/* 214 */,
/* 215 */,
/* 216 */,
/* 217 */
/***/ (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__(36);
var EventSource_1 = __webpack_require__(6);
var util_1 = __webpack_require__(19);
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) { // invalid input. fallback to parsing footprint directly
return this.parseFootprints(constraintVal);
}
else {
return this.eventInstancesToFootprints(eventInstances);
}
}
else if (constraintVal != null) { // an ID
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) { // invalid
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;
}
/***/ }),
/* 218 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var $ = __webpack_require__(3);
var util_1 = __webpack_require__(19);
var EventInstanceGroup_1 = __webpack_require__(20);
var RecurringEventDef_1 = __webpack_require__(54);
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;
/***/ }),
/* 219 */
/***/ (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__(21);
var EmitterMixin_1 = __webpack_require__(13);
var UnzonedRange_1 = __webpack_require__(5);
var EventInstanceGroup_1 = __webpack_require__(20);
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);
/***/ }),
/* 220 */
/***/ (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__(219);
var ArrayEventSource_1 = __webpack_require__(56);
var EventSource_1 = __webpack_require__(6);
var EventSourceParser_1 = __webpack_require__(38);
var SingleEventDef_1 = __webpack_require__(9);
var EventInstanceGroup_1 = __webpack_require__(20);
var EmitterMixin_1 = __webpack_require__(13);
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();
}
/***/ }),
/* 221 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = __webpack_require__(2);
var Theme_1 = __webpack_require__(22);
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-';
/***/ }),
/* 222 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = __webpack_require__(2);
var Theme_1 = __webpack_require__(22);
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-';
/***/ }),
/* 223 */
/***/ (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__(21);
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)) { // extended form
rawProps = rawInput;
}
else if ($.isFunction(rawInput)) { // short form
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
});
/***/ }),
/* 224 */
/***/ (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__(21);
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') { // extended form
rawProps = rawInput;
}
else if (typeof rawInput === 'string') { // short form
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
});
/***/ }),
/* 225 */
/***/ (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;
/***/ }),
/* 226 */
/***/ (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) { // disallow more than one stop animation at a time
this.isFollowing = false;
this.stopListeningTo($(document));
if (shouldRevert && revertDuration && !this.isHidden) { // do a revert animation?
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);
/***/ }),
/* 227 */
/***/ (function(module, exports, __webpack_require__) {
/* A rectangular panel that is absolutely positioned over other content
------------------------------------------------------------------------------------------------------------------------
Options:
- className (string)
- content (HTML string or jQuery element set)
- parentEl
- top
- left
- right (the x coord of where the right edge should be. not a "CSS" right)
- autoHide (boolean)
- show (callback)
- hide (callback)
*/
Object.defineProperty(exports, "__esModule", { value: true });
var $ = __webpack_require__(3);
var util_1 = __webpack_require__(4);
var ListenerMixin_1 = __webpack_require__(7);
var Popover = /** @class */ (function () {
function Popover(options) {
this.isHidden = true;
this.margin = 10; // the space required between the popover and the edges of the scroll container
this.options = options || {};
}
// Shows the popover on the specified position. Renders it if not already
Popover.prototype.show = function () {
if (this.isHidden) {
if (!this.el) {
this.render();
}
this.el.show();
this.position();
this.isHidden = false;
this.trigger('show');
}
};
// Hides the popover, through CSS, but does not remove it from the DOM
Popover.prototype.hide = function () {
if (!this.isHidden) {
this.el.hide();
this.isHidden = true;
this.trigger('hide');
}
};
// Creates `this.el` and renders content inside of it
Popover.prototype.render = function () {
var _this = this;
var options = this.options;
this.el = $(' ')
.addClass(options.className || '')
.css({
// position initially to the top left to avoid creating scrollbars
top: 0,
left: 0
})
.append(options.content)
.appendTo(options.parentEl);
// when a click happens on anything inside with a 'fc-close' className, hide the popover
this.el.on('click', '.fc-close', function () {
_this.hide();
});
if (options.autoHide) {
this.listenTo($(document), 'mousedown', this.documentMousedown);
}
};
// Triggered when the user clicks *anywhere* in the document, for the autoHide feature
Popover.prototype.documentMousedown = function (ev) {
// only hide the popover if the click happened outside the popover
if (this.el && !$(ev.target).closest(this.el).length) {
this.hide();
}
};
// Hides and unregisters any handlers
Popover.prototype.removeElement = function () {
this.hide();
if (this.el) {
this.el.remove();
this.el = null;
}
this.stopListeningTo($(document), 'mousedown');
};
// Positions the popover optimally, using the top/left/right options
Popover.prototype.position = function () {
var options = this.options;
var origin = this.el.offsetParent().offset();
var width = this.el.outerWidth();
var height = this.el.outerHeight();
var windowEl = $(window);
var viewportEl = util_1.getScrollParent(this.el);
var viewportTop;
var viewportLeft;
var viewportOffset;
var top; // the "position" (not "offset") values for the popover
var left; //
// compute top and left
top = options.top || 0;
if (options.left !== undefined) {
left = options.left;
}
else if (options.right !== undefined) {
left = options.right - width; // derive the left value from the right value
}
else {
left = 0;
}
if (viewportEl.is(window) || viewportEl.is(document)) { // normalize getScrollParent's result
viewportEl = windowEl;
viewportTop = 0; // the window is always at the top left
viewportLeft = 0; // (and .offset() won't work if called here)
}
else {
viewportOffset = viewportEl.offset();
viewportTop = viewportOffset.top;
viewportLeft = viewportOffset.left;
}
// if the window is scrolled, it causes the visible area to be further down
viewportTop += windowEl.scrollTop();
viewportLeft += windowEl.scrollLeft();
// constrain to the view port. if constrained by two edges, give precedence to top/left
if (options.viewportConstrain !== false) {
top = Math.min(top, viewportTop + viewportEl.outerHeight() - height - this.margin);
top = Math.max(top, viewportTop + this.margin);
left = Math.min(left, viewportLeft + viewportEl.outerWidth() - width - this.margin);
left = Math.max(left, viewportLeft + this.margin);
}
this.el.css({
top: top - origin.top,
left: left - origin.left
});
};
// Triggers a callback. Calls a function in the option hash of the same name.
// Arguments beyond the first `name` are forwarded on.
// TODO: better code reuse for this. Repeat code
Popover.prototype.trigger = function (name) {
if (this.options[name]) {
this.options[name].apply(this, Array.prototype.slice.call(arguments, 1));
}
};
return Popover;
}());
exports.default = Popover;
ListenerMixin_1.default.mixInto(Popover);
/***/ }),
/* 228 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var EmitterMixin_1 = __webpack_require__(13);
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);
/***/ }),
/* 229 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = __webpack_require__(2);
var TaskQueue_1 = __webpack_require__(228);
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)) { // appended to queue?
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];
if (task.namespace === newTask.namespace) {
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;
/***/ }),
/* 230 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = __webpack_require__(2);
var Model_1 = __webpack_require__(51);
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;
/***/ }),
/* 231 */
/***/ (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__(11);
var date_formatting_1 = __webpack_require__(49);
var Component_1 = __webpack_require__(230);
var util_2 = __webpack_require__(19);
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) { // fillRenderer is optional -----v
_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']) { // legacy
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']) { // legacy
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) { // necessary?
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) { // necessary?
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)) { // TODO: use DateComponent subclass somehow
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;
}
/***/ }),
/* 232 */
/***/ (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__(33);
var Iterator_1 = __webpack_require__(225);
var GlobalEmitter_1 = __webpack_require__(23);
var EmitterMixin_1 = __webpack_require__(13);
var ListenerMixin_1 = __webpack_require__(7);
var Toolbar_1 = __webpack_require__(257);
var OptionsManager_1 = __webpack_require__(258);
var ViewSpecManager_1 = __webpack_require__(259);
var Constraints_1 = __webpack_require__(217);
var locale_1 = __webpack_require__(32);
var moment_ext_1 = __webpack_require__(11);
var UnzonedRange_1 = __webpack_require__(5);
var ComponentFootprint_1 = __webpack_require__(12);
var EventDateProfile_1 = __webpack_require__(16);
var EventManager_1 = __webpack_require__(220);
var BusinessHourGenerator_1 = __webpack_require__(218);
var EventSourceParser_1 = __webpack_require__(38);
var EventDefParser_1 = __webpack_require__(36);
var SingleEventDef_1 = __webpack_require__(9);
var EventDefMutation_1 = __webpack_require__(39);
var EventSource_1 = __webpack_require__(6);
var ThemeRegistry_1 = __webpack_require__(57);
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) { // getter
return this.optionsManager.get(name);
}
else { // setter for individual option
newOptionHash = {};
newOptionHash[name] = value;
this.optionsManager.add(newOptionHash);
}
}
else if (typeof name === 'object') { // compound setter with object input
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) { // a range
this.optionsManager.recordOverrides({
visibleRange: dateOrRange
});
}
else { // a date
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) { // hack
_this.setToolbarsTitle(deps.title);
}
});
view.watch('dateProfileForCalendar', ['dateProfile'], function (deps) {
if (view === _this.view) { // hack
_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') { // exists and not 'auto'
this.suggestedViewHeight = contentHeightInput;
}
else if (typeof contentHeightInput === 'function') { // exists and is a function
this.suggestedViewHeight = contentHeightInput();
}
else if (typeof heightInput === 'number') { // exists and not 'auto'
this.suggestedViewHeight = heightInput - this.queryToolbarsHeight();
}
else if (typeof heightInput === 'function') { // exists and is a function
this.suggestedViewHeight = heightInput() - this.queryToolbarsHeight();
}
else if (heightInput === 'parent') { // set to height of parent element
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)) { // isResize=true, returns true on success
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 ( // whitelist certain kinds of input
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()) { // don't give ambiguously-timed moments a local zone
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) { // is the time result different than expected?
adjustedZonedDate = zonedDate.clone().add(timeAdjust); // add milliseconds
if (date.time().asMilliseconds() - adjustedZonedDate.time().asMilliseconds() === 0) { // does it match perfectly now?
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);
}
}
this.localizeMoment(start);
if (end) {
this.localizeMoment(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) { // shortcut for removing all
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) { // reuse `i` as an "id"
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 { // an event ID
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
});
}
}
/***/ }),
/* 233 */
/***/ (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__(18);
var util_1 = __webpack_require__(4);
var moment_ext_1 = __webpack_require__(11);
var ListenerMixin_1 = __webpack_require__(7);
var HitDragListener_1 = __webpack_require__(17);
var SingleEventDef_1 = __webpack_require__(9);
var EventInstanceGroup_1 = __webpack_require__(20);
var EventSource_1 = __webpack_require__(6);
var Interaction_1 = __webpack_require__(14);
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')) { // only listen if this setting is on
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) { // prevent double-listening if fired twice
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) { // element was dropped on a valid hit
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 { // something like 1 or true. still signal event creation
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 };
}
/***/ }),
/* 234 */
/***/ (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__(39);
var EventDefDateMutation_1 = __webpack_require__(40);
var HitDragListener_1 = __webpack_require__(17);
var Interaction_1 = __webpack_require__(14);
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) { // valid date to resize to?
// 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;
/***/ }),
/* 235 */
/***/ (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__(39);
var EventDefDateMutation_1 = __webpack_require__(40);
var DragListener_1 = __webpack_require__(59);
var HitDragListener_1 = __webpack_require__(17);
var MouseFollower_1 = __webpack_require__(226);
var Interaction_1 = __webpack_require__(14);
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;
/***/ }),
/* 236 */
/***/ (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__(17);
var ComponentFootprint_1 = __webpack_require__(12);
var UnzonedRange_1 = __webpack_require__(5);
var Interaction_1 = __webpack_require__(14);
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) { // click needs to have started on a hit
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;
/***/ }),
/* 237 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = __webpack_require__(2);
var HitDragListener_1 = __webpack_require__(17);
var Interaction_1 = __webpack_require__(14);
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;
/***/ }),
/* 238 */
/***/ (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__(41);
var View_1 = __webpack_require__(43);
var TimeGrid_1 = __webpack_require__(239);
var DayGrid_1 = __webpack_require__(66);
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')) { // should we display the "all-day" area?
_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) { // should we force dimensions of the scroll container?
scrollerHeight = this.computeScrollerHeight(totalHeight);
this.scroller.setHeight(scrollerHeight);
scrollbarWidths = this.scroller.getScrollbarWidths();
if (scrollbarWidths.left || scrollbarWidths.right) { // using scrollbars?
// 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 };
}
/***/ }),
/* 239 */
/***/ (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__(42);
var BusinessHourRenderer_1 = __webpack_require__(61);
var StandardInteractionsMixin_1 = __webpack_require__(65);
var DayTableMixin_1 = __webpack_require__(60);
var CoordCache_1 = __webpack_require__(58);
var UnzonedRange_1 = __webpack_require__(5);
var ComponentFootprint_1 = __webpack_require__(12);
var TimeGridEventRenderer_1 = __webpack_require__(240);
var TimeGridHelperRenderer_1 = __webpack_require__(241);
var TimeGridFillRenderer_1 = __webpack_require__(242);
/* 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 + ' ' +
' ' +
' ');
this.colContainerEls = skeletonEl.find('.fc-content-col');
this.helperContainerEls = skeletonEl.find('.fc-helper-container');
this.fgContainerEls = skeletonEl.find('.fc-event-container:not(.fc-helper-container)');
this.bgContainerEls = skeletonEl.find('.fc-bgevent-container');
this.highlightContainerEls = skeletonEl.find('.fc-highlight-container');
this.businessContainerEls = skeletonEl.find('.fc-business-container');
this.bookendCells(skeletonEl.find('tr')); // TODO: do this on string level
this.el.append(skeletonEl);
};
TimeGrid.prototype.unrenderContentSkeleton = function () {
if (this.contentSkeletonEl) { // defensive :(
this.contentSkeletonEl.remove();
this.contentSkeletonEl = null;
this.colContainerEls = null;
this.helperContainerEls = null;
this.fgContainerEls = null;
this.bgContainerEls = null;
this.highlightContainerEls = null;
this.businessContainerEls = null;
}
};
// Given a flat array of segments, return an array of sub-arrays, grouped by each segment's col
TimeGrid.prototype.groupSegsByCol = function (segs) {
var segsByCol = [];
var i;
for (i = 0; i < this.colCnt; i++) {
segsByCol.push([]);
}
for (i = 0; i < segs.length; i++) {
segsByCol[segs[i].col].push(segs[i]);
}
return segsByCol;
};
// Given segments grouped by column, insert the segments' elements into a parallel array of container
// elements, each living within a column.
TimeGrid.prototype.attachSegsByCol = function (segsByCol, containerEls) {
var col;
var segs;
var i;
for (col = 0; col < this.colCnt; col++) { // iterate each column grouping
segs = segsByCol[col];
for (i = 0; i < segs.length; i++) {
containerEls.eq(col).append(segs[i].el);
}
}
};
/* Now Indicator
------------------------------------------------------------------------------------------------------------------*/
TimeGrid.prototype.getNowIndicatorUnit = function () {
return 'minute'; // will refresh on the minute
};
TimeGrid.prototype.renderNowIndicator = function (date) {
// HACK: if date columns not ready for some reason (scheduler)
if (!this.colContainerEls) {
return;
}
// seg system might be overkill, but it handles scenario where line needs to be rendered
// more than once because of columns with the same date (resources columns for example)
var segs = this.componentFootprintToSegs(new ComponentFootprint_1.default(new UnzonedRange_1.default(date, date.valueOf() + 1), // protect against null range
false // all-day
));
var top = this.computeDateTop(date, date);
var nodes = [];
var i;
// render lines within the columns
for (i = 0; i < segs.length; i++) {
nodes.push($(' ')
.css('top', top)
.appendTo(this.colContainerEls.eq(segs[i].col))[0]);
}
// render an arrow over the axis
if (segs.length > 0) { // is the current time in view?
nodes.push($(' ')
.css('top', top)
.appendTo(this.el.find('.fc-content-skeleton'))[0]);
}
this.nowIndicatorEls = $(nodes);
};
TimeGrid.prototype.unrenderNowIndicator = function () {
if (this.nowIndicatorEls) {
this.nowIndicatorEls.remove();
this.nowIndicatorEls = null;
}
};
/* Coordinates
------------------------------------------------------------------------------------------------------------------*/
TimeGrid.prototype.updateSize = function (totalHeight, isAuto, isResize) {
_super.prototype.updateSize.call(this, totalHeight, isAuto, isResize);
this.slatCoordCache.build();
if (isResize) {
this.updateSegVerticals([].concat(this.eventRenderer.getSegs(), this.businessSegs || []));
}
};
TimeGrid.prototype.getTotalSlatHeight = function () {
return this.slatContainerEl.outerHeight();
};
// Computes the top coordinate, relative to the bounds of the grid, of the given date.
// `ms` can be a millisecond UTC time OR a UTC moment.
// A `startOfDayDate` must be given for avoiding ambiguity over how to treat midnight.
TimeGrid.prototype.computeDateTop = function (ms, startOfDayDate) {
return this.computeTimeTop(moment.duration(ms - startOfDayDate.clone().stripTime()));
};
// Computes the top coordinate, relative to the bounds of the grid, of the given time (a Duration).
TimeGrid.prototype.computeTimeTop = function (time) {
var len = this.slatEls.length;
var dateProfile = this.dateProfile;
var slatCoverage = (time - dateProfile.minTime) / this.slotDuration; // floating-point value of # of slots covered
var slatIndex;
var slatRemainder;
// compute a floating-point number for how many slats should be progressed through.
// from 0 to number of slats (inclusive)
// constrained because minTime/maxTime might be customized.
slatCoverage = Math.max(0, slatCoverage);
slatCoverage = Math.min(len, slatCoverage);
// an integer index of the furthest whole slat
// from 0 to number slats (*exclusive*, so len-1)
slatIndex = Math.floor(slatCoverage);
slatIndex = Math.min(slatIndex, len - 1);
// how much further through the slatIndex slat (from 0.0-1.0) must be covered in addition.
// could be 1.0 if slatCoverage is covering *all* the slots
slatRemainder = slatCoverage - slatIndex;
return this.slatCoordCache.getTopPosition(slatIndex) +
this.slatCoordCache.getHeight(slatIndex) * slatRemainder;
};
// Refreshes the CSS top/bottom coordinates for each segment element.
// Works when called after initial render, after a window resize/zoom for example.
TimeGrid.prototype.updateSegVerticals = function (segs) {
this.computeSegVerticals(segs);
this.assignSegVerticals(segs);
};
// For each segment in an array, computes and assigns its top and bottom properties
TimeGrid.prototype.computeSegVerticals = function (segs) {
var eventMinHeight = this.opt('agendaEventMinHeight');
var i;
var seg;
var dayDate;
for (i = 0; i < segs.length; i++) {
seg = segs[i];
dayDate = this.dayDates[seg.dayIndex];
seg.top = this.computeDateTop(seg.startMs, dayDate);
seg.bottom = Math.max(seg.top + eventMinHeight, this.computeDateTop(seg.endMs, dayDate));
}
};
// Given segments that already have their top/bottom properties computed, applies those values to
// the segments' elements.
TimeGrid.prototype.assignSegVerticals = function (segs) {
var i;
var seg;
for (i = 0; i < segs.length; i++) {
seg = segs[i];
seg.el.css(this.generateSegVerticalCss(seg));
}
};
// Generates an object with CSS properties for the top/bottom coordinates of a segment element
TimeGrid.prototype.generateSegVerticalCss = function (seg) {
return {
top: seg.top,
bottom: -seg.bottom // flipped because needs to be space beyond bottom edge of event container
};
};
/* Hit System
------------------------------------------------------------------------------------------------------------------*/
TimeGrid.prototype.prepareHits = function () {
this.colCoordCache.build();
this.slatCoordCache.build();
};
TimeGrid.prototype.releaseHits = function () {
this.colCoordCache.clear();
// NOTE: don't clear slatCoordCache because we rely on it for computeTimeTop
};
TimeGrid.prototype.queryHit = function (leftOffset, topOffset) {
var snapsPerSlot = this.snapsPerSlot;
var colCoordCache = this.colCoordCache;
var slatCoordCache = this.slatCoordCache;
if (colCoordCache.isLeftInBounds(leftOffset) && slatCoordCache.isTopInBounds(topOffset)) {
var colIndex = colCoordCache.getHorizontalIndex(leftOffset);
var slatIndex = slatCoordCache.getVerticalIndex(topOffset);
if (colIndex != null && slatIndex != null) {
var slatTop = slatCoordCache.getTopOffset(slatIndex);
var slatHeight = slatCoordCache.getHeight(slatIndex);
var partial = (topOffset - slatTop) / slatHeight; // floating point number between 0 and 1
var localSnapIndex = Math.floor(partial * snapsPerSlot); // the snap # relative to start of slat
var snapIndex = slatIndex * snapsPerSlot + localSnapIndex;
var snapTop = slatTop + (localSnapIndex / snapsPerSlot) * slatHeight;
var snapBottom = slatTop + ((localSnapIndex + 1) / snapsPerSlot) * slatHeight;
return {
col: colIndex,
snap: snapIndex,
component: this,
left: colCoordCache.getLeftOffset(colIndex),
right: colCoordCache.getRightOffset(colIndex),
top: snapTop,
bottom: snapBottom
};
}
}
};
TimeGrid.prototype.getHitFootprint = function (hit) {
var start = this.getCellDate(0, hit.col); // row=0
var time = this.computeSnapTime(hit.snap); // pass in the snap-index
var end;
start.time(time);
end = start.clone().add(this.snapDuration);
return new ComponentFootprint_1.default(new UnzonedRange_1.default(start, end), false // all-day?
);
};
// Given a row number of the grid, representing a "snap", returns a time (Duration) from its start-of-day
TimeGrid.prototype.computeSnapTime = function (snapIndex) {
return moment.duration(this.dateProfile.minTime + this.snapDuration * snapIndex);
};
TimeGrid.prototype.getHitEl = function (hit) {
return this.colEls.eq(hit.col);
};
/* Event Drag Visualization
------------------------------------------------------------------------------------------------------------------*/
// Renders a visual indication of an event being dragged over the specified date(s).
// A returned value of `true` signals that a mock "helper" event has been rendered.
TimeGrid.prototype.renderDrag = function (eventFootprints, seg, isTouch) {
var i;
if (seg) { // if there is event information for this drag, render a helper event
if (eventFootprints.length) {
this.helperRenderer.renderEventDraggingFootprints(eventFootprints, seg, isTouch);
// signal that a helper has been rendered
return true;
}
}
else { // otherwise, just render a highlight
for (i = 0; i < eventFootprints.length; i++) {
this.renderHighlight(eventFootprints[i].componentFootprint);
}
}
};
// Unrenders any visual indication of an event being dragged
TimeGrid.prototype.unrenderDrag = function () {
this.unrenderHighlight();
this.helperRenderer.unrender();
};
/* Event Resize Visualization
------------------------------------------------------------------------------------------------------------------*/
// Renders a visual indication of an event being resized
TimeGrid.prototype.renderEventResize = function (eventFootprints, seg, isTouch) {
this.helperRenderer.renderEventResizingFootprints(eventFootprints, seg, isTouch);
};
// Unrenders any visual indication of an event being resized
TimeGrid.prototype.unrenderEventResize = function () {
this.helperRenderer.unrender();
};
/* Selection
------------------------------------------------------------------------------------------------------------------*/
// Renders a visual indication of a selection. Overrides the default, which was to simply render a highlight.
TimeGrid.prototype.renderSelectionFootprint = function (componentFootprint) {
if (this.opt('selectHelper')) { // this setting signals that a mock helper event should be rendered
this.helperRenderer.renderComponentFootprint(componentFootprint);
}
else {
this.renderHighlight(componentFootprint);
}
};
// Unrenders any visual indication of a selection
TimeGrid.prototype.unrenderSelection = function () {
this.helperRenderer.unrender();
this.unrenderHighlight();
};
return TimeGrid;
}(InteractiveDateComponent_1.default));
exports.default = TimeGrid;
TimeGrid.prototype.eventRendererClass = TimeGridEventRenderer_1.default;
TimeGrid.prototype.businessHourRendererClass = BusinessHourRenderer_1.default;
TimeGrid.prototype.helperRendererClass = TimeGridHelperRenderer_1.default;
TimeGrid.prototype.fillRendererClass = TimeGridFillRenderer_1.default;
StandardInteractionsMixin_1.default.mixInto(TimeGrid);
DayTableMixin_1.default.mixInto(TimeGrid);
/***/ }),
/* 240 */
/***/ (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__(44);
/*
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) { // hack
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) +
' ' :
'') +
' ';
};
// Given segments that are assumed to all live in the *same column*,
// compute their verical/horizontal coordinates and assign to their elements.
TimeGridEventRenderer.prototype.updateFgSegCoords = function (segs) {
this.timeGrid.computeSegVerticals(segs); // horizontals relies on this
this.computeFgSegHorizontals(segs); // compute horizontal coordinates, z-index's, and reorder the array
this.timeGrid.assignSegVerticals(segs);
this.assignFgSegHorizontals(segs);
};
// Given an array of segments that are all in the same column, sets the backwardCoord and forwardCoord on each.
// NOTE: Also reorders the given array by date!
TimeGridEventRenderer.prototype.computeFgSegHorizontals = function (segs) {
var levels;
var level0;
var i;
this.sortEventSegs(segs); // order by certain criteria
levels = buildSlotSegLevels(segs);
computeForwardSlotSegs(levels);
if ((level0 = levels[0])) {
for (i = 0; i < level0.length; i++) {
computeSlotSegPressures(level0[i]);
}
for (i = 0; i < level0.length; i++) {
this.computeFgSegForwardBack(level0[i], 0, 0);
}
}
};
// Calculate seg.forwardCoord and seg.backwardCoord for the segment, where both values range
// from 0 to 1. If the calendar is left-to-right, the seg.backwardCoord maps to "left" and
// seg.forwardCoord maps to "right" (via percentage). Vice-versa if the calendar is right-to-left.
//
// The segment might be part of a "series", which means consecutive segments with the same pressure
// who's width is unknown until an edge has been hit. `seriesBackwardPressure` is the number of
// segments behind this one in the current series, and `seriesBackwardCoord` is the starting
// coordinate of the first segment in the series.
TimeGridEventRenderer.prototype.computeFgSegForwardBack = function (seg, seriesBackwardPressure, seriesBackwardCoord) {
var forwardSegs = seg.forwardSegs;
var i;
if (seg.forwardCoord === undefined) { // not already computed
if (!forwardSegs.length) {
// if there are no forward segments, this segment should butt up against the edge
seg.forwardCoord = 1;
}
else {
// sort highest pressure first
this.sortForwardSegs(forwardSegs);
// this segment's forwardCoord will be calculated from the backwardCoord of the
// highest-pressure forward segment.
this.computeFgSegForwardBack(forwardSegs[0], seriesBackwardPressure + 1, seriesBackwardCoord);
seg.forwardCoord = forwardSegs[0].backwardCoord;
}
// calculate the backwardCoord from the forwardCoord. consider the series
seg.backwardCoord = seg.forwardCoord -
(seg.forwardCoord - seriesBackwardCoord) / // available width for series
(seriesBackwardPressure + 1); // # of segments in the series
// use this segment's coordinates to computed the coordinates of the less-pressurized
// forward segments
for (i = 0; i < forwardSegs.length; i++) {
this.computeFgSegForwardBack(forwardSegs[i], 0, seg.forwardCoord);
}
}
};
TimeGridEventRenderer.prototype.sortForwardSegs = function (forwardSegs) {
forwardSegs.sort(util_1.proxy(this, 'compareForwardSegs'));
};
// A cmp function for determining which forward segment to rely on more when computing coordinates.
TimeGridEventRenderer.prototype.compareForwardSegs = function (seg1, seg2) {
// put higher-pressure first
return seg2.forwardPressure - seg1.forwardPressure ||
// put segments that are closer to initial edge first (and favor ones with no coords yet)
(seg1.backwardCoord || 0) - (seg2.backwardCoord || 0) ||
// do normal sorting...
this.compareEventSegs(seg1, seg2);
};
// Given foreground event segments that have already had their position coordinates computed,
// assigns position-related CSS values to their elements.
TimeGridEventRenderer.prototype.assignFgSegHorizontals = function (segs) {
var i;
var seg;
for (i = 0; i < segs.length; i++) {
seg = segs[i];
seg.el.css(this.generateFgSegHorizontalCss(seg));
// if the event is short that the title will be cut off,
// attach a className that condenses the title into the time area.
if (seg.footprint.eventDef.title && seg.bottom - seg.top < 30) {
seg.el.addClass('fc-short'); // TODO: "condensed" is a better name
}
}
};
// Generates an object with CSS properties/values that should be applied to an event segment element.
// Contains important positioning-related properties that should be applied to any event element, customized or not.
TimeGridEventRenderer.prototype.generateFgSegHorizontalCss = function (seg) {
var shouldOverlap = this.opt('slotEventOverlap');
var backwardCoord = seg.backwardCoord; // the left side if LTR. the right side if RTL. floating-point
var forwardCoord = seg.forwardCoord; // the right side if LTR. the left side if RTL. floating-point
var props = this.timeGrid.generateSegVerticalCss(seg); // get top/bottom first
var isRTL = this.timeGrid.isRTL;
var left; // amount of space from left edge, a fraction of the total width
var right; // amount of space from right edge, a fraction of the total width
if (shouldOverlap) {
// double the width, but don't go beyond the maximum forward coordinate (1.0)
forwardCoord = Math.min(1, backwardCoord + (forwardCoord - backwardCoord) * 2);
}
if (isRTL) {
left = 1 - forwardCoord;
right = backwardCoord;
}
else {
left = backwardCoord;
right = 1 - forwardCoord;
}
props.zIndex = seg.level + 1; // convert from 0-base to 1-based
props.left = left * 100 + '%';
props.right = right * 100 + '%';
if (shouldOverlap && seg.forwardPressure) {
// add padding to the edge so that forward stacked events don't cover the resizer's icon
props[isRTL ? 'marginLeft' : 'marginRight'] = 10 * 2; // 10 is a guesstimate of the icon's width
}
return props;
};
return TimeGridEventRenderer;
}(EventRenderer_1.default));
exports.default = TimeGridEventRenderer;
// Builds an array of segments "levels". The first level will be the leftmost tier of segments if the calendar is
// left-to-right, or the rightmost if the calendar is right-to-left. Assumes the segments are already ordered by date.
function buildSlotSegLevels(segs) {
var levels = [];
var i;
var seg;
var j;
for (i = 0; i < segs.length; i++) {
seg = segs[i];
// go through all the levels and stop on the first level where there are no collisions
for (j = 0; j < levels.length; j++) {
if (!computeSlotSegCollisions(seg, levels[j]).length) {
break;
}
}
seg.level = j;
(levels[j] || (levels[j] = [])).push(seg);
}
return levels;
}
// For every segment, figure out the other segments that are in subsequent
// levels that also occupy the same vertical space. Accumulate in seg.forwardSegs
function computeForwardSlotSegs(levels) {
var i;
var level;
var j;
var seg;
var k;
for (i = 0; i < levels.length; i++) {
level = levels[i];
for (j = 0; j < level.length; j++) {
seg = level[j];
seg.forwardSegs = [];
for (k = i + 1; k < levels.length; k++) {
computeSlotSegCollisions(seg, levels[k], seg.forwardSegs);
}
}
}
}
// Figure out which path forward (via seg.forwardSegs) results in the longest path until
// the furthest edge is reached. The number of segments in this path will be seg.forwardPressure
function computeSlotSegPressures(seg) {
var forwardSegs = seg.forwardSegs;
var forwardPressure = 0;
var i;
var forwardSeg;
if (seg.forwardPressure === undefined) { // not already computed
for (i = 0; i < forwardSegs.length; i++) {
forwardSeg = forwardSegs[i];
// figure out the child's maximum forward path
computeSlotSegPressures(forwardSeg);
// either use the existing maximum, or use the child's forward pressure
// plus one (for the forwardSeg itself)
forwardPressure = Math.max(forwardPressure, 1 + forwardSeg.forwardPressure);
}
seg.forwardPressure = forwardPressure;
}
}
// Find all the segments in `otherSegs` that vertically collide with `seg`.
// Append into an optionally-supplied `results` array and return.
function computeSlotSegCollisions(seg, otherSegs, results) {
if (results === void 0) { results = []; }
for (var i = 0; i < otherSegs.length; i++) {
if (isSlotSegCollision(seg, otherSegs[i])) {
results.push(otherSegs[i]);
}
}
return results;
}
// Do these segments occupy the same vertical space?
function isSlotSegCollision(seg1, seg2) {
return seg1.bottom > seg2.top && seg1.top < seg2.bottom;
}
/***/ }),
/* 241 */
/***/ (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__(63);
var TimeGridHelperRenderer = /** @class */ (function (_super) {
tslib_1.__extends(TimeGridHelperRenderer, _super);
function TimeGridHelperRenderer() {
return _super !== null && _super.apply(this, arguments) || this;
}
TimeGridHelperRenderer.prototype.renderSegs = function (segs, sourceSeg) {
var helperNodes = [];
var i;
var seg;
var sourceEl;
// TODO: not good to call eventRenderer this way
this.eventRenderer.renderFgSegsIntoContainers(segs, this.component.helperContainerEls);
// Try to make the segment that is in the same row as sourceSeg look the same
for (i = 0; i < segs.length; i++) {
seg = segs[i];
if (sourceSeg && sourceSeg.col === seg.col) {
sourceEl = sourceSeg.el;
seg.el.css({
left: sourceEl.css('left'),
right: sourceEl.css('right'),
'margin-left': sourceEl.css('margin-left'),
'margin-right': sourceEl.css('margin-right')
});
}
helperNodes.push(seg.el[0]);
}
return $(helperNodes); // must return the elements rendered
};
return TimeGridHelperRenderer;
}(HelperRenderer_1.default));
exports.default = TimeGridHelperRenderer;
/***/ }),
/* 242 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = __webpack_require__(2);
var FillRenderer_1 = __webpack_require__(62);
var TimeGridFillRenderer = /** @class */ (function (_super) {
tslib_1.__extends(TimeGridFillRenderer, _super);
function TimeGridFillRenderer() {
return _super !== null && _super.apply(this, arguments) || this;
}
TimeGridFillRenderer.prototype.attachSegEls = function (type, segs) {
var timeGrid = this.component;
var containerEls;
// TODO: more efficient lookup
if (type === 'bgEvent') {
containerEls = timeGrid.bgContainerEls;
}
else if (type === 'businessHours') {
containerEls = timeGrid.businessContainerEls;
}
else if (type === 'highlight') {
containerEls = timeGrid.highlightContainerEls;
}
timeGrid.updateSegVerticals(segs);
timeGrid.attachSegsByCol(timeGrid.groupSegsByCol(segs), containerEls);
return segs.map(function (seg) {
return seg.el[0];
});
};
return TimeGridFillRenderer;
}(FillRenderer_1.default));
exports.default = TimeGridFillRenderer;
/***/ }),
/* 243 */
/***/ (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 EventRenderer_1 = __webpack_require__(44);
/* Event-rendering methods for the DayGrid class
----------------------------------------------------------------------------------------------------------------------*/
var DayGridEventRenderer = /** @class */ (function (_super) {
tslib_1.__extends(DayGridEventRenderer, _super);
function DayGridEventRenderer(dayGrid, fillRenderer) {
var _this = _super.call(this, dayGrid, fillRenderer) || this;
_this.dayGrid = dayGrid;
return _this;
}
DayGridEventRenderer.prototype.renderBgRanges = function (eventRanges) {
// don't render timed background events
eventRanges = $.grep(eventRanges, function (eventRange) {
return eventRange.eventDef.isAllDay();
});
_super.prototype.renderBgRanges.call(this, eventRanges);
};
// Renders the given foreground event segments onto the grid
DayGridEventRenderer.prototype.renderFgSegs = function (segs) {
var rowStructs = this.rowStructs = this.renderSegRows(segs);
// append to each row's content skeleton
this.dayGrid.rowEls.each(function (i, rowNode) {
$(rowNode).find('.fc-content-skeleton > table').append(rowStructs[i].tbodyEl);
});
};
// Unrenders all currently rendered foreground event segments
DayGridEventRenderer.prototype.unrenderFgSegs = function () {
var rowStructs = this.rowStructs || [];
var rowStruct;
while ((rowStruct = rowStructs.pop())) {
rowStruct.tbodyEl.remove();
}
this.rowStructs = null;
};
// Uses the given events array to generate elements that should be appended to each row's content skeleton.
// Returns an array of rowStruct objects (see the bottom of `renderSegRow`).
// PRECONDITION: each segment shoud already have a rendered and assigned `.el`
DayGridEventRenderer.prototype.renderSegRows = function (segs) {
var rowStructs = [];
var segRows;
var row;
segRows = this.groupSegRows(segs); // group into nested arrays
// iterate each row of segment groupings
for (row = 0; row < segRows.length; row++) {
rowStructs.push(this.renderSegRow(row, segRows[row]));
}
return rowStructs;
};
// Given a row # and an array of segments all in the same row, render a element, a skeleton that contains
// the segments. Returns object with a bunch of internal data about how the render was calculated.
// NOTE: modifies rowSegs
DayGridEventRenderer.prototype.renderSegRow = function (row, rowSegs) {
var colCnt = this.dayGrid.colCnt;
var segLevels = this.buildSegLevels(rowSegs); // group into sub-arrays of levels
var levelCnt = Math.max(1, segLevels.length); // ensure at least one level
var tbody = $('');
var segMatrix = []; // lookup for which segments are rendered into which level+col cells
var cellMatrix = []; // lookup for all 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++) { // iterate through all levels
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++) { // iterate through segments in level
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 { // a single-column segment
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;
}
/***/ }),
/* 244 */
/***/ (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__(63);
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) { // when no events
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;
/***/ }),
/* 245 */
/***/ (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__(62);
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(
// will create (startCol + 1) td's
new Array(startCol + 1).join(' | | '));
}
trEl.append(seg.el.attr('colspan', endCol - startCol));
if (endCol < colCnt) {
trEl.append(
// will create (colCnt - endCol) td's
new Array(colCnt - endCol + 1).join(' | '));
}
this.component.bookendCells(trEl);
return skeletonEl;
};
return DayGridFillRenderer;
}(FillRenderer_1.default));
exports.default = DayGridFillRenderer;
/***/ }),
/* 246 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = __webpack_require__(2);
var moment = __webpack_require__(0);
var util_1 = __webpack_require__(4);
var BasicView_1 = __webpack_require__(67);
var MonthViewDateProfileGenerator_1 = __webpack_require__(247);
/* A month view with day cells running in rows (one-per-week) and columns
----------------------------------------------------------------------------------------------------------------------*/
var MonthView = /** @class */ (function (_super) {
tslib_1.__extends(MonthView, _super);
function MonthView() {
return _super !== null && _super.apply(this, arguments) || this;
}
// Overrides the default BasicView behavior to have special multi-week auto-height logic
MonthView.prototype.setGridHeight = function (height, isAuto) {
// if auto, make the height of each row the height that it would be if there were 6 weeks
if (isAuto) {
height *= this.dayGrid.rowCnt / 6;
}
util_1.distributeHeight(this.dayGrid.rowEls, height, !isAuto); // if auto, don't compensate for height-hogging rows
};
MonthView.prototype.isDateInOtherMonth = function (date, dateProfile) {
return date.month() !== moment.utc(dateProfile.currentUnzonedRange.startMs).month(); // TODO: optimize
};
return MonthView;
}(BasicView_1.default));
exports.default = MonthView;
MonthView.prototype.dateProfileGeneratorClass = MonthViewDateProfileGenerator_1.default;
/***/ }),
/* 247 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = __webpack_require__(2);
var BasicViewDateProfileGenerator_1 = __webpack_require__(68);
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;
/***/ }),
/* 248 */
/***/ (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 UnzonedRange_1 = __webpack_require__(5);
var View_1 = __webpack_require__(43);
var Scroller_1 = __webpack_require__(41);
var ListEventRenderer_1 = __webpack_require__(249);
var ListEventPointing_1 = __webpack_require__(250);
/*
Responsible for the scroller, and forwarding event-related actions into the "grid".
*/
var ListView = /** @class */ (function (_super) {
tslib_1.__extends(ListView, _super);
function ListView(calendar, viewSpec) {
var _this = _super.call(this, calendar, viewSpec) || this;
_this.segSelector = '.fc-list-item'; // which elements accept event actions
_this.scroller = new Scroller_1.default({
overflowX: 'hidden',
overflowY: 'auto'
});
return _this;
}
ListView.prototype.renderSkeleton = function () {
this.el.addClass('fc-list-view ' +
this.calendar.theme.getClass('listView'));
this.scroller.render();
this.scroller.el.appendTo(this.el);
this.contentEl = this.scroller.scrollEl; // shortcut
};
ListView.prototype.unrenderSkeleton = function () {
this.scroller.destroy(); // will remove the Grid too
};
ListView.prototype.updateSize = function (totalHeight, isAuto, isResize) {
_super.prototype.updateSize.call(this, totalHeight, isAuto, isResize);
this.scroller.clear(); // sets height to 'auto' and clears overflow
if (!isAuto) {
this.scroller.setHeight(this.computeScrollerHeight(totalHeight));
}
};
ListView.prototype.computeScrollerHeight = function (totalHeight) {
return totalHeight -
util_1.subtractInnerElHeight(this.el, this.scroller.el); // everything that's NOT the scroller
};
ListView.prototype.renderDates = function (dateProfile) {
var calendar = this.calendar;
var dayStart = calendar.msToUtcMoment(dateProfile.renderUnzonedRange.startMs, true);
var viewEnd = calendar.msToUtcMoment(dateProfile.renderUnzonedRange.endMs, true);
var dayDates = [];
var dayRanges = [];
while (dayStart < viewEnd) {
dayDates.push(dayStart.clone());
dayRanges.push(new UnzonedRange_1.default(dayStart, dayStart.clone().add(1, 'day')));
dayStart.add(1, 'day');
}
this.dayDates = dayDates;
this.dayRanges = dayRanges;
// all real rendering happens in EventRenderer
};
// slices by day
ListView.prototype.componentFootprintToSegs = function (footprint) {
var dayRanges = this.dayRanges;
var dayIndex;
var segRange;
var seg;
var segs = [];
for (dayIndex = 0; dayIndex < dayRanges.length; dayIndex++) {
segRange = footprint.unzonedRange.intersect(dayRanges[dayIndex]);
if (segRange) {
seg = {
startMs: segRange.startMs,
endMs: segRange.endMs,
isStart: segRange.isStart,
isEnd: segRange.isEnd,
dayIndex: dayIndex
};
segs.push(seg);
// detect when footprint won't go fully into the next day,
// and mutate the latest seg to the be the end.
if (!seg.isEnd && !footprint.isAllDay &&
dayIndex + 1 < dayRanges.length &&
footprint.unzonedRange.endMs < dayRanges[dayIndex + 1].startMs + this.nextDayThreshold) {
seg.endMs = footprint.unzonedRange.endMs;
seg.isEnd = true;
break;
}
}
}
return segs;
};
ListView.prototype.renderEmptyMessage = function () {
this.contentEl.html('' + // 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;
/***/ }),
/* 249 */
/***/ (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__(44);
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) { // outer segment that probably lasts part of the day
timeHtml = util_1.htmlEscape(this._getTimeText(calendar.msToMoment(seg.startMs), calendar.msToMoment(seg.endMs), componentFootprint.isAllDay));
}
else { // inner segment that lasts the whole day
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;
/***/ }),
/* 250 */
/***/ (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__(64);
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()) { // jsEvent not cancelled in handler
window.location.href = url; // simulate link click
}
}
};
return ListEventPointing;
}(EventPointing_1.default));
exports.default = ListEventPointing;
/***/ }),
/* 251 */,
/* 252 */,
/* 253 */,
/* 254 */,
/* 255 */,
/* 256 */
/***/ (function(module, exports, __webpack_require__) {
var $ = __webpack_require__(3);
var exportHooks = __webpack_require__(18);
var util_1 = __webpack_require__(4);
var Calendar_1 = __webpack_require__(232);
// for intentional side-effects
__webpack_require__(11);
__webpack_require__(49);
__webpack_require__(260);
__webpack_require__(261);
__webpack_require__(264);
__webpack_require__(265);
__webpack_require__(266);
__webpack_require__(267);
$.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) { // first element only
res = calendar;
}
}
else if (options === 'destroy') { // don't warn if no calendar object
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') { // for the destroy method, must remove Calendar object data
element.removeData('fullCalendar');
}
}
else {
util_1.warn("'" + options + "' is an unknown FullCalendar method.");
}
}
else if (!calendar) { // don't initialize twice
calendar = new Calendar_1.default(element, options);
element.data('fullCalendar', calendar);
calendar.render();
}
});
return res;
};
module.exports = exportHooks;
/***/ }),
/* 257 */
/***/ (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 = $(" |