/**
* angular-bootstrap-calendar - A pure AngularJS bootstrap themed responsive calendar that can display events and has views for year, month, week and day
* @version v0.18.0
* @link https://github.com/mattlewis92/angular-bootstrap-calendar
* @license MIT
*/
(function webpackUniversalModuleDefinition(root, factory) {
if (typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("angular"), (function webpackLoadOptionalExternalModule() { try { return require("interact.js"); } catch (e) {} }()), require("moment"));
else if (typeof define === 'function' && define.amd)
define(["angular", "interact", "moment"], factory);
else if (typeof exports === 'object')
exports["angularBootstrapCalendarModuleName"] = factory(require("angular"), (function webpackLoadOptionalExternalModule() { try { return require("interact.js"); } catch (e) {} }()), require("moment"));
else
root["angularBootstrapCalendarModuleName"] = factory(root["angular"], root["interact"], root["moment"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_12__, __WEBPACK_EXTERNAL_MODULE_47__, __WEBPACK_EXTERNAL_MODULE_49__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/
var installedModules = {};
/******/ // The require function
/******/
function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/
if (installedModules[moduleId])
/******/
return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/
var module = installedModules[moduleId] = {
/******/
exports: {},
/******/
id: moduleId,
/******/
loaded: false
/******/
};
/******/ // Execute the module function
/******/
modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/
module.loaded = true;
/******/ // Return the exports of the module
/******/
return module.exports;
/******/
}
/******/ // expose the modules object (__webpack_modules__)
/******/
__webpack_require__.m = modules;
/******/ // expose the module cache
/******/
__webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/
__webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/
return __webpack_require__(0);
/******/
})
/************************************************************************/
/******/
([
/* 0 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
__webpack_require__(8);
var angular = __webpack_require__(12);
function requireAll(r) {
r.keys().forEach(r);
}
var templates = {};
if (true) {
var templatesContext = __webpack_require__(13);
templatesContext.keys().forEach(function(templateName) {
var templateNameWithoutPrefix = templateName.replace('./', '');
var cacheTemplateName = 'mwl/' + templateNameWithoutPrefix;
var configTemplateName = templateNameWithoutPrefix.replace('.html', '');
templates[configTemplateName] = {
cacheTemplateName: cacheTemplateName,
template: templatesContext(templateName)
};
});
}
module.exports = angular
.module('mwl.calendar', [])
.config(["calendarConfig", function(calendarConfig) {
angular.forEach(templates, function(template, templateName) {
if (!calendarConfig.templates[templateName]) {
calendarConfig.templates[templateName] = template.cacheTemplateName;
}
});
}])
.run(["$templateCache", function($templateCache) {
angular.forEach(templates, function(template) {
if (!$templateCache.get(template.cacheTemplateName)) {
$templateCache.put(template.cacheTemplateName, template.template);
}
});
}]).name;
requireAll(__webpack_require__(23));
requireAll(__webpack_require__(37));
requireAll(__webpack_require__(42));
/***/
},
/* 1 */
,
/* 2 */
,
/* 3 */
,
/* 4 */
,
/* 5 */
,
/* 6 */
,
/* 7 */
,
/* 8 */
/***/
function(module, exports) {
// removed by extract-text-webpack-plugin
/***/
},
/* 9 */
,
/* 10 */
,
/* 11 */
,
/* 12 */
/***/
function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_12__;
/***/
},
/* 13 */
/***/
function(module, exports, __webpack_require__) {
var map = {
"./calendar.html": 14,
"./calendarDayView.html": 15,
"./calendarHourList.html": 16,
"./calendarMonthCell.html": 17,
"./calendarMonthCellEvents.html": 18,
"./calendarMonthView.html": 19,
"./calendarSlideBox.html": 20,
"./calendarWeekView.html": 21,
"./calendarYearView.html": 22
};
function webpackContext(req) {
return __webpack_require__(webpackContextResolve(req));
};
function webpackContextResolve(req) {
return map[req] || (function() { throw new Error("Cannot find module '" + req + "'.") }());
};
webpackContext.keys = function webpackContextKeys() {
return Object.keys(map);
};
webpackContext.resolve = webpackContextResolve;
module.exports = webpackContext;
webpackContext.id = 13;
/***/
},
/* 14 */
/***/
function(module, exports) {
module.exports = "
\n\n
The value passed to the view attribute of the calendar is not set
\n\n
The value passed to view-date attribute of the calendar is not set
\n\n
\n\n
\n\n
\n\n
\n
\n";
/***/
},
/* 15 */
/***/
function(module, exports) {
module.exports = "\n
\n\n
\n\n
\n \n\n
\n\n
\n , \n \n \n
\n \n \n\n
\n\n
\n\n
\n";
/***/
},
/* 16 */
/***/
function(module, exports) {
module.exports = "\n\n
\n\n
\n\n
\n\n
\n\n
\n\n
\n\n
\n\n
\n\n
\n";
/***/
},
/* 17 */
/***/
function(module, exports) {
module.exports = "\n\n
0\"\n ng-bind=\"day.badgeTotal\">\n \n\n
\n \n\n
0\">\n \n \n
\n\n
\n\n
\n {{ vm.calendarConfig.i18nStrings.weekNumber.replace('{week}', day.date.week()) }}\n
\n\n
\n";
/***/
},
/* 18 */
/***/
function(module, exports) {
module.exports = "\n";
/***/
},
/* 19 */
/***/
function(module, exports) {
module.exports = "\n\n\n
\n
\n\n
0\"\n events=\"vm.view[vm.openDayIndex].events\"\n on-event-click=\"vm.onEventClick\"\n edit-event-html=\"vm.editEventHtml\"\n on-edit-event-click=\"vm.onEditEventClick\"\n delete-event-html=\"vm.deleteEventHtml\"\n on-delete-event-click=\"vm.onDeleteEventClick\">\n \n\n
\n\n
\n";
/***/
},
/* 20 */
/***/
function(module, exports) {
module.exports = "\n";
/***/
},
/* 21 */
/***/
function(module, exports) {
module.exports = "\n
\n\n
\n\n \n
\n \n \n \n \n\n
\n\n
\n\n
\n
\n";
/***/
},
/* 22 */
/***/
function(module, exports) {
module.exports = "\n
\n
\n
0, 'cal-day-today': month.isToday}\"\n mwl-droppable\n on-drop=\"vm.handleEventDrop(dropData.event, month.date)\">\n\n
\n \n\n
0\"\n ng-bind=\"month.badgeTotal\">\n \n\n
0\">\n \n \n
\n\n
\n
\n\n
0\"\n events=\"vm.view[vm.openMonthIndex].events\"\n on-event-click=\"vm.onEventClick\"\n edit-event-html=\"vm.editEventHtml\"\n on-edit-event-click=\"vm.onEditEventClick\"\n delete-event-html=\"vm.deleteEventHtml\"\n on-delete-event-click=\"vm.onDeleteEventClick\">\n \n\n
\n\n
\n";
/***/
},
/* 23 */
/***/
function(module, exports, __webpack_require__) {
var map = {
"./mwlCalendar.js": 24,
"./mwlCalendarDay.js": 25,
"./mwlCalendarHourList.js": 26,
"./mwlCalendarMonth.js": 27,
"./mwlCalendarSlideBox.js": 28,
"./mwlCalendarWeek.js": 29,
"./mwlCalendarYear.js": 30,
"./mwlCollapseFallback.js": 31,
"./mwlDateModifier.js": 32,
"./mwlDraggable.js": 33,
"./mwlDroppable.js": 34,
"./mwlElementDimensions.js": 35,
"./mwlResizable.js": 36
};
function webpackContext(req) {
return __webpack_require__(webpackContextResolve(req));
};
function webpackContextResolve(req) {
return map[req] || (function() { throw new Error("Cannot find module '" + req + "'.") }());
};
webpackContext.keys = function webpackContextKeys() {
return Object.keys(map);
};
webpackContext.resolve = webpackContextResolve;
module.exports = webpackContext;
webpackContext.id = 23;
/***/
},
/* 24 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlCalendarCtrl', ["$scope", "$log", "$timeout", "$attrs", "$locale", "moment", "calendarTitle", function($scope, $log, $timeout, $attrs, $locale, moment, calendarTitle) {
var vm = this;
vm.events = vm.events || [];
vm.changeView = function(view, newDay) {
vm.view = view;
vm.viewDate = newDay;
};
vm.dateClicked = function(date) {
var rawDate = moment(date).toDate();
var nextView = {
year: 'month',
month: 'day',
week: 'day'
};
if (vm.onViewChangeClick({ calendarDate: rawDate, calendarNextView: nextView[vm.view] }) !== false) {
vm.changeView(nextView[vm.view], rawDate);
}
};
var previousDate = moment(vm.viewDate);
var previousView = vm.view;
function eventIsValid(event) {
if (!event.startsAt) {
$log.warn('Bootstrap calendar: ', 'Event is missing the startsAt field', event);
}
if (!angular.isDate(event.startsAt)) {
$log.warn('Bootstrap calendar: ', 'Event startsAt should be a javascript date object', event);
}
if (angular.isDefined(event.endsAt)) {
if (!angular.isDate(event.endsAt)) {
$log.warn('Bootstrap calendar: ', 'Event endsAt should be a javascript date object', event);
}
if (moment(event.startsAt).isAfter(moment(event.endsAt))) {
$log.warn('Bootstrap calendar: ', 'Event cannot start after it finishes', event);
}
}
return true;
}
function refreshCalendar() {
if (calendarTitle[vm.view] && angular.isDefined($attrs.viewTitle)) {
vm.viewTitle = calendarTitle[vm.view](vm.viewDate);
}
vm.events = vm.events.filter(eventIsValid).map(function(event, index) {
Object.defineProperty(event, '$id', { enumerable: false, configurable: true, value: index });
return event;
});
//if on-timespan-click="calendarDay = calendarDate" is set then don't update the view as nothing needs to change
var currentDate = moment(vm.viewDate);
var shouldUpdate = true;
if (
previousDate.clone().startOf(vm.view).isSame(currentDate.clone().startOf(vm.view)) &&
!previousDate.isSame(currentDate) &&
vm.view === previousView
) {
shouldUpdate = false;
}
previousDate = currentDate;
previousView = vm.view;
if (shouldUpdate) {
// a $timeout is required as $broadcast is synchronous so if a new events array is set the calendar won't update
$timeout(function() {
$scope.$broadcast('calendar.refreshView');
});
}
}
var eventsWatched = false;
//Refresh the calendar when any of these variables change.
$scope.$watchGroup([
'vm.viewDate',
'vm.view',
'vm.cellIsOpen',
function() {
return moment.locale() + $locale.id; //Auto update the calendar when the locale changes
}
], function() {
if (!eventsWatched) {
eventsWatched = true;
//need to deep watch events hence why it isn't included in the watch group
$scope.$watch('vm.events', refreshCalendar, true); //this will call refreshCalendar when the watcher starts (i.e. now)
} else {
refreshCalendar();
}
});
}])
.directive('mwlCalendar', ["calendarConfig", function(calendarConfig) {
return {
templateUrl: calendarConfig.templates.calendar,
restrict: 'E',
scope: {
events: '=',
view: '=',
viewTitle: '=?',
viewDate: '=',
editEventHtml: '=',
deleteEventHtml: '=',
cellIsOpen: '=',
onEventClick: '&',
onEventTimesChanged: '&',
onEditEventClick: '&',
onDeleteEventClick: '&',
onTimespanClick: '&',
onViewChangeClick: '&',
cellModifier: '&',
dayViewStart: '@',
dayViewEnd: '@',
dayViewSplit: '@'
},
controller: 'MwlCalendarCtrl as vm',
bindToController: true
};
}]);
/***/
},
/* 25 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlCalendarDayCtrl', ["$scope", "$sce", "moment", "calendarHelper", "calendarConfig", function($scope, $sce, moment, calendarHelper, calendarConfig) {
var vm = this;
vm.calendarConfig = calendarConfig;
vm.$sce = $sce;
$scope.$on('calendar.refreshView', function() {
vm.dayViewSplit = vm.dayViewSplit || 30;
vm.dayViewHeight = calendarHelper.getDayViewHeight(
vm.dayViewStart,
vm.dayViewEnd,
vm.dayViewSplit
);
vm.view = calendarHelper.getDayView(
vm.events,
vm.viewDate,
vm.dayViewStart,
vm.dayViewEnd,
vm.dayViewSplit
);
});
vm.eventDragComplete = function(event, minuteChunksMoved) {
var minutesDiff = minuteChunksMoved * vm.dayViewSplit;
var newStart = moment(event.startsAt).add(minutesDiff, 'minutes');
var newEnd = moment(event.endsAt).add(minutesDiff, 'minutes');
delete event.tempStartsAt;
vm.onEventTimesChanged({
calendarEvent: event,
calendarNewEventStart: newStart.toDate(),
calendarNewEventEnd: event.endsAt ? newEnd.toDate() : null
});
};
vm.eventDragged = function(event, minuteChunksMoved) {
var minutesDiff = minuteChunksMoved * vm.dayViewSplit;
event.tempStartsAt = moment(event.startsAt).add(minutesDiff, 'minutes').toDate();
};
vm.eventResizeComplete = function(event, edge, minuteChunksMoved) {
var minutesDiff = minuteChunksMoved * vm.dayViewSplit;
var start = moment(event.startsAt);
var end = moment(event.endsAt);
if (edge === 'start') {
start.add(minutesDiff, 'minutes');
} else {
end.add(minutesDiff, 'minutes');
}
delete event.tempStartsAt;
vm.onEventTimesChanged({
calendarEvent: event,
calendarNewEventStart: start.toDate(),
calendarNewEventEnd: end.toDate()
});
};
vm.eventResized = function(event, edge, minuteChunksMoved) {
var minutesDiff = minuteChunksMoved * vm.dayViewSplit;
if (edge === 'start') {
event.tempStartsAt = moment(event.startsAt).add(minutesDiff, 'minutes').toDate();
}
};
}])
.directive('mwlCalendarDay', ["calendarConfig", function(calendarConfig) {
return {
templateUrl: calendarConfig.templates.calendarDayView,
restrict: 'E',
require: '^mwlCalendar',
scope: {
events: '=',
viewDate: '=',
onEventClick: '=',
onEventTimesChanged: '=',
onTimespanClick: '=',
dayViewStart: '=',
dayViewEnd: '=',
dayViewSplit: '='
},
controller: 'MwlCalendarDayCtrl as vm',
bindToController: true
};
}]);
/***/
},
/* 26 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlCalendarHourListCtrl', ["$scope", "moment", "calendarConfig", "calendarHelper", function($scope, moment, calendarConfig, calendarHelper) {
var vm = this;
var dayViewStart, dayViewEnd;
function updateDays() {
dayViewStart = moment(vm.dayViewStart || '00:00', 'HH:mm');
dayViewEnd = moment(vm.dayViewEnd || '23:00', 'HH:mm');
vm.dayViewSplit = parseInt(vm.dayViewSplit);
vm.hours = [];
var dayCounter = moment(vm.viewDate)
.clone()
.hours(dayViewStart.hours())
.minutes(dayViewStart.minutes())
.seconds(dayViewStart.seconds());
for (var i = 0; i <= dayViewEnd.diff(dayViewStart, 'hours'); i++) {
vm.hours.push({
label: calendarHelper.formatDate(dayCounter, calendarConfig.dateFormats.hour),
date: dayCounter.clone()
});
dayCounter.add(1, 'hour');
}
}
var originalLocale = moment.locale();
$scope.$on('calendar.refreshView', function() {
if (originalLocale !== moment.locale()) {
originalLocale = moment.locale();
updateDays();
}
});
$scope.$watchGroup([
'vm.dayViewStart',
'vm.dayViewEnd',
'vm.dayViewSplit',
'vm.viewDate'
], function() {
updateDays();
});
}])
.directive('mwlCalendarHourList', ["calendarConfig", function(calendarConfig) {
return {
restrict: 'E',
templateUrl: calendarConfig.templates.calendarHourList,
controller: 'MwlCalendarHourListCtrl as vm',
scope: {
viewDate: '=',
dayViewStart: '=',
dayViewEnd: '=',
dayViewSplit: '=',
onTimespanClick: '='
},
bindToController: true
};
}]);
/***/
},
/* 27 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlCalendarMonthCtrl', ["$scope", "moment", "calendarHelper", "calendarConfig", function($scope, moment, calendarHelper, calendarConfig) {
var vm = this;
vm.calendarConfig = calendarConfig;
vm.openRowIndex = null;
$scope.$on('calendar.refreshView', function() {
vm.weekDays = calendarHelper.getWeekDayNames();
vm.view = calendarHelper.getMonthView(vm.events, vm.viewDate, vm.cellModifier);
var rows = Math.floor(vm.view.length / 7);
vm.monthOffsets = [];
for (var i = 0; i < rows; i++) {
vm.monthOffsets.push(i * 7);
}
//Auto open the calendar to the current day if set
if (vm.cellIsOpen && vm.openRowIndex === null) {
vm.openDayIndex = null;
vm.view.forEach(function(day) {
if (day.inMonth && moment(vm.viewDate).startOf('day').isSame(day.date)) {
vm.dayClicked(day, true);
}
});
}
});
vm.dayClicked = function(day, dayClickedFirstRun, $event) {
if (!dayClickedFirstRun) {
vm.onTimespanClick({
calendarDate: day.date.toDate(),
$event: $event
});
if ($event && $event.defaultPrevented) {
return;
}
}
vm.openRowIndex = null;
var dayIndex = vm.view.indexOf(day);
if (dayIndex === vm.openDayIndex) { //the day has been clicked and is already open
vm.openDayIndex = null; //close the open day
vm.cellIsOpen = false;
} else {
vm.openDayIndex = dayIndex;
vm.openRowIndex = Math.floor(dayIndex / 7);
vm.cellIsOpen = true;
}
};
vm.highlightEvent = function(event, shouldAddClass) {
vm.view.forEach(function(day) {
delete day.highlightClass;
if (shouldAddClass) {
var dayContainsEvent = day.events.indexOf(event) > -1;
if (dayContainsEvent) {
day.highlightClass = 'day-highlight dh-event-' + event.type;
}
}
});
};
vm.handleEventDrop = function(event, newDayDate, draggedFromDate) {
var newStart = moment(event.startsAt)
.date(moment(newDayDate).date())
.month(moment(newDayDate).month());
var newEnd = calendarHelper.adjustEndDateFromStartDiff(event.startsAt, newStart, event.endsAt);
vm.onEventTimesChanged({
calendarEvent: event,
calendarDate: newDayDate,
calendarNewEventStart: newStart.toDate(),
calendarNewEventEnd: newEnd ? newEnd.toDate() : null,
calendarDraggedFromDate: draggedFromDate
});
};
}])
.directive('mwlCalendarMonth', ["calendarConfig", function(calendarConfig) {
return {
templateUrl: calendarConfig.templates.calendarMonthView,
restrict: 'E',
require: '^mwlCalendar',
scope: {
events: '=',
viewDate: '=',
onEventClick: '=',
onEditEventClick: '=',
onDeleteEventClick: '=',
onEventTimesChanged: '=',
editEventHtml: '=',
deleteEventHtml: '=',
cellIsOpen: '=',
onTimespanClick: '=',
cellModifier: '='
},
controller: 'MwlCalendarMonthCtrl as vm',
link: function(scope, element, attrs, calendarCtrl) {
scope.vm.calendarCtrl = calendarCtrl;
},
bindToController: true
};
}]);
/***/
},
/* 28 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlCalendarSlideBoxCtrl', ["$sce", "$scope", "$timeout", "calendarConfig", function($sce, $scope, $timeout, calendarConfig) {
var vm = this;
vm.$sce = $sce;
vm.calendarConfig = calendarConfig;
vm.isCollapsed = true;
$scope.$watch('vm.isOpen', function(isOpen) {
//events must be populated first to set the element height before animation will work
$timeout(function() {
vm.isCollapsed = !isOpen;
});
});
}])
.directive('mwlCalendarSlideBox', ["calendarConfig", function(calendarConfig) {
return {
restrict: 'E',
templateUrl: calendarConfig.templates.calendarSlideBox,
replace: true,
controller: 'MwlCalendarSlideBoxCtrl as vm',
require: ['^?mwlCalendarMonth', '^?mwlCalendarYear'],
link: function(scope, elm, attrs, ctrls) {
scope.isMonthView = !!ctrls[0];
scope.isYearView = !!ctrls[1];
},
scope: {
isOpen: '=',
events: '=',
onEventClick: '=',
editEventHtml: '=',
onEditEventClick: '=',
deleteEventHtml: '=',
onDeleteEventClick: '='
},
bindToController: true
};
}]);
/***/
},
/* 29 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlCalendarWeekCtrl', ["$scope", "$sce", "moment", "calendarHelper", "calendarConfig", function($scope, $sce, moment, calendarHelper, calendarConfig) {
var vm = this;
vm.showTimes = calendarConfig.showTimesOnWeekView;
vm.$sce = $sce;
$scope.$on('calendar.refreshView', function() {
vm.dayViewSplit = vm.dayViewSplit || 30;
vm.dayViewHeight = calendarHelper.getDayViewHeight(
vm.dayViewStart,
vm.dayViewEnd,
vm.dayViewSplit
);
if (vm.showTimes) {
vm.view = calendarHelper.getWeekViewWithTimes(
vm.events,
vm.viewDate,
vm.dayViewStart,
vm.dayViewEnd,
vm.dayViewSplit
);
} else {
vm.view = calendarHelper.getWeekView(vm.events, vm.viewDate);
}
});
vm.weekDragged = function(event, daysDiff, minuteChunksMoved) {
var newStart = moment(event.startsAt).add(daysDiff, 'days');
var newEnd = moment(event.endsAt).add(daysDiff, 'days');
if (minuteChunksMoved) {
var minutesDiff = minuteChunksMoved * vm.dayViewSplit;
newStart = newStart.add(minutesDiff, 'minutes');
newEnd = newEnd.add(minutesDiff, 'minutes');
}
delete event.tempStartsAt;
vm.onEventTimesChanged({
calendarEvent: event,
calendarNewEventStart: newStart.toDate(),
calendarNewEventEnd: event.endsAt ? newEnd.toDate() : null
});
};
vm.weekResized = function(event, edge, daysDiff) {
var start = moment(event.startsAt);
var end = moment(event.endsAt);
if (edge === 'start') {
start.add(daysDiff, 'days');
} else {
end.add(daysDiff, 'days');
}
vm.onEventTimesChanged({
calendarEvent: event,
calendarNewEventStart: start.toDate(),
calendarNewEventEnd: end.toDate()
});
};
vm.tempTimeChanged = function(event, minuteChunksMoved) {
var minutesDiff = minuteChunksMoved * vm.dayViewSplit;
event.tempStartsAt = moment(event.startsAt).add(minutesDiff, 'minutes').toDate();
};
}])
.directive('mwlCalendarWeek', ["calendarConfig", function(calendarConfig) {
return {
templateUrl: calendarConfig.templates.calendarWeekView,
restrict: 'E',
require: '^mwlCalendar',
scope: {
events: '=',
viewDate: '=',
onEventClick: '=',
onEventTimesChanged: '=',
dayViewStart: '=',
dayViewEnd: '=',
dayViewSplit: '=',
onTimespanClick: '='
},
controller: 'MwlCalendarWeekCtrl as vm',
link: function(scope, element, attrs, calendarCtrl) {
scope.vm.calendarCtrl = calendarCtrl;
},
bindToController: true
};
}]);
/***/
},
/* 30 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlCalendarYearCtrl', ["$scope", "moment", "calendarHelper", function($scope, moment, calendarHelper) {
var vm = this;
vm.openMonthIndex = null;
$scope.$on('calendar.refreshView', function() {
vm.view = calendarHelper.getYearView(vm.events, vm.viewDate, vm.cellModifier);
//Auto open the calendar to the current day if set
if (vm.cellIsOpen && vm.openMonthIndex === null) {
vm.openMonthIndex = null;
vm.view.forEach(function(month) {
if (moment(vm.viewDate).startOf('month').isSame(month.date)) {
vm.monthClicked(month, true);
}
});
}
});
vm.monthClicked = function(month, monthClickedFirstRun, $event) {
if (!monthClickedFirstRun) {
vm.onTimespanClick({
calendarDate: month.date.toDate(),
$event: $event
});
if ($event && $event.defaultPrevented) {
return;
}
}
vm.openRowIndex = null;
var monthIndex = vm.view.indexOf(month);
if (monthIndex === vm.openMonthIndex) { //the month has been clicked and is already open
vm.openMonthIndex = null; //close the open month
vm.cellIsOpen = false;
} else {
vm.openMonthIndex = monthIndex;
vm.openRowIndex = Math.floor(monthIndex / 4);
vm.cellIsOpen = true;
}
};
vm.handleEventDrop = function(event, newMonthDate) {
var newStart = moment(event.startsAt).month(moment(newMonthDate).month());
var newEnd = calendarHelper.adjustEndDateFromStartDiff(event.startsAt, newStart, event.endsAt);
vm.onEventTimesChanged({
calendarEvent: event,
calendarDate: newMonthDate,
calendarNewEventStart: newStart.toDate(),
calendarNewEventEnd: newEnd ? newEnd.toDate() : null
});
};
}])
.directive('mwlCalendarYear', ["calendarConfig", function(calendarConfig) {
return {
templateUrl: calendarConfig.templates.calendarYearView,
restrict: 'E',
require: '^mwlCalendar',
scope: {
events: '=',
viewDate: '=',
onEventClick: '=',
onEventTimesChanged: '=',
onEditEventClick: '=',
onDeleteEventClick: '=',
editEventHtml: '=',
deleteEventHtml: '=',
cellIsOpen: '=',
onTimespanClick: '=',
cellModifier: '='
},
controller: 'MwlCalendarYearCtrl as vm',
link: function(scope, element, attrs, calendarCtrl) {
scope.vm.calendarCtrl = calendarCtrl;
},
bindToController: true
};
}]);
/***/
},
/* 31 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlCollapseFallbackCtrl', ["$scope", "$attrs", "$element", function($scope, $attrs, $element) {
$scope.$watch($attrs.mwlCollapseFallback, function(shouldCollapse) {
if (shouldCollapse) {
$element.addClass('ng-hide');
} else {
$element.removeClass('ng-hide');
}
});
}])
.directive('mwlCollapseFallback', ["$injector", function($injector) {
if ($injector.has('uibCollapseDirective')) {
return {};
}
return {
restrict: 'A',
controller: 'MwlCollapseFallbackCtrl'
};
}]);
/***/
},
/* 32 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlDateModifierCtrl', ["$element", "$attrs", "$scope", "moment", function($element, $attrs, $scope, moment) {
var vm = this;
function onClick() {
if (angular.isDefined($attrs.setToToday)) {
vm.date = new Date();
} else if (angular.isDefined($attrs.increment)) {
vm.date = moment(vm.date).add(1, vm.increment).toDate();
} else if (angular.isDefined($attrs.decrement)) {
vm.date = moment(vm.date).subtract(1, vm.decrement).toDate();
}
$scope.$apply();
}
$element.bind('click', onClick);
$scope.$on('$destroy', function() {
$element.unbind('click', onClick);
});
}])
.directive('mwlDateModifier', function() {
return {
restrict: 'A',
controller: 'MwlDateModifierCtrl as vm',
scope: {
date: '=',
increment: '=',
decrement: '='
},
bindToController: true
};
});
/***/
},
/* 33 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlDraggableCtrl', ["$element", "$scope", "$window", "$parse", "$attrs", "$timeout", "interact", function($element, $scope, $window, $parse, $attrs, $timeout, interact) {
if (!interact) {
return;
}
var snap, snapGridDimensions;
if ($attrs.snapGrid) {
snapGridDimensions = $parse($attrs.snapGrid)($scope);
snap = {
targets: [
interact.createSnapGrid(snapGridDimensions)
]
};
}
function translateElement(elm, transformValue) {
return elm
.css('-ms-transform', transformValue)
.css('-webkit-transform', transformValue)
.css('transform', transformValue);
}
function canDrag() {
return $parse($attrs.mwlDraggable)($scope);
}
function getUnitsMoved(x, y, gridDimensions) {
var result = { x: x, y: y };
if (gridDimensions && gridDimensions.x) {
result.x /= gridDimensions.x;
}
if (gridDimensions && gridDimensions.y) {
result.y /= gridDimensions.y;
}
return result;
}
interact($element[0]).draggable({
snap: snap,
onstart: function(event) {
if (canDrag()) {
angular.element(event.target).addClass('dragging-active');
event.target.dropData = $parse($attrs.dropData)($scope);
event.target.style.pointerEvents = 'none';
if ($attrs.onDragStart) {
$parse($attrs.onDragStart)($scope);
$scope.$apply();
}
}
},
onmove: function(event) {
if (canDrag()) {
var elm = angular.element(event.target);
var x = (parseFloat(elm.attr('data-x')) || 0) + (event.dx || 0);
var y = (parseFloat(elm.attr('data-y')) || 0) + (event.dy || 0);
switch ($parse($attrs.axis)($scope)) {
case 'x':
y = 0;
break;
case 'y':
x = 0;
break;
default:
}
if ($window.getComputedStyle(elm[0]).position === 'static') {
elm.css('position', 'relative');
}
translateElement(elm, 'translate(' + x + 'px, ' + y + 'px)')
.css('z-index', 1000)
.attr('data-x', x)
.attr('data-y', y);
if ($attrs.onDrag) {
$parse($attrs.onDrag)($scope, getUnitsMoved(x, y, snapGridDimensions));
$scope.$apply();
}
}
},
onend: function(event) {
if (canDrag()) {
var elm = angular.element(event.target);
var x = elm.attr('data-x');
var y = elm.attr('data-y');
event.target.style.pointerEvents = 'auto';
if ($attrs.onDragEnd) {
$parse($attrs.onDragEnd)($scope, getUnitsMoved(x, y, snapGridDimensions));
$scope.$apply();
}
$timeout(function() {
translateElement(elm, '')
.css('z-index', 'auto')
.removeAttr('data-x')
.removeAttr('data-y')
.removeClass('dragging-active');
});
}
}
});
$scope.$on('$destroy', function() {
interact($element[0]).unset();
});
}])
.directive('mwlDraggable', function() {
return {
restrict: 'A',
controller: 'MwlDraggableCtrl'
};
});
/***/
},
/* 34 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlDroppableCtrl', ["$element", "$scope", "$parse", "$attrs", "interact", function($element, $scope, $parse, $attrs, interact) {
if (!interact) {
return;
}
interact($element[0]).dropzone({
ondragenter: function(event) {
angular.element(event.target).addClass('drop-active');
},
ondragleave: function(event) {
angular.element(event.target).removeClass('drop-active');
},
ondropdeactivate: function(event) {
angular.element(event.target).removeClass('drop-active');
},
ondrop: function(event) {
if (event.relatedTarget.dropData) {
$parse($attrs.onDrop)($scope, { dropData: event.relatedTarget.dropData });
$scope.$apply();
}
}
});
$scope.$on('$destroy', function() {
interact($element[0]).unset();
});
}])
.directive('mwlDroppable', function() {
return {
restrict: 'A',
controller: 'MwlDroppableCtrl'
};
});
/***/
},
/* 35 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlElementDimensionsCtrl', ["$element", "$scope", "$parse", "$attrs", function($element, $scope, $parse, $attrs) {
$parse($attrs.mwlElementDimensions).assign($scope, {
width: $element[0].offsetWidth,
height: $element[0].offsetHeight
});
}])
.directive('mwlElementDimensions', function() {
return {
restrict: 'A',
controller: 'MwlElementDimensionsCtrl'
};
});
/***/
},
/* 36 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.controller('MwlResizableCtrl', ["$element", "$scope", "$parse", "$attrs", "$timeout", "interact", function($element, $scope, $parse, $attrs, $timeout, interact) {
if (!interact) {
return;
}
var snap, snapGridDimensions;
if ($attrs.snapGrid) {
snapGridDimensions = $parse($attrs.snapGrid)($scope);
snap = {
targets: [
interact.createSnapGrid(snapGridDimensions)
]
};
}
var originalDimensions = {};
var originalDimensionsStyle = {};
var resizeEdge;
function canResize() {
return $parse($attrs.mwlResizable)($scope);
}
function getUnitsResized(edge, elm, gridDimensions) {
var unitsResized = {};
unitsResized.edge = edge;
if (edge === 'start') {
unitsResized.x = elm.data('x');
unitsResized.y = elm.data('y');
} else if (edge === 'end') {
unitsResized.x = parseFloat(elm.css('width').replace('px', '')) - originalDimensions.width;
unitsResized.y = parseFloat(elm.css('height').replace('px', '')) - originalDimensions.height;
}
if (gridDimensions && gridDimensions.x) {
unitsResized.x = Math.round(unitsResized.x / gridDimensions.x);
}
if (gridDimensions && gridDimensions.y) {
unitsResized.y = Math.round(unitsResized.y / gridDimensions.y);
}
return unitsResized;
}
interact($element[0]).resizable({
edges: $parse($attrs.resizeEdges)($scope),
snap: snap,
onstart: function(event) {
if (canResize()) {
resizeEdge = 'end';
var elm = angular.element(event.target);
originalDimensions.height = elm[0].offsetHeight;
originalDimensions.width = elm[0].offsetWidth;
originalDimensionsStyle.height = elm.css('height');
originalDimensionsStyle.width = elm.css('width');
}
},
onmove: function(event) {
if (canResize()) {
var elm = angular.element(event.target);
var x = parseFloat(elm.data('x') || 0);
var y = parseFloat(elm.data('y') || 0);
elm.css({
width: event.rect.width + 'px',
height: event.rect.height + 'px'
});
// translate when resizing from top or left edges
x += event.deltaRect.left;
y += event.deltaRect.top;
elm.css('transform', 'translate(' + x + 'px,' + y + 'px)');
elm.data('x', x);
elm.data('y', y);
if (event.deltaRect.left !== 0 || event.deltaRect.top !== 0) {
resizeEdge = 'start';
}
if ($attrs.onResize) {
$parse($attrs.onResize)($scope, getUnitsResized(resizeEdge, elm, snapGridDimensions));
$scope.$apply();
}
}
},
onend: function(event) {
if (canResize()) {
var elm = angular.element(event.target);
var unitsResized = getUnitsResized(resizeEdge, elm, snapGridDimensions);
$timeout(function() {
elm
.data('x', null)
.data('y', null)
.css({
transform: '',
width: originalDimensionsStyle.width,
height: originalDimensionsStyle.height
});
});
if ($attrs.onResizeEnd) {
$parse($attrs.onResizeEnd)($scope, unitsResized);
$scope.$apply();
}
}
}
});
$scope.$on('$destroy', function() {
interact($element[0]).unset();
});
}])
.directive('mwlResizable', function() {
return {
restrict: 'A',
controller: 'MwlResizableCtrl'
};
});
/***/
},
/* 37 */
/***/
function(module, exports, __webpack_require__) {
var map = {
"./calendarDate.js": 38,
"./calendarLimitTo.js": 39,
"./calendarTruncateEventTitle.js": 40,
"./calendarTrustAsHtml.js": 41
};
function webpackContext(req) {
return __webpack_require__(webpackContextResolve(req));
};
function webpackContextResolve(req) {
return map[req] || (function() { throw new Error("Cannot find module '" + req + "'.") }());
};
webpackContext.keys = function webpackContextKeys() {
return Object.keys(map);
};
webpackContext.resolve = webpackContextResolve;
module.exports = webpackContext;
webpackContext.id = 37;
/***/
},
/* 38 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.filter('calendarDate', ["calendarHelper", "calendarConfig", function(calendarHelper, calendarConfig) {
function calendarDate(date, format, getFromConfig) {
if (getFromConfig === true) {
format = calendarConfig.dateFormats[format];
}
return calendarHelper.formatDate(date, format);
}
// This is stateful because the locale can change as well
// as calendarConfig.dateFormats which would change the value outside of this filter
calendarDate.$stateful = true;
return calendarDate;
}]);
/***/
},
/* 39 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.filter('calendarLimitTo', ["limitToFilter", function(limitToFilter) {
if (angular.version.minor >= 4) { //1.4+ supports the begin attribute
return limitToFilter;
}
//Copied from the angular source. Only 1.4 has the begin functionality.
return function(input, limit, begin) {
if (Math.abs(Number(limit)) === Infinity) {
limit = Number(limit);
} else {
limit = parseInt(limit);
}
if (isNaN(limit)) {
return input;
}
if (angular.isNumber(input)) {
input = input.toString();
}
if (!angular.isArray(input) && !angular.isString(input)) {
return input;
}
begin = (!begin || isNaN(begin)) ? 0 : parseInt(begin);
begin = (begin < 0 && begin >= -input.length) ? input.length + begin : begin;
if (limit >= 0) {
return input.slice(begin, begin + limit);
} else if (begin === 0) {
return input.slice(limit, input.length);
} else {
return input.slice(Math.max(0, begin + limit), begin);
}
};
}]);
/***/
},
/* 40 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.filter('calendarTruncateEventTitle', function() {
return function(string, length, boxHeight) {
if (!string) {
return '';
}
//Only truncate if if actually needs truncating
if (string.length >= length && string.length / 20 > boxHeight / 30) {
return string.substr(0, length) + '...';
} else {
return string;
}
};
});
/***/
},
/* 41 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.filter('calendarTrustAsHtml', ["$sce", function($sce) {
return function(text) {
return $sce.trustAsHtml(text);
};
}]);
/***/
},
/* 42 */
/***/
function(module, exports, __webpack_require__) {
var map = {
"./calendarConfig.js": 43,
"./calendarHelper.js": 44,
"./calendarTitle.js": 45,
"./interact.js": 46,
"./moment.js": 48
};
function webpackContext(req) {
return __webpack_require__(webpackContextResolve(req));
};
function webpackContextResolve(req) {
return map[req] || (function() { throw new Error("Cannot find module '" + req + "'.") }());
};
webpackContext.keys = function webpackContextKeys() {
return Object.keys(map);
};
webpackContext.resolve = webpackContextResolve;
module.exports = webpackContext;
webpackContext.id = 42;
/***/
},
/* 43 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.constant('calendarConfig', {
allDateFormats: {
angular: {
date: {
hour: 'ha',
day: 'd MMM',
month: 'MMMM',
weekDay: 'EEEE',
time: 'HH:mm',
datetime: 'MMM d, h:mm a'
},
title: {
day: 'EEEE d MMMM, yyyy',
week: 'Week {week} of {year}',
month: 'MMMM yyyy',
year: 'yyyy'
}
},
moment: {
date: {
hour: 'ha',
day: 'D MMM',
month: 'MMMM',
weekDay: 'dddd',
time: 'HH:mm',
datetime: 'MMM D, h:mm a'
},
title: {
day: 'dddd D MMMM, YYYY',
week: 'Week {week} of {year}',
month: 'MMMM YYYY',
year: 'YYYY'
}
}
},
get dateFormats() {
return this.allDateFormats[this.dateFormatter].date;
},
get titleFormats() {
return this.allDateFormats[this.dateFormatter].title;
},
dateFormatter: 'angular',
displayEventEndTimes: false,
showTimesOnWeekView: false,
displayAllMonthEvents: false,
i18nStrings: {
eventsLabel: 'Events',
timeLabel: 'Time',
weekNumber: 'Week {week}'
},
templates: {}
});
/***/
},
/* 44 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.factory('calendarHelper', ["dateFilter", "moment", "calendarConfig", function(dateFilter, moment, calendarConfig) {
function formatDate(date, format) {
if (calendarConfig.dateFormatter === 'angular') {
return dateFilter(moment(date).toDate(), format);
} else if (calendarConfig.dateFormatter === 'moment') {
return moment(date).format(format);
}
}
function adjustEndDateFromStartDiff(oldStart, newStart, oldEnd) {
if (!oldEnd) {
return oldEnd;
}
var diffInSeconds = moment(newStart).diff(moment(oldStart));
return moment(oldEnd).add(diffInSeconds);
}
function eventIsInPeriod(event, periodStart, periodEnd) {
var eventStart = moment(event.startsAt);
var eventEnd = moment(event.endsAt || event.startsAt);
periodStart = moment(periodStart);
periodEnd = moment(periodEnd);
if (angular.isDefined(event.recursOn)) {
switch (event.recursOn) {
case 'year':
eventStart.set({
year: periodStart.year()
});
break;
case 'month':
eventStart.set({
year: periodStart.year(),
month: periodStart.month()
});
break;
default:
throw new Error('Invalid value (' + event.recursOn + ') given for recurs on. Can only be year or month.');
}
eventEnd = adjustEndDateFromStartDiff(event.startsAt, eventStart, eventEnd);
}
return (eventStart.isAfter(periodStart) && eventStart.isBefore(periodEnd)) ||
(eventEnd.isAfter(periodStart) && eventEnd.isBefore(periodEnd)) ||
(eventStart.isBefore(periodStart) && eventEnd.isAfter(periodEnd)) ||
eventStart.isSame(periodStart) ||
eventEnd.isSame(periodEnd);
}
function filterEventsInPeriod(events, startPeriod, endPeriod) {
return events.filter(function(event) {
return eventIsInPeriod(event, startPeriod, endPeriod);
});
}
function getEventsInPeriod(calendarDate, period, allEvents) {
var startPeriod = moment(calendarDate).startOf(period);
var endPeriod = moment(calendarDate).endOf(period);
return filterEventsInPeriod(allEvents, startPeriod, endPeriod);
}
function getBadgeTotal(events) {
return events.filter(function(event) {
return event.incrementsBadgeTotal !== false;
}).length;
}
function getWeekDayNames() {
var weekdays = [];
var count = 0;
while (count < 7) {
weekdays.push(formatDate(moment().weekday(count++), calendarConfig.dateFormats.weekDay));
}
return weekdays;
}
function getYearView(events, viewDate, cellModifier) {
var view = [];
var eventsInPeriod = getEventsInPeriod(viewDate, 'year', events);
var month = moment(viewDate).startOf('year');
var count = 0;
while (count < 12) {
var startPeriod = month.clone();
var endPeriod = startPeriod.clone().endOf('month');
var periodEvents = filterEventsInPeriod(eventsInPeriod, startPeriod, endPeriod);
var cell = {
label: formatDate(startPeriod, calendarConfig.dateFormats.month),
isToday: startPeriod.isSame(moment().startOf('month')),
events: periodEvents,
date: startPeriod,
badgeTotal: getBadgeTotal(periodEvents)
};
cellModifier({ calendarCell: cell });
view.push(cell);
month.add(1, 'month');
count++;
}
return view;
}
function getMonthView(events, viewDate, cellModifier) {
var startOfMonth = moment(viewDate).startOf('month');
var day = startOfMonth.clone().startOf('week');
var endOfMonthView = moment(viewDate).endOf('month').endOf('week');
var eventsInPeriod;
if (calendarConfig.displayAllMonthEvents) {
eventsInPeriod = filterEventsInPeriod(events, day, endOfMonthView);
} else {
eventsInPeriod = filterEventsInPeriod(events, startOfMonth, startOfMonth.clone().endOf('month'));
}
var view = [];
var today = moment().startOf('day');
while (day.isBefore(endOfMonthView)) {
var inMonth = day.month() === moment(viewDate).month();
var monthEvents = [];
if (inMonth || calendarConfig.displayAllMonthEvents) {
monthEvents = filterEventsInPeriod(eventsInPeriod, day, day.clone().endOf('day'));
}
var cell = {
label: day.date(),
date: day.clone(),
inMonth: inMonth,
isPast: today.isAfter(day),
isToday: today.isSame(day),
isFuture: today.isBefore(day),
isWeekend: [0, 6].indexOf(day.day()) > -1,
events: monthEvents,
badgeTotal: getBadgeTotal(monthEvents)
};
cellModifier({ calendarCell: cell });
view.push(cell);
day.add(1, 'day');
}
return view;
}
function getWeekView(events, viewDate) {
var startOfWeek = moment(viewDate).startOf('week');
var endOfWeek = moment(viewDate).endOf('week');
var dayCounter = startOfWeek.clone();
var days = [];
var today = moment().startOf('day');
while (days.length < 7) {
days.push({
weekDayLabel: formatDate(dayCounter, calendarConfig.dateFormats.weekDay),
date: dayCounter.clone(),
dayLabel: formatDate(dayCounter, calendarConfig.dateFormats.day),
isPast: dayCounter.isBefore(today),
isToday: dayCounter.isSame(today),
isFuture: dayCounter.isAfter(today),
isWeekend: [0, 6].indexOf(dayCounter.day()) > -1
});
dayCounter.add(1, 'day');
}
var eventsSorted = filterEventsInPeriod(events, startOfWeek, endOfWeek).map(function(event) {
var eventStart = moment(event.startsAt).startOf('day');
var eventEnd = moment(event.endsAt || event.startsAt).startOf('day');
var weekViewStart = moment(startOfWeek).startOf('day');
var weekViewEnd = moment(endOfWeek).startOf('day');
var offset, span;
if (eventStart.isBefore(weekViewStart) || eventStart.isSame(weekViewStart)) {
offset = 0;
} else {
offset = eventStart.diff(weekViewStart, 'days');
}
if (eventEnd.isAfter(weekViewEnd)) {
eventEnd = weekViewEnd;
}
if (eventStart.isBefore(weekViewStart)) {
eventStart = weekViewStart;
}
span = moment(eventEnd).diff(eventStart, 'days') + 1;
event.daySpan = span;
event.dayOffset = offset;
return event;
});
return { days: days, events: eventsSorted };
}
function getDayView(events, viewDate, dayViewStart, dayViewEnd, dayViewSplit) {
var dayStartHour = moment(dayViewStart || '00:00', 'HH:mm').hours();
var dayEndHour = moment(dayViewEnd || '23:00', 'HH:mm').hours();
var hourHeight = (60 / dayViewSplit) * 30;
var calendarStart = moment(viewDate).startOf('day').add(dayStartHour, 'hours');
var calendarEnd = moment(viewDate).startOf('day').add(dayEndHour, 'hours');
var calendarHeight = (dayEndHour - dayStartHour + 1) * hourHeight;
var hourHeightMultiplier = hourHeight / 60;
var buckets = [];
var eventsInPeriod = filterEventsInPeriod(
events,
moment(viewDate).startOf('day').toDate(),
moment(viewDate).endOf('day').toDate()
);
return eventsInPeriod.map(function(event) {
if (moment(event.startsAt).isBefore(calendarStart)) {
event.top = 0;
} else {
event.top = (moment(event.startsAt).startOf('minute').diff(calendarStart.startOf('minute'), 'minutes') * hourHeightMultiplier) - 2;
}
if (moment(event.endsAt || event.startsAt).isAfter(calendarEnd)) {
event.height = calendarHeight - event.top;
} else {
var diffStart = event.startsAt;
if (moment(event.startsAt).isBefore(calendarStart)) {
diffStart = calendarStart.toDate();
}
if (!event.endsAt) {
event.height = 30;
} else {
event.height = moment(event.endsAt || event.startsAt).diff(diffStart, 'minutes') * hourHeightMultiplier;
}
}
if (event.top - event.height > calendarHeight) {
event.height = 0;
}
event.left = 0;
return event;
}).filter(function(event) {
return event.height > 0;
}).map(function(event) {
var cannotFitInABucket = true;
buckets.forEach(function(bucket, bucketIndex) {
var canFitInThisBucket = true;
bucket.forEach(function(bucketItem) {
if (eventIsInPeriod(event, bucketItem.startsAt, bucketItem.endsAt || bucketItem.startsAt) ||
eventIsInPeriod(bucketItem, event.startsAt, event.endsAt || event.startsAt)) {
canFitInThisBucket = false;
}
});
if (canFitInThisBucket && cannotFitInABucket) {
cannotFitInABucket = false;
event.left = bucketIndex * 150;
buckets[bucketIndex].push(event);
}
});
if (cannotFitInABucket) {
event.left = buckets.length * 150;
buckets.push([event]);
}
return event;
});
}
function getWeekViewWithTimes(events, viewDate, dayViewStart, dayViewEnd, dayViewSplit) {
var weekView = getWeekView(events, viewDate);
var newEvents = [];
weekView.days.forEach(function(day) {
var dayEvents = weekView.events.filter(function(event) {
return moment(event.startsAt).startOf('day').isSame(moment(day.date).startOf('day'));
});
var newDayEvents = getDayView(
dayEvents,
day.date,
dayViewStart,
dayViewEnd,
dayViewSplit
);
newEvents = newEvents.concat(newDayEvents);
});
weekView.events = newEvents;
return weekView;
}
function getDayViewHeight(dayViewStart, dayViewEnd, dayViewSplit) {
var dayViewStartM = moment(dayViewStart || '00:00', 'HH:mm');
var dayViewEndM = moment(dayViewEnd || '23:00', 'HH:mm');
var hourHeight = (60 / dayViewSplit) * 30;
return ((dayViewEndM.diff(dayViewStartM, 'hours') + 1) * hourHeight) + 2;
}
return {
getWeekDayNames: getWeekDayNames,
getYearView: getYearView,
getMonthView: getMonthView,
getWeekView: getWeekView,
getDayView: getDayView,
getWeekViewWithTimes: getWeekViewWithTimes,
getDayViewHeight: getDayViewHeight,
adjustEndDateFromStartDiff: adjustEndDateFromStartDiff,
formatDate: formatDate,
eventIsInPeriod: eventIsInPeriod //expose for testing only
};
}]);
/***/
},
/* 45 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
angular
.module('mwl.calendar')
.factory('calendarTitle', ["moment", "calendarConfig", "calendarHelper", function(moment, calendarConfig, calendarHelper) {
function day(viewDate) {
return calendarHelper.formatDate(viewDate, calendarConfig.titleFormats.day);
}
function week(viewDate) {
var weekTitleLabel = calendarConfig.titleFormats.week;
return weekTitleLabel.replace('{week}', moment(viewDate).week()).replace('{year}', moment(viewDate).format('YYYY'));
}
function month(viewDate) {
return calendarHelper.formatDate(viewDate, calendarConfig.titleFormats.month);
}
function year(viewDate) {
return calendarHelper.formatDate(viewDate, calendarConfig.titleFormats.year);
}
return {
day: day,
week: week,
month: month,
year: year
};
}]);
/***/
},
/* 46 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
var interact;
try {
interact = __webpack_require__(47);
} catch (e) {
/* istanbul ignore next */
interact = null;
}
angular
.module('mwl.calendar')
.constant('interact', interact);
/***/
},
/* 47 */
/***/
function(module, exports) {
if (typeof __WEBPACK_EXTERNAL_MODULE_47__ === 'undefined') {
var e = new Error("Cannot find module \"undefined\"");
e.code = 'MODULE_NOT_FOUND';
throw e;
}
module.exports = __WEBPACK_EXTERNAL_MODULE_47__;
/***/
},
/* 48 */
/***/
function(module, exports, __webpack_require__) {
'use strict';
var angular = __webpack_require__(12);
var moment = __webpack_require__(49);
angular
.module('mwl.calendar')
.constant('moment', moment);
/***/
},
/* 49 */
/***/
function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_49__;
/***/
}
/******/
])
});;