(needed by setTrInnerHeight).
// there will be no content
return tr.append("
| ");
};
return HRowGroup;
}(RowGroup_1.default));
exports.default = HRowGroup;
HRowGroup.prototype.hasOwnRow = true; // actually renders its own row and takes up height
/***/ }),
/* 48 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var $ = __webpack_require__(2);
var fullcalendar_1 = __webpack_require__(0);
var Resource_1 = __webpack_require__(19);
var ResourceManager_1 = __webpack_require__(49);
var ResourceComponentFootprint_1 = __webpack_require__(6);
// NOTE: for public methods, always be sure of the return value. for chaining
var origMethods = {
constructed: fullcalendar_1.Calendar.prototype.constructed,
buildSelectFootprint: fullcalendar_1.Calendar.prototype.buildSelectFootprint
};
// option defaults
fullcalendar_1.Calendar.defaults.refetchResourcesOnNavigate = false;
fullcalendar_1.Calendar.defaults.filterResourcesWithEvents = false;
fullcalendar_1.Calendar.prototype.resourceManager = null;
fullcalendar_1.Calendar.prototype.constructed = function () {
origMethods.constructed.apply(this, arguments);
this.resourceManager = new ResourceManager_1.default(this);
};
fullcalendar_1.Calendar.prototype.instantiateView = function (viewType) {
var spec = this.viewSpecManager.getViewSpec(viewType);
var viewClass = spec['class'];
if (this.opt('resources') && (spec.options.resources !== false)) {
if (spec.queryResourceClass) {
viewClass = spec.queryResourceClass(spec) || viewClass; // might return falsy
}
else if (spec.resourceClass) {
viewClass = spec.resourceClass;
}
}
return new viewClass(this, spec);
};
// for the API only
// retrieves what is currently in memory. no fetching
fullcalendar_1.Calendar.prototype.getResources = function () {
return Array.prototype.slice.call(// make a copy
this.resourceManager.topLevelResources);
};
// assumes all resources already loaded
fullcalendar_1.Calendar.prototype.addResource = function (resourceInput, scroll) {
var _this = this;
if (scroll === void 0) { scroll = false; }
this.resourceManager.addResource(resourceInput)
.then(function (resource) {
if (scroll && _this.view.scrollToResource) {
return _this.view.scrollToResource(resource);
}
});
};
// assumes all resources already loaded
fullcalendar_1.Calendar.prototype.removeResource = function (idOrResource) {
return this.resourceManager.removeResource(idOrResource);
};
fullcalendar_1.Calendar.prototype.refetchResources = function () {
this.resourceManager.clear();
this.view.flash('initialResources');
};
fullcalendar_1.Calendar.prototype.rerenderResources = function () {
this.resourceManager.resetCurrentResources();
};
fullcalendar_1.Calendar.prototype.buildSelectFootprint = function (zonedStartInput, zonedEndInput, resourceId) {
var plainFootprint = origMethods.buildSelectFootprint.apply(this, arguments);
if (resourceId) {
return new ResourceComponentFootprint_1.default(plainFootprint.unzonedRange, plainFootprint.isAllDay, resourceId);
}
else {
return plainFootprint;
}
};
fullcalendar_1.Calendar.prototype.getResourceById = function (id) {
return this.resourceManager.getResourceById(id);
};
// Resources + Events
// ----------------------------------------------------------------------------------------
// DEPRECATED. for external API backwards compatibility
fullcalendar_1.Calendar.prototype.getEventResourceId = function (event) {
return this.getEventResourceIds(event)[0];
};
fullcalendar_1.Calendar.prototype.getEventResourceIds = function (event) {
var eventDef = this.eventManager.getEventDefByUid(event._id);
if (eventDef) {
return eventDef.getResourceIds();
}
else {
return [];
}
};
// DEPRECATED
fullcalendar_1.Calendar.prototype.setEventResourceId = function (event, resourceId) {
this.setEventResourceIds(event, resourceId ? [resourceId] : []);
};
fullcalendar_1.Calendar.prototype.setEventResourceIds = function (event, resourceIds) {
var eventDef = this.eventManager.getEventDefByUid(event._id);
if (eventDef) {
eventDef.resourceIds = resourceIds.map(function (rawResourceId) {
return Resource_1.default.normalizeId(rawResourceId);
});
}
};
// NOTE: views pair *segments* to resources. that's why there's no code reuse
fullcalendar_1.Calendar.prototype.getResourceEvents = function (idOrResource) {
var _this = this;
var resource = typeof idOrResource === 'object' ?
idOrResource :
this.getResourceById(idOrResource);
if (resource) {
// return the event cache, filtered by events assigned to the resource
// TODO: move away from using clientId
return this.clientEvents(function (event) {
return $.inArray(resource.id, _this.getEventResourceIds(event)) !== -1;
});
}
else {
return [];
}
};
// DEPRECATED. for external API backwards compatibility
fullcalendar_1.Calendar.prototype.getEventResource = function (idOrEvent) {
return this.getEventResources(idOrEvent)[0];
};
fullcalendar_1.Calendar.prototype.getEventResources = function (idOrEvent) {
var event = typeof idOrEvent === 'object' ?
idOrEvent :
this.clientEvents(idOrEvent)[0];
var resources = [];
if (event) {
for (var _i = 0, _a = this.getEventResourceIds(event); _i < _a.length; _i++) {
var resourceId = _a[_i];
var resource = this.getResourceById(resourceId);
if (resource) {
resources.push(resource);
}
}
}
return resources;
};
/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = __webpack_require__(1);
var $ = __webpack_require__(2);
var fullcalendar_1 = __webpack_require__(0);
var ResourceManager = /** @class */ (function (_super) {
tslib_1.__extends(ResourceManager, _super);
function ResourceManager(calendar) {
var _this = _super.call(this) || this;
_this.fetchId = 0;
_this.calendar = calendar;
_this.initializeCache();
return _this;
}
// Resource Data Getting
// ------------------------------------------------------------------------------------------------------------------
/*
Like fetchResources, but won't refetch if already fetched.
*/
ResourceManager.prototype.getResources = function (start, end) {
var isSameRange = (!start && !this.currentStart) || // both nonexistent ranges?
(start && this.currentStart && start.isSame(this.currentStart) && end.isSame(this.currentEnd));
if (!this.fetching || !isSameRange) {
return this.fetchResources(start, end);
}
else {
return this.fetching;
}
};
/*
Will always fetch, even if done previously.
Accepts optional chrono-related params to pass on to the raw resource sources.
Returns a promise.
*/
ResourceManager.prototype.fetchResources = function (start, end) {
var _this = this;
var currentFetchId = (this.fetchId += 1);
return this.fetching =
fullcalendar_1.Promise.construct(function (resolve, reject) {
_this.fetchResourceInputs(function (resourceInputs) {
if (currentFetchId === _this.fetchId) {
_this.setResources(resourceInputs);
return resolve(_this.topLevelResources);
}
else {
return reject();
}
}, start, end);
});
};
/*
Accepts optional chrono-related params to pass on to the raw resource sources.
Calls callback when done.
*/
ResourceManager.prototype.fetchResourceInputs = function (callback, start, end) {
var _this = this;
var calendar = this.calendar;
var source = calendar.opt('resources');
var timezone = calendar.opt('timezone');
if ($.type(source) === 'string') {
source = { url: source };
}
switch ($.type(source)) {
case 'function':
this.calendar.pushLoading();
source(function (resourceInputs) {
_this.calendar.popLoading();
callback(resourceInputs);
}, start, end, calendar.opt('timezone'));
break;
case 'object':
calendar.pushLoading();
var requestParams = {};
if (start && end) {
requestParams[calendar.opt('startParam')] = start.format();
requestParams[calendar.opt('endParam')] = end.format();
// mimick what EventManager does
// TODO: more DRY
if (timezone && (timezone !== 'local')) {
requestParams[calendar.opt('timezoneParam')] = timezone;
}
}
$.ajax(// TODO: handle failure
$.extend({ data: requestParams }, ResourceManager.ajaxDefaults, source)).then(function (resourceInputs) {
calendar.popLoading();
callback(resourceInputs);
});
break;
case 'array':
callback(source);
break;
default:
callback([]);
break;
}
};
ResourceManager.prototype.getResourceById = function (id) {
return this.resourcesById[id];
};
// assumes already completed fetch
// does not guarantee order
ResourceManager.prototype.getFlatResources = function () {
var result = [];
for (var id in this.resourcesById) {
result.push(this.resourcesById[id]);
}
return result;
};
// Resource Adding
// ------------------------------------------------------------------------------------------------------------------
ResourceManager.prototype.initializeCache = function () {
this.topLevelResources = [];
this.resourcesById = {};
};
ResourceManager.prototype.setResources = function (resourceInputs) {
var _this = this;
var resource;
var wasSet = Boolean(this.topLevelResources);
this.initializeCache();
var resources = resourceInputs.map(function (resourceInput) { return (_this.buildResource(resourceInput)); });
var validResources = [];
for (var _i = 0, resources_1 = resources; _i < resources_1.length; _i++) {
resource = resources_1[_i];
if (this.addResourceToIndex(resource)) {
validResources.push(resource);
}
}
for (var _a = 0, validResources_1 = validResources; _a < validResources_1.length; _a++) {
resource = validResources_1[_a];
this.addResourceToTree(resource);
}
if (wasSet) {
this.trigger('reset', this.topLevelResources);
}
else {
this.trigger('set', this.topLevelResources);
}
this.calendar.publiclyTrigger('resourcesSet', [this.topLevelResources]);
};
ResourceManager.prototype.resetCurrentResources = function () {
if (this.topLevelResources) {
this.trigger('reset', this.topLevelResources);
}
};
ResourceManager.prototype.clear = function () {
this.topLevelResources = null;
this.fetching = null;
};
ResourceManager.prototype.addResource = function (resourceInput) {
var _this = this;
if (this.fetching) {
return this.fetching.then(function () {
var resource = _this.buildResource(resourceInput);
if (_this.addResourceToIndex(resource)) {
_this.addResourceToTree(resource);
_this.trigger('add', resource, _this.topLevelResources);
return resource;
}
else {
return false;
}
});
}
else {
return fullcalendar_1.Promise.reject();
}
};
ResourceManager.prototype.addResourceToIndex = function (resource) {
if (this.resourcesById[resource.id]) {
return false;
}
else {
this.resourcesById[resource.id] = resource;
for (var _i = 0, _a = resource.children; _i < _a.length; _i++) {
var child = _a[_i];
this.addResourceToIndex(child);
}
return true;
}
};
ResourceManager.prototype.addResourceToTree = function (resource) {
if (!resource.parent) {
var siblings = void 0;
var parentId = String(resource['parentId'] != null ? resource['parentId'] : '');
if (parentId) {
var parent_1 = this.resourcesById[parentId];
if (parent_1) {
resource.parent = parent_1;
siblings = parent_1.children;
}
else {
return false;
}
}
else {
siblings = this.topLevelResources;
}
siblings.push(resource);
}
return true;
};
// Resource Removing
// ------------------------------------------------------------------------------------------------------------------
ResourceManager.prototype.removeResource = function (idOrResource) {
var _this = this;
var id = typeof idOrResource === 'object' ?
idOrResource.id :
idOrResource;
if (this.fetching) {
return this.fetching.then(function () {
var resource = _this.removeResourceFromIndex(id);
if (resource) {
_this.removeResourceFromTree(resource);
_this.trigger('remove', resource, _this.topLevelResources);
}
return resource;
});
}
else {
return fullcalendar_1.Promise.reject();
}
};
ResourceManager.prototype.removeResourceFromIndex = function (resourceId) {
var resource = this.resourcesById[resourceId];
if (resource) {
delete this.resourcesById[resourceId];
for (var _i = 0, _a = resource.children; _i < _a.length; _i++) {
var child = _a[_i];
this.removeResourceFromIndex(child.id);
}
return resource;
}
else {
return false;
}
};
ResourceManager.prototype.removeResourceFromTree = function (resource, siblings) {
if (siblings === void 0) { siblings = this.topLevelResources; }
for (var i = 0; i < siblings.length; i++) {
var sibling = siblings[i];
if (sibling === resource) {
resource.parent = null;
siblings.splice(i, 1);
return true;
}
if (this.removeResourceFromTree(resource, sibling.children)) {
return true;
}
}
return false;
};
// Resource Data Utils
// ------------------------------------------------------------------------------------------------------------------
ResourceManager.prototype.buildResource = function (resourceInput) {
var _this = this;
var resource = $.extend({}, resourceInput);
var rawClassName = resourceInput.eventClassName;
resource.id = String(resourceInput.id != null ?
resourceInput.id :
'_fc' + (ResourceManager.resourceGuid++));
// TODO: consolidate repeat logic
resource.eventClassName = (function () {
switch ($.type(rawClassName)) {
case 'string':
return rawClassName.split(/\s+/);
case 'array':
return rawClassName;
default:
return [];
}
})();
if (resourceInput.businessHours) {
resource.businessHourGenerator = new fullcalendar_1.BusinessHourGenerator(resourceInput.businessHours, this.calendar);
}
resource.children = (resourceInput.children || []).map(function (childInput) {
var child = _this.buildResource(childInput);
child.parent = resource;
return child;
});
return resource;
};
ResourceManager.resourceGuid = 1;
ResourceManager.ajaxDefaults = {
dataType: 'json',
cache: false
};
return ResourceManager;
}(fullcalendar_1.Class));
exports.default = ResourceManager;
fullcalendar_1.EmitterMixin.mixInto(ResourceManager);
/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var $ = __webpack_require__(2);
var fullcalendar_1 = __webpack_require__(0);
var Resource_1 = __webpack_require__(19);
var ResourceComponentFootprint_1 = __webpack_require__(6);
var origMethods = {
getPeerEventInstances: fullcalendar_1.Constraints.prototype.getPeerEventInstances,
isFootprintAllowed: fullcalendar_1.Constraints.prototype.isFootprintAllowed,
buildCurrentBusinessFootprints: fullcalendar_1.Constraints.prototype.buildCurrentBusinessFootprints,
footprintContainsFootprint: fullcalendar_1.Constraints.prototype.footprintContainsFootprint,
footprintsIntersect: fullcalendar_1.Constraints.prototype.footprintsIntersect,
eventRangeToEventFootprints: fullcalendar_1.Constraints.prototype.eventRangeToEventFootprints,
parseFootprints: fullcalendar_1.Constraints.prototype.parseFootprints
};
fullcalendar_1.Constraints.prototype.getPeerEventInstances = function (subjectEventDef) {
var subjectResourceIds = subjectEventDef.getResourceIds();
var peerInstances = origMethods.getPeerEventInstances.apply(this, arguments);
if (!subjectResourceIds.length) {
return peerInstances;
}
else {
return peerInstances.filter(function (peerInstance) {
// always consider non-resource events to be peers
if (!peerInstance.def.resourceIds.length) {
return true;
}
// has same resource? consider it a peer
for (var _i = 0, subjectResourceIds_1 = subjectResourceIds; _i < subjectResourceIds_1.length; _i++) {
var resourceId = subjectResourceIds_1[_i];
if (peerInstance.def.hasResourceId(resourceId)) {
return true;
}
}
return false;
});
}
};
// enforce resource ID constraint
fullcalendar_1.Constraints.prototype.isFootprintAllowed = function (footprint, peerEventFootprints, constraintVal, overlapVal, subjectEventInstance) {
if (typeof constraintVal === 'object') {
var constrainToResourceIds = Resource_1.default.extractIds(constraintVal, this);
if (constrainToResourceIds.length && (!(footprint instanceof ResourceComponentFootprint_1.default) ||
$.inArray(footprint.resourceId, constrainToResourceIds) === -1)) {
return false;
}
}
return origMethods.isFootprintAllowed.apply(this, arguments);
};
fullcalendar_1.Constraints.prototype.buildCurrentBusinessFootprints = function (isAllDay) {
var flatResources = this._calendar.resourceManager.getFlatResources();
var anyCustomBusinessHours = false;
// any per-resource business hours? or will one global businessHours suffice?
for (var _i = 0, flatResources_1 = flatResources; _i < flatResources_1.length; _i++) {
var resource = flatResources_1[_i];
if (resource.businessHourGenerator) {
anyCustomBusinessHours = true;
}
}
// if there are any custom business hours, all business hours must be sliced per-resources
if (anyCustomBusinessHours) {
var view = this._calendar.view;
var generalBusinessHourGenerator = view.get('businessHourGenerator');
var unzonedRange = view.dateProfile.activeUnzonedRange;
var componentFootprints = [];
for (var _a = 0, flatResources_2 = flatResources; _a < flatResources_2.length; _a++) {
var resource = flatResources_2[_a];
var businessHourGenerator = resource.businessHourGenerator || generalBusinessHourGenerator;
var eventInstanceGroup = businessHourGenerator.buildEventInstanceGroup(isAllDay, unzonedRange);
if (eventInstanceGroup) {
for (var _b = 0, _c = eventInstanceGroup.getAllEventRanges(); _b < _c.length; _b++) {
var eventRange = _c[_b];
componentFootprints.push(new ResourceComponentFootprint_1.default(eventRange.unzonedRange, isAllDay, // isAllDay
resource.id));
}
}
}
return componentFootprints;
}
else {
return origMethods.buildCurrentBusinessFootprints.apply(this, arguments);
}
};
fullcalendar_1.Constraints.prototype.footprintContainsFootprint = function (outerFootprint, innerFootprint) {
if (outerFootprint instanceof ResourceComponentFootprint_1.default &&
(!(innerFootprint instanceof ResourceComponentFootprint_1.default) ||
(innerFootprint.resourceId !== outerFootprint.resourceId))) {
return false;
}
return origMethods.footprintContainsFootprint.apply(this, arguments);
};
fullcalendar_1.Constraints.prototype.footprintsIntersect = function (footprint0, footprint1) {
if (footprint0 instanceof ResourceComponentFootprint_1.default &&
footprint1 instanceof ResourceComponentFootprint_1.default &&
(footprint0.resourceId !== footprint1.resourceId)) {
return false;
}
return origMethods.footprintsIntersect.apply(this, arguments);
};
/*
TODO: somehow more DRY with DateComponent::eventRangeToEventFootprints monkeypatch
*/
fullcalendar_1.Constraints.prototype.eventRangeToEventFootprints = function (eventRange) {
var eventDef = eventRange.eventDef;
var resourceIds = eventDef.getResourceIds();
if (resourceIds.length) {
return resourceIds.map(function (resourceId) { return (new fullcalendar_1.EventFootprint(new ResourceComponentFootprint_1.default(eventRange.unzonedRange, eventDef.isAllDay(), resourceId), eventDef, eventRange.eventInstance // might not exist
)); });
}
else {
return origMethods.eventRangeToEventFootprints.apply(this, arguments);
}
};
fullcalendar_1.Constraints.prototype.parseFootprints = function (input) {
var plainFootprints = origMethods.parseFootprints.apply(this, arguments);
var resourceIds = input.resourceIds || [];
if (input.resourceId) {
resourceIds = [input.resourceId].concat(resourceIds);
}
if (resourceIds.length) {
var footprints = [];
for (var _i = 0, resourceIds_1 = resourceIds; _i < resourceIds_1.length; _i++) {
var resourceId = resourceIds_1[_i];
for (var _a = 0, plainFootprints_1 = plainFootprints; _a < plainFootprints_1.length; _a++) {
var plainFootprint = plainFootprints_1[_a];
footprints.push(new ResourceComponentFootprint_1.default(plainFootprint.unzonedRange, plainFootprint.isAllDay, resourceId));
}
}
return footprints;
}
else {
return plainFootprints;
}
};
/***/ }),
/* 51 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
var license_1 = __webpack_require__(52);
// pre-monkeypatch methods
var origMethods = {
setElement: fullcalendar_1.View.prototype.setElement,
removeElement: fullcalendar_1.View.prototype.removeElement,
triggerViewRender: fullcalendar_1.View.prototype.triggerViewRender
};
// new properties
fullcalendar_1.View.prototype.canHandleSpecificResources = false;
// View Rendering
// --------------------------------------------------------------------------------------------------
fullcalendar_1.View.prototype.setElement = function () {
origMethods.setElement.apply(this, arguments);
this.watchResources(); // do after have the el, because might render, which assumes a render skeleton
};
fullcalendar_1.View.prototype.removeElement = function () {
this.unwatchResources();
origMethods.removeElement.apply(this, arguments);
};
// Show the warning even for non-resource views
// inject license key before 'viewRender' which is called by super's afterBaseDisplay
fullcalendar_1.View.prototype.triggerViewRender = function () {
license_1.processLicenseKey(this.opt('schedulerLicenseKey'), this.el // container element
);
origMethods.triggerViewRender.apply(this, arguments);
};
// Resource Binding
// --------------------------------------------------------------------------------------------------
fullcalendar_1.View.prototype.watchResources = function () {
var _this = this;
var initialDepNames = [];
var bindingDepNames = ['initialResources'];
if (this.opt('refetchResourcesOnNavigate')) {
initialDepNames.push('dateProfile');
}
if (this.opt('filterResourcesWithEvents')) {
bindingDepNames.push('currentEvents');
}
this.watch('initialResources', initialDepNames, function (deps) {
return _this.getInitialResources(deps.dateProfile); // promise
});
this.watch('bindingResources', bindingDepNames, function (deps) {
_this.bindResourceChanges(deps.currentEvents);
_this.setResources(deps.initialResources, deps.currentEvents);
}, function () {
_this.unbindResourceChanges();
_this.unsetResources();
});
};
fullcalendar_1.View.prototype.unwatchResources = function () {
this.unwatch('initialResources');
this.unwatch('bindingResources');
};
// dateProfile is optional
fullcalendar_1.View.prototype.getInitialResources = function (dateProfile) {
var calendar = this.calendar;
if (dateProfile) {
return calendar.resourceManager.getResources(calendar.msToMoment(dateProfile.activeUnzonedRange.startMs, dateProfile.isRangeAllDay), calendar.msToMoment(dateProfile.activeUnzonedRange.endMs, dateProfile.isRangeAllDay));
}
else {
return calendar.resourceManager.getResources();
}
};
// eventsPayload is optional
fullcalendar_1.View.prototype.bindResourceChanges = function (eventsPayload) {
var _this = this;
this.listenTo(this.calendar.resourceManager, {
set: function (resources) {
_this.setResources(resources, eventsPayload);
},
unset: function () {
_this.unsetResources();
},
reset: function (resources) {
_this.resetResources(resources, eventsPayload);
},
add: function (resource, allResources) {
_this.addResource(resource, allResources, eventsPayload);
},
remove: function (resource, allResources) {
_this.removeResource(resource, allResources, eventsPayload);
}
});
};
fullcalendar_1.View.prototype.unbindResourceChanges = function () {
this.stopListeningTo(this.calendar.resourceManager);
};
// Event Rendering
// --------------------------------------------------------------------------------------------------
fullcalendar_1.View.watch('displayingEvents', ['displayingDates', 'hasEvents', 'currentResources'], function (deps) {
this.requestEventsRender(this.get('currentEvents'));
}, function () {
this.requestEventsUnrender();
});
// Resource Data
// --------------------------------------------------------------------------------------------------
// currentEvents is optional
fullcalendar_1.View.prototype.setResources = function (resources, eventsPayload) {
if (eventsPayload) {
resources = this.filterResourcesWithEvents(resources, eventsPayload);
}
this.set('currentResources', resources);
this.set('hasResources', true);
};
fullcalendar_1.View.prototype.unsetResources = function () {
this.unset('currentResources');
this.unset('hasResources');
};
// eventsPayload is optional
fullcalendar_1.View.prototype.resetResources = function (resources, eventsPayload) {
this.startBatchRender();
this.unsetResources();
this.setResources(resources, eventsPayload);
this.stopBatchRender();
};
// eventsPayload is optional
fullcalendar_1.View.prototype.addResource = function (resource, allResources, eventsPayload) {
if (!this.canHandleSpecificResources) {
this.resetResources(allResources, eventsPayload);
return;
}
if (eventsPayload) {
var a = this.filterResourcesWithEvents([resource], eventsPayload);
if (!a.length) {
resource = null;
}
}
if (resource) {
this.set('currentResources', allResources); // TODO: filter against eventsPayload?
this.handleResourceAdd(resource);
}
};
fullcalendar_1.View.prototype.removeResource = function (resource, allResources, eventsPayload) {
if (!this.canHandleSpecificResources) {
this.resetResources(allResources, eventsPayload);
return;
}
this.set('currentResources', allResources); // TODO: filter against eventsPayload?
this.handleResourceRemove(resource);
};
// Resource Change Handling
// --------------------------------------------------------------------------------------------------
fullcalendar_1.View.prototype.handleResourceAdd = function (resource) {
// subclasses should implement
};
fullcalendar_1.View.prototype.handleResourceRemove = function (resource) {
// subclasses should implement
};
// Resource Filtering
// ------------------------------------------------------------------------------------------------------------------
fullcalendar_1.View.prototype.filterResourcesWithEvents = function (resources, eventsPayload) {
var eventRanges = this.eventsPayloadToRanges(eventsPayload);
var resourceIdHits = {};
for (var _i = 0, eventRanges_1 = eventRanges; _i < eventRanges_1.length; _i++) {
var eventRange = eventRanges_1[_i];
for (var _a = 0, _b = eventRange.eventDef.getResourceIds(); _a < _b.length; _a++) {
var resourceId = _b[_a];
resourceIdHits[resourceId] = true;
}
}
return _filterResourcesWithEvents(resources, resourceIdHits);
};
fullcalendar_1.View.prototype.eventsPayloadToRanges = function (eventsPayload) {
var dateProfile = this._getDateProfile();
var allEventRanges = [];
for (var eventDefId in eventsPayload) {
var instanceGroup = eventsPayload[eventDefId];
var eventRanges = instanceGroup.sliceRenderRanges(dateProfile.activeUnzonedRange);
allEventRanges.push.apply(allEventRanges, (eventRanges || []));
}
return allEventRanges;
};
// provides a new structure with masked objects
function _filterResourcesWithEvents(sourceResources, resourceIdHits) {
var filteredResources = [];
for (var _i = 0, sourceResources_1 = sourceResources; _i < sourceResources_1.length; _i++) {
var sourceResource = sourceResources_1[_i];
if (sourceResource.children.length) {
var filteredChildren = _filterResourcesWithEvents(sourceResource.children, resourceIdHits);
if (filteredChildren.length || resourceIdHits[sourceResource.id]) {
var filteredResource = Object.create(sourceResource); // mask
filteredResource.children = filteredChildren;
filteredResources.push(filteredResource);
}
}
else {
if (resourceIdHits[sourceResource.id]) {
filteredResources.push(sourceResource);
}
}
}
return filteredResources;
}
/***/ }),
/* 52 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var $ = __webpack_require__(2);
var moment = __webpack_require__(15);
var exportHooks = __webpack_require__(0);
var RELEASE_DATE = '2018-01-28'; // for Scheduler
var UPGRADE_WINDOW = { years: 1, weeks: 1 }; // 1 week leeway, for tz shift reasons too
var LICENSE_INFO_URL = 'http://fullcalendar.io/scheduler/license/';
var PRESET_LICENSE_KEYS = [
'GPL-My-Project-Is-Open-Source',
'CC-Attribution-NonCommercial-NoDerivatives'
];
function processLicenseKey(key, containerEl) {
if (!isImmuneUrl(window.location.href) && !isValidKey(key)) {
if (!detectWarningInContainer(containerEl)) {
return renderingWarningInContainer('Please use a valid license key.
More Info', containerEl);
}
}
}
exports.processLicenseKey = processLicenseKey;
/*
This decryption is not meant to be bulletproof. Just a way to remind about an upgrade.
*/
function isValidKey(key) {
if ($.inArray(key, PRESET_LICENSE_KEYS) !== -1) {
return true;
}
var parts = (key || '').match(/^(\d+)\-fcs\-(\d+)$/);
if (parts && (parts[1].length === 10)) {
var purchaseDate = moment.utc(parseInt(parts[2], 10) * 1000);
var releaseDate = moment.utc(exportHooks.mockSchedulerReleaseDate || RELEASE_DATE);
if (releaseDate.isValid()) {
var minPurchaseDate = releaseDate.clone().subtract(UPGRADE_WINDOW);
if (purchaseDate.isAfter(minPurchaseDate)) {
return true;
}
}
}
return false;
}
exports.isValidKey = isValidKey;
function isImmuneUrl(url) {
return /\w+\:\/\/fullcalendar\.io\/|\/demos\/[\w-]+\.html$/.test(url);
}
exports.isImmuneUrl = isImmuneUrl;
function renderingWarningInContainer(messageHtml, containerEl) {
return containerEl.append($('
').html(messageHtml));
}
exports.renderingWarningInContainer = renderingWarningInContainer;
// returns boolean of whether a license message is already rendered
function detectWarningInContainer(containerEl) {
return containerEl.find('.fc-license-message').length >= 1;
}
exports.detectWarningInContainer = detectWarningInContainer;
/***/ }),
/* 53 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
var ResourceComponentFootprint_1 = __webpack_require__(6);
// references to pre-monkeypatched methods
var origMethods = {
eventRangeToEventFootprints: fullcalendar_1.DateComponent.prototype.eventRangeToEventFootprints
};
// configuration for subclasses
fullcalendar_1.DateComponent.prototype.isResourceFootprintsEnabled = false;
fullcalendar_1.DateComponent.prototype.eventRangeToEventFootprints = function (eventRange) {
if (!this.isResourceFootprintsEnabled) {
return origMethods.eventRangeToEventFootprints.apply(this, arguments);
}
else {
var eventDef_1 = eventRange.eventDef;
var resourceIds = eventDef_1.getResourceIds();
if (resourceIds.length) {
return resourceIds.map(function (resourceId) { return (new fullcalendar_1.EventFootprint(new ResourceComponentFootprint_1.default(eventRange.unzonedRange, eventDef_1.isAllDay(), resourceId), eventDef_1, eventRange.eventInstance // might not exist
)); });
}
else if (eventDef_1.hasBgRendering()) {
return origMethods.eventRangeToEventFootprints.apply(this, arguments);
}
else {
return [];
}
}
};
// Resource Low-level Rendering
// ----------------------------------------------------------------------------------------------
// ResourceViewMixin wires these up
fullcalendar_1.DateComponent.prototype.renderResources = function (resources) {
this.callChildren('renderResources', arguments);
};
fullcalendar_1.DateComponent.prototype.unrenderResources = function () {
this.callChildren('unrenderResources', arguments);
};
fullcalendar_1.DateComponent.prototype.renderResource = function (resource) {
this.callChildren('renderResource', arguments);
};
fullcalendar_1.DateComponent.prototype.unrenderResource = function (resource) {
this.callChildren('unrenderResource', arguments);
};
/***/ }),
/* 54 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
// references to pre-monkeypatched methods
var origMethods = {
isEventDefDraggable: fullcalendar_1.InteractiveDateComponent.prototype.isEventDefDraggable
};
// configuration for subclasses
// whether we should attempt to render selections or resizes that span across different resources
fullcalendar_1.InteractiveDateComponent.prototype.allowCrossResource = true;
// ^ is this worth the complexity?
// if an event's dates are not draggable, but it's resource IS, still allow dragging
fullcalendar_1.InteractiveDateComponent.prototype.isEventDefDraggable = function (eventDef) {
return this.isEventDefResourceEditable(eventDef) ||
origMethods.isEventDefDraggable.call(this, eventDef);
};
fullcalendar_1.InteractiveDateComponent.prototype.isEventDefResourceEditable = function (eventDef) {
var bool = eventDef.resourceEditable;
if (bool == null) {
bool = (eventDef.source || {}).resourceEditable;
if (bool == null) {
bool = this.opt('eventResourceEditable');
if (bool == null) {
bool = this.isEventDefGenerallyEditable(eventDef);
}
}
}
return bool;
};
/***/ }),
/* 55 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
// references to pre-monkeypatched methods
var origMethods = {
getFallbackStylingObjs: fullcalendar_1.EventRenderer.prototype.getFallbackStylingObjs
};
fullcalendar_1.EventRenderer.prototype.designatedResource = null; // optionally set by caller. forces @currentResource
fullcalendar_1.EventRenderer.prototype.currentResource = null; // when set, will affect future rendered segs
fullcalendar_1.EventRenderer.prototype.beforeFgSegHtml = function (seg) {
var segResourceId = seg.footprint.componentFootprint.resourceId;
if (this.designatedResource) {
this.currentResource = this.designatedResource;
}
else if (segResourceId) {
this.currentResource = queryResourceObject(this, segResourceId);
}
else {
this.currentResource = null;
}
};
fullcalendar_1.EventRenderer.prototype.getFallbackStylingObjs = function (eventDef) {
var objs = origMethods.getFallbackStylingObjs.apply(this, arguments);
if (this.currentResource) {
objs.unshift(this.currentResource);
}
else {
var resources = [];
for (var _i = 0, _a = eventDef.getResourceIds(); _i < _a.length; _i++) {
var id = _a[_i];
var resource = queryResourceObject(this, id);
if (resource) {
resources.push(resource);
}
}
objs = resources.concat(objs);
}
return objs;
};
function queryResourceObject(eventRenderer, id) {
return eventRenderer.view.calendar.resourceManager.getResourceById(id);
}
/***/ }),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
var ResourceComponentFootprint_1 = __webpack_require__(6);
// references to pre-monkeypatched methods
var origMethods = {
computeSelectionFootprint: fullcalendar_1.DateSelecting.prototype.computeSelectionFootprint
};
fullcalendar_1.DateSelecting.prototype.computeSelectionFootprint = function (startFootprint, endFootprint) {
if (startFootprint.resourceId && endFootprint.resourceId &&
(startFootprint.resourceId !== endFootprint.resourceId) &&
!this.component.allowCrossResource) {
return null; // explicity disallow selection across two different resources
}
else {
var footprint = origMethods.computeSelectionFootprint.apply(this, arguments);
if (startFootprint.resourceId) {
// create a new footprint with resourceId data
footprint = new ResourceComponentFootprint_1.default(footprint.unzonedRange, footprint.isAllDay, startFootprint.resourceId);
}
return footprint;
}
};
/***/ }),
/* 57 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
// references to pre-monkeypatched methods
var origMethods = {
computeEventDropMutation: fullcalendar_1.EventDragging.prototype.computeEventDropMutation
};
/*
monkeypatching can cause an event to seem draggable if the resource is editable but the
start/end dates are NOT. make sure to account for this.
*/
fullcalendar_1.EventDragging.prototype.computeEventDropMutation = function (startFootprint, endFootprint, eventDef) {
var isDatesDraggable = this.component.isEventDefStartEditable(eventDef);
if (startFootprint.resourceId && endFootprint.resourceId &&
(startFootprint.resourceId !== endFootprint.resourceId) &&
this.component.isEventDefResourceEditable(eventDef)) {
var mutation = new fullcalendar_1.EventDefMutation();
mutation.oldResourceId = startFootprint.resourceId;
mutation.newResourceId = endFootprint.resourceId;
if (isDatesDraggable) {
mutation.setDateMutation(this.computeEventDateMutation(startFootprint, endFootprint));
}
return mutation;
}
else if (isDatesDraggable) {
return origMethods.computeEventDropMutation.apply(this, arguments);
}
};
/***/ }),
/* 58 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
// references to pre-monkeypatched methods
var origMethods = {
computeEventStartResizeMutation: fullcalendar_1.EventResizing.prototype.computeEventStartResizeMutation,
computeEventEndResizeMutation: fullcalendar_1.EventResizing.prototype.computeEventEndResizeMutation
};
fullcalendar_1.EventResizing.prototype.computeEventStartResizeMutation = function (startFootprint, endFootprint, origEventFootprint) {
if (startFootprint.resourceId && endFootprint.resourceId &&
(startFootprint.resourceId !== endFootprint.resourceId) &&
!this.component.allowCrossResource) {
return null; // explicity disallow resizing across two different resources
}
else {
return origMethods.computeEventStartResizeMutation.apply(this, arguments);
}
};
fullcalendar_1.EventResizing.prototype.computeEventEndResizeMutation = function (startFootprint, endFootprint, origEventFootprint) {
if (startFootprint.resourceId && endFootprint.resourceId &&
(startFootprint.resourceId !== endFootprint.resourceId) &&
!this.component.allowCrossResource) {
return null; // explicity disallow resizing across two different resources
}
else {
return origMethods.computeEventEndResizeMutation.apply(this, arguments);
}
};
/***/ }),
/* 59 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
// references to pre-monkeypatched methods
var origMethods = {
computeExternalDrop: fullcalendar_1.ExternalDropping.prototype.computeExternalDrop
};
fullcalendar_1.ExternalDropping.prototype.computeExternalDrop = function (componentFootprint, meta) {
var eventDef = origMethods.computeExternalDrop.apply(this, arguments);
if (componentFootprint.resourceId) {
eventDef.addResourceId(componentFootprint.resourceId);
}
return eventDef;
};
/***/ }),
/* 60 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
// defineStandardProps won't work :(
// TODO: find a better way
fullcalendar_1.EventSource.prototype.standardPropMap.resourceEditable = true; // automatically transfer
/***/ }),
/* 61 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var $ = __webpack_require__(2);
var fullcalendar_1 = __webpack_require__(0);
var Resource_1 = __webpack_require__(19);
var origMethods = {
applyMiscProps: fullcalendar_1.EventDef.prototype.applyMiscProps,
clone: fullcalendar_1.EventDef.prototype.clone,
toLegacy: fullcalendar_1.EventDef.prototype.toLegacy
};
fullcalendar_1.EventDef.defineStandardProps({
resourceEditable: true // automatically transfer
});
/*
new class members
*/
fullcalendar_1.EventDef.prototype.resourceIds = null;
fullcalendar_1.EventDef.prototype.resourceEditable = null; // `null` is unspecified state
/*
NOTE: we can use defineStandardProps/applyManualStandardProps (example below)
once we do away with the deprecated eventResourceField.
*/
fullcalendar_1.EventDef.prototype.applyMiscProps = function (rawProps) {
rawProps = $.extend({}, rawProps); // clone, because of delete
this.resourceIds = Resource_1.default.extractIds(rawProps, this.source.calendar);
delete rawProps.resourceId;
delete rawProps.resourceIds;
origMethods.applyMiscProps.apply(this, arguments);
};
/*
EventDef.defineStandardProps({
resourceId: false # manually handle
resourceIds: false # manually handle
});
EventDef.prototype.applyManualStandardProps = function(rawProps) {
origApplyManualStandardProps.apply(this, arguments);
this.resourceIds = Resource.extractIds(rawProps, this.source.calendar);
};
*/
/*
resourceId should already be normalized
*/
fullcalendar_1.EventDef.prototype.hasResourceId = function (resourceId) {
return $.inArray(resourceId, this.resourceIds) !== -1;
};
/*
resourceId should already be normalized
*/
fullcalendar_1.EventDef.prototype.removeResourceId = function (resourceId) {
fullcalendar_1.removeExact(this.resourceIds, resourceId);
};
/*
resourceId should already be normalized
*/
fullcalendar_1.EventDef.prototype.addResourceId = function (resourceId) {
if (!this.hasResourceId(resourceId)) {
this.resourceIds.push(resourceId);
}
};
fullcalendar_1.EventDef.prototype.getResourceIds = function () {
if (this.resourceIds) {
return this.resourceIds.slice(); // clone
}
else {
return [];
}
};
fullcalendar_1.EventDef.prototype.clone = function () {
var def = origMethods.clone.apply(this, arguments);
def.resourceIds = this.getResourceIds();
return def;
};
fullcalendar_1.EventDef.prototype.toLegacy = function () {
var obj = origMethods.toLegacy.apply(this, arguments);
var resourceIds = this.getResourceIds();
obj.resourceId =
resourceIds.length === 1 ?
resourceIds[0] :
null;
obj.resourceIds =
resourceIds.length > 1 ?
resourceIds :
null;
if (this.resourceEditable != null) {
obj.resourceEditable = this.resourceEditable;
}
return obj;
};
/***/ }),
/* 62 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
var oldMutateSingle = fullcalendar_1.EventDefMutation.prototype.mutateSingle;
// either both will be set, or neither will be set
fullcalendar_1.EventDefMutation.prototype.oldResourceId = null;
fullcalendar_1.EventDefMutation.prototype.newResourceId = null;
fullcalendar_1.EventDefMutation.prototype.mutateSingle = function (eventDef) {
var undo = oldMutateSingle.apply(this, arguments);
var savedResourceIds = null;
if (this.oldResourceId && eventDef.hasResourceId(this.oldResourceId)) {
savedResourceIds = eventDef.getResourceIds();
eventDef.removeResourceId(this.oldResourceId);
eventDef.addResourceId(this.newResourceId);
}
return function () {
undo();
if (savedResourceIds) {
eventDef.resourceIds = savedResourceIds;
}
};
};
/***/ }),
/* 63 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
var TimelineView_1 = __webpack_require__(14);
fullcalendar_1.defineView('timeline', {
class: TimelineView_1.default,
defaults: {
eventResizableFromStart: true
}
});
fullcalendar_1.defineView('timelineDay', {
type: 'timeline',
duration: { days: 1 }
});
fullcalendar_1.defineView('timelineWeek', {
type: 'timeline',
duration: { weeks: 1 }
});
fullcalendar_1.defineView('timelineMonth', {
type: 'timeline',
duration: { months: 1 }
});
fullcalendar_1.defineView('timelineYear', {
type: 'timeline',
duration: { years: 1 }
});
/***/ }),
/* 64 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
var ResourceTimelineView_1 = __webpack_require__(30);
fullcalendar_1.getViewConfig('timeline').resourceClass = ResourceTimelineView_1.default;
fullcalendar_1.Calendar.defaults.resourcesInitiallyExpanded = true;
/***/ }),
/* 65 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
var ResourceBasicView_1 = __webpack_require__(22);
var ResourceMonthView_1 = __webpack_require__(23);
// TODO: make more DRY (with agenda's config too)
fullcalendar_1.getViewConfig('basic').queryResourceClass = function (viewSpec) {
var explicitGrouping = viewSpec.options.groupByResource ||
viewSpec.options.groupByDateAndResource;
var showsResources = false;
if (explicitGrouping != null) {
showsResources = explicitGrouping;
}
else if (viewSpec.duration) {
showsResources = viewSpec.duration.as('days') === 1;
}
if (showsResources) {
return ResourceBasicView_1.default;
}
};
fullcalendar_1.getViewConfig('month').queryResourceClass = function (viewSpec) {
if (viewSpec.options.groupByResource ||
viewSpec.options.groupByDateAndResource) {
return ResourceMonthView_1.default;
}
};
/***/ }),
/* 66 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var fullcalendar_1 = __webpack_require__(0);
var ResourceAgendaView_1 = __webpack_require__(20);
/*
TODO: make more DRY, with basic's config
*/
fullcalendar_1.getViewConfig('agenda').queryResourceClass = function (viewSpec) {
var explicitGrouping = viewSpec.options.groupByResource ||
viewSpec.options.groupByDateAndResource;
var showsResources = false;
if (explicitGrouping != null) {
showsResources = explicitGrouping;
}
else if (viewSpec.duration) {
showsResources = viewSpec.duration.as('days') === 1;
}
if (showsResources) {
return ResourceAgendaView_1.default;
}
};
/***/ }),
/* 67 */
/***/ (function(module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
/***/ }),
/* 68 */
/***/ (function(module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
/***/ })
/******/ ]);
});