Latest repo

node_modules/react-big-calendar/lib/utils/DateSlotMetrics.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSlotMetrics = getSlotMetrics;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _memoizeOne = _interopRequireDefault(require("memoize-one"));
+var _eventLevels2 = require("./eventLevels");
+var isSegmentInSlot = function isSegmentInSlot(seg, slot) {
+  return seg.left <= slot && seg.right >= slot;
+};
+var isEqual = function isEqual(a, b) {
+  return a[0].range === b[0].range && a[0].events === b[0].events;
+};
+function getSlotMetrics() {
+  return (0, _memoizeOne.default)(function (options) {
+    var range = options.range,
+      events = options.events,
+      maxRows = options.maxRows,
+      minRows = options.minRows,
+      accessors = options.accessors,
+      localizer = options.localizer;
+    var _endOfRange = (0, _eventLevels2.endOfRange)({
+        dateRange: range,
+        localizer: localizer
+      }),
+      first = _endOfRange.first,
+      last = _endOfRange.last;
+    var segments = events.map(function (evt) {
+      return (0, _eventLevels2.eventSegments)(evt, range, accessors, localizer);
+    });
+    var _eventLevels = (0, _eventLevels2.eventLevels)(segments, Math.max(maxRows - 1, 1)),
+      levels = _eventLevels.levels,
+      extra = _eventLevels.extra;
+    // Subtract 1 from minRows to not include showMore button row when
+    // it would be rendered
+    var minEventRows = extra.length > 0 ? minRows - 1 : minRows;
+    while (levels.length < minEventRows) levels.push([]);
+    return {
+      first: first,
+      last: last,
+      levels: levels,
+      extra: extra,
+      range: range,
+      slots: range.length,
+      clone: function clone(args) {
+        var metrics = getSlotMetrics();
+        return metrics((0, _objectSpread2.default)((0, _objectSpread2.default)({}, options), args));
+      },
+      getDateForSlot: function getDateForSlot(slotNumber) {
+        return range[slotNumber];
+      },
+      getSlotForDate: function getSlotForDate(date) {
+        return range.find(function (r) {
+          return localizer.isSameDate(r, date);
+        });
+      },
+      getEventsForSlot: function getEventsForSlot(slot) {
+        return segments.filter(function (seg) {
+          return isSegmentInSlot(seg, slot);
+        }).map(function (seg) {
+          return seg.event;
+        });
+      },
+      continuesPrior: function continuesPrior(event) {
+        return localizer.continuesPrior(accessors.start(event), first);
+      },
+      continuesAfter: function continuesAfter(event) {
+        var start = accessors.start(event);
+        var end = accessors.end(event);
+        return localizer.continuesAfter(start, end, last);
+      }
+    };
+  }, isEqual);
+}

node_modules/react-big-calendar/lib/utils/DayEventLayout.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStyledEvents = getStyledEvents;
+var _overlap = _interopRequireDefault(require("./layout-algorithms/overlap"));
+var _noOverlap = _interopRequireDefault(require("./layout-algorithms/no-overlap"));
+/*eslint no-unused-vars: "off"*/
+
+var DefaultAlgorithms = {
+  overlap: _overlap.default,
+  'no-overlap': _noOverlap.default
+};
+function isFunction(a) {
+  return !!(a && a.constructor && a.call && a.apply);
+}
+
+//
+function getStyledEvents(_ref) {
+  var events = _ref.events,
+    minimumStartDifference = _ref.minimumStartDifference,
+    slotMetrics = _ref.slotMetrics,
+    accessors = _ref.accessors,
+    dayLayoutAlgorithm = _ref.dayLayoutAlgorithm;
+  var algorithm = dayLayoutAlgorithm;
+  if (dayLayoutAlgorithm in DefaultAlgorithms) algorithm = DefaultAlgorithms[dayLayoutAlgorithm];
+  if (!isFunction(algorithm)) {
+    // invalid algorithm
+    return [];
+  }
+  return algorithm.apply(this, arguments);
+}

node_modules/react-big-calendar/lib/utils/Resources.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NONE = void 0;
+exports.default = Resources;
+var NONE = exports.NONE = {};
+function Resources(resources, accessors) {
+  return {
+    map: function map(fn) {
+      if (!resources) return [fn([NONE, null], 0)];
+      return resources.map(function (resource, idx) {
+        return fn([accessors.resourceId(resource), resource], idx);
+      });
+    },
+    groupEvents: function groupEvents(events) {
+      var eventsByResource = new Map();
+      if (!resources) {
+        // Return all events if resources are not provided
+        eventsByResource.set(NONE, events);
+        return eventsByResource;
+      }
+      events.forEach(function (event) {
+        var id = accessors.resource(event) || NONE;
+        if (Array.isArray(id)) {
+          id.forEach(function (item) {
+            var resourceEvents = eventsByResource.get(item) || [];
+            resourceEvents.push(event);
+            eventsByResource.set(item, resourceEvents);
+          });
+        } else {
+          var resourceEvents = eventsByResource.get(id) || [];
+          resourceEvents.push(event);
+          eventsByResource.set(id, resourceEvents);
+        }
+      });
+      return eventsByResource;
+    }
+  };
+}

node_modules/react-big-calendar/lib/utils/TimeSlots.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSlotMetrics = getSlotMetrics;
+var getKey = function getKey(_ref) {
+  var min = _ref.min,
+    max = _ref.max,
+    step = _ref.step,
+    slots = _ref.slots,
+    localizer = _ref.localizer;
+  return "".concat(+localizer.startOf(min, 'minutes')) + "".concat(+localizer.startOf(max, 'minutes')) + "".concat(step, "-").concat(slots);
+};
+function getSlotMetrics(_ref2) {
+  var start = _ref2.min,
+    end = _ref2.max,
+    step = _ref2.step,
+    timeslots = _ref2.timeslots,
+    localizer = _ref2.localizer;
+  var key = getKey({
+    start: start,
+    end: end,
+    step: step,
+    timeslots: timeslots,
+    localizer: localizer
+  });
+
+  // DST differences are handled inside the localizer
+  var totalMin = 1 + localizer.getTotalMin(start, end);
+  var minutesFromMidnight = localizer.getMinutesFromMidnight(start);
+  var numGroups = Math.ceil((totalMin - 1) / (step * timeslots));
+  var numSlots = numGroups * timeslots;
+  var groups = new Array(numGroups);
+  var slots = new Array(numSlots);
+  // Each slot date is created from "zero", instead of adding `step` to
+  // the previous one, in order to avoid DST oddities
+  for (var grp = 0; grp < numGroups; grp++) {
+    groups[grp] = new Array(timeslots);
+    for (var slot = 0; slot < timeslots; slot++) {
+      var slotIdx = grp * timeslots + slot;
+      var minFromStart = slotIdx * step;
+      // A date with total minutes calculated from the start of the day
+      slots[slotIdx] = groups[grp][slot] = localizer.getSlotDate(start, minutesFromMidnight, minFromStart);
+    }
+  }
+
+  // Necessary to be able to select up until the last timeslot in a day
+  var lastSlotMinFromStart = slots.length * step;
+  slots.push(localizer.getSlotDate(start, minutesFromMidnight, lastSlotMinFromStart));
+  function positionFromDate(date) {
+    var diff = localizer.diff(start, date, 'minutes') + localizer.getDstOffset(start, date);
+    return Math.min(diff, totalMin);
+  }
+  return {
+    groups: groups,
+    update: function update(args) {
+      if (getKey(args) !== key) return getSlotMetrics(args);
+      return this;
+    },
+    dateIsInGroup: function dateIsInGroup(date, groupIndex) {
+      var nextGroup = groups[groupIndex + 1];
+      return localizer.inRange(date, groups[groupIndex][0], nextGroup ? nextGroup[0] : end, 'minutes');
+    },
+    nextSlot: function nextSlot(slot) {
+      // We cannot guarantee that the slot object must be in slots,
+      // because after each update, a new slots array will be created.
+      var next = slots[Math.min(slots.findIndex(function (s) {
+        return s === slot || localizer.eq(s, slot);
+      }) + 1, slots.length - 1)];
+      // in the case of the last slot we won't a long enough range so manually get it
+      if (localizer.eq(next, slot)) next = localizer.add(slot, step, 'minutes');
+      return next;
+    },
+    closestSlotToPosition: function closestSlotToPosition(percent) {
+      var slot = Math.min(slots.length - 1, Math.max(0, Math.floor(percent * numSlots)));
+      return slots[slot];
+    },
+    closestSlotFromPoint: function closestSlotFromPoint(point, boundaryRect) {
+      var range = Math.abs(boundaryRect.top - boundaryRect.bottom);
+      return this.closestSlotToPosition((point.y - boundaryRect.top) / range);
+    },
+    closestSlotFromDate: function closestSlotFromDate(date) {
+      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (localizer.lt(date, start, 'minutes')) return slots[0];
+      if (localizer.gt(date, end, 'minutes')) return slots[slots.length - 1];
+      var diffMins = localizer.diff(start, date, 'minutes');
+      return slots[(diffMins - diffMins % step) / step + offset];
+    },
+    startsBeforeDay: function startsBeforeDay(date) {
+      return localizer.lt(date, start, 'day');
+    },
+    startsAfterDay: function startsAfterDay(date) {
+      return localizer.gt(date, end, 'day');
+    },
+    startsBefore: function startsBefore(date) {
+      return localizer.lt(localizer.merge(start, date), start, 'minutes');
+    },
+    startsAfter: function startsAfter(date) {
+      return localizer.gt(localizer.merge(end, date), end, 'minutes');
+    },
+    getRange: function getRange(rangeStart, rangeEnd, ignoreMin, ignoreMax) {
+      if (!ignoreMin) rangeStart = localizer.min(end, localizer.max(start, rangeStart));
+      if (!ignoreMax) rangeEnd = localizer.min(end, localizer.max(start, rangeEnd));
+      var rangeStartMin = positionFromDate(rangeStart);
+      var rangeEndMin = positionFromDate(rangeEnd);
+      var top = rangeEndMin > step * numSlots && !localizer.eq(end, rangeEnd) ? (rangeStartMin - step) / (step * numSlots) * 100 : rangeStartMin / (step * numSlots) * 100;
+      return {
+        top: top,
+        height: rangeEndMin / (step * numSlots) * 100 - top,
+        start: positionFromDate(rangeStart),
+        startDate: rangeStart,
+        end: positionFromDate(rangeEnd),
+        endDate: rangeEnd
+      };
+    },
+    getCurrentTimePosition: function getCurrentTimePosition(rangeStart) {
+      var rangeStartMin = positionFromDate(rangeStart);
+      var top = rangeStartMin / (step * numSlots) * 100;
+      return top;
+    }
+  };
+}

node_modules/react-big-calendar/lib/utils/accessors.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.accessor = accessor;
+exports.wrapAccessor = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+/**
+ * Retrieve via an accessor-like property
+ *
+ *    accessor(obj, 'name')   // => retrieves obj['name']
+ *    accessor(data, func)    // => retrieves func(data)
+ *    ... otherwise null
+ */
+function accessor(data, field) {
+  var value = null;
+  if (typeof field === 'function') value = field(data);else if (typeof field === 'string' && (0, _typeof2.default)(data) === 'object' && data != null && field in data) value = data[field];
+  return value;
+}
+var wrapAccessor = exports.wrapAccessor = function wrapAccessor(acc) {
+  return function (data) {
+    return accessor(data, acc);
+  };
+};

node_modules/react-big-calendar/lib/utils/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.views = exports.navigate = void 0;
+var navigate = exports.navigate = {
+  PREVIOUS: 'PREV',
+  NEXT: 'NEXT',
+  TODAY: 'TODAY',
+  DATE: 'DATE'
+};
+var views = exports.views = {
+  MONTH: 'month',
+  WEEK: 'week',
+  WORK_WEEK: 'work_week',
+  DAY: 'day',
+  AGENDA: 'agenda'
+};

node_modules/react-big-calendar/lib/utils/dates.js

@@ -0,0 +1,236 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "add", {
+  enumerable: true,
+  get: function get() {
+    return dates.add;
+  }
+});
+exports.ceil = ceil;
+exports.diff = diff;
+exports.duration = duration;
+Object.defineProperty(exports, "endOf", {
+  enumerable: true,
+  get: function get() {
+    return dates.endOf;
+  }
+});
+Object.defineProperty(exports, "eq", {
+  enumerable: true,
+  get: function get() {
+    return dates.eq;
+  }
+});
+exports.eqTime = eqTime;
+exports.firstVisibleDay = firstVisibleDay;
+Object.defineProperty(exports, "gt", {
+  enumerable: true,
+  get: function get() {
+    return dates.gt;
+  }
+});
+Object.defineProperty(exports, "gte", {
+  enumerable: true,
+  get: function get() {
+    return dates.gte;
+  }
+});
+Object.defineProperty(exports, "hours", {
+  enumerable: true,
+  get: function get() {
+    return dates.hours;
+  }
+});
+Object.defineProperty(exports, "inRange", {
+  enumerable: true,
+  get: function get() {
+    return dates.inRange;
+  }
+});
+exports.isJustDate = isJustDate;
+exports.lastVisibleDay = lastVisibleDay;
+Object.defineProperty(exports, "lt", {
+  enumerable: true,
+  get: function get() {
+    return dates.lt;
+  }
+});
+Object.defineProperty(exports, "lte", {
+  enumerable: true,
+  get: function get() {
+    return dates.lte;
+  }
+});
+Object.defineProperty(exports, "max", {
+  enumerable: true,
+  get: function get() {
+    return dates.max;
+  }
+});
+exports.merge = merge;
+Object.defineProperty(exports, "milliseconds", {
+  enumerable: true,
+  get: function get() {
+    return dates.milliseconds;
+  }
+});
+Object.defineProperty(exports, "min", {
+  enumerable: true,
+  get: function get() {
+    return dates.min;
+  }
+});
+Object.defineProperty(exports, "minutes", {
+  enumerable: true,
+  get: function get() {
+    return dates.minutes;
+  }
+});
+Object.defineProperty(exports, "month", {
+  enumerable: true,
+  get: function get() {
+    return dates.month;
+  }
+});
+exports.monthsInYear = monthsInYear;
+Object.defineProperty(exports, "neq", {
+  enumerable: true,
+  get: function get() {
+    return dates.neq;
+  }
+});
+exports.range = range;
+Object.defineProperty(exports, "seconds", {
+  enumerable: true,
+  get: function get() {
+    return dates.seconds;
+  }
+});
+Object.defineProperty(exports, "startOf", {
+  enumerable: true,
+  get: function get() {
+    return dates.startOf;
+  }
+});
+exports.today = today;
+exports.tomorrow = tomorrow;
+exports.total = total;
+exports.visibleDays = visibleDays;
+exports.week = week;
+exports.yesterday = yesterday;
+var dates = _interopRequireWildcard(require("date-arithmetic"));
+/* eslint no-fallthrough: off */
+
+var MILLI = {
+  seconds: 1000,
+  minutes: 1000 * 60,
+  hours: 1000 * 60 * 60,
+  day: 1000 * 60 * 60 * 24
+};
+var MONTHS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+function monthsInYear(year) {
+  var date = new Date(year, 0, 1);
+  return MONTHS.map(function (i) {
+    return dates.month(date, i);
+  });
+}
+function firstVisibleDay(date, localizer) {
+  var firstOfMonth = dates.startOf(date, 'month');
+  return dates.startOf(firstOfMonth, 'week', localizer.startOfWeek());
+}
+function lastVisibleDay(date, localizer) {
+  var endOfMonth = dates.endOf(date, 'month');
+  return dates.endOf(endOfMonth, 'week', localizer.startOfWeek());
+}
+function visibleDays(date, localizer) {
+  var current = firstVisibleDay(date, localizer),
+    last = lastVisibleDay(date, localizer),
+    days = [];
+  while (dates.lte(current, last, 'day')) {
+    days.push(current);
+    current = dates.add(current, 1, 'day');
+  }
+  return days;
+}
+function ceil(date, unit) {
+  var floor = dates.startOf(date, unit);
+  return dates.eq(floor, date) ? floor : dates.add(floor, 1, unit);
+}
+function range(start, end) {
+  var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'day';
+  var current = start,
+    days = [];
+  while (dates.lte(current, end, unit)) {
+    days.push(current);
+    current = dates.add(current, 1, unit);
+  }
+  return days;
+}
+function merge(date, time) {
+  if (time == null && date == null) return null;
+  if (time == null) time = new Date();
+  if (date == null) date = new Date();
+  date = dates.startOf(date, 'day');
+  date = dates.hours(date, dates.hours(time));
+  date = dates.minutes(date, dates.minutes(time));
+  date = dates.seconds(date, dates.seconds(time));
+  return dates.milliseconds(date, dates.milliseconds(time));
+}
+function eqTime(dateA, dateB) {
+  return dates.hours(dateA) === dates.hours(dateB) && dates.minutes(dateA) === dates.minutes(dateB) && dates.seconds(dateA) === dates.seconds(dateB);
+}
+function isJustDate(date) {
+  return dates.hours(date) === 0 && dates.minutes(date) === 0 && dates.seconds(date) === 0 && dates.milliseconds(date) === 0;
+}
+function duration(start, end, unit, firstOfWeek) {
+  if (unit === 'day') unit = 'date';
+  return Math.abs(
+  // eslint-disable-next-line import/namespace
+  dates[unit](start, undefined, firstOfWeek) -
+  // eslint-disable-next-line import/namespace
+  dates[unit](end, undefined, firstOfWeek));
+}
+function diff(dateA, dateB, unit) {
+  if (!unit || unit === 'milliseconds') return Math.abs(+dateA - +dateB);
+
+  // the .round() handles an edge case
+  // with DST where the total won't be exact
+  // since one day in the range may be shorter/longer by an hour
+  return Math.round(Math.abs(+dates.startOf(dateA, unit) / MILLI[unit] - +dates.startOf(dateB, unit) / MILLI[unit]));
+}
+function total(date, unit) {
+  var ms = date.getTime(),
+    div = 1;
+  switch (unit) {
+    case 'week':
+      div *= 7;
+    case 'day':
+      div *= 24;
+    case 'hours':
+      div *= 60;
+    case 'minutes':
+      div *= 60;
+    case 'seconds':
+      div *= 1000;
+  }
+  return ms / div;
+}
+function week(date) {
+  var d = new Date(date);
+  d.setHours(0, 0, 0);
+  d.setDate(d.getDate() + 4 - (d.getDay() || 7));
+  return Math.ceil(((d - new Date(d.getFullYear(), 0, 1)) / 8.64e7 + 1) / 7);
+}
+function today() {
+  return dates.startOf(new Date(), 'day');
+}
+function yesterday() {
+  return dates.add(dates.startOf(new Date(), 'day'), -1, 'day');
+}
+function tomorrow() {
+  return dates.add(dates.startOf(new Date(), 'day'), 1, 'day');
+}

node_modules/react-big-calendar/lib/utils/eventLevels.js

@@ -0,0 +1,136 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.endOfRange = endOfRange;
+exports.eventLevels = eventLevels;
+exports.eventSegments = eventSegments;
+exports.inRange = inRange;
+exports.segsOverlap = segsOverlap;
+exports.sortEvents = sortEvents;
+exports.sortWeekEvents = sortWeekEvents;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _findIndex = _interopRequireDefault(require("lodash/findIndex"));
+function endOfRange(_ref) {
+  var dateRange = _ref.dateRange,
+    _ref$unit = _ref.unit,
+    unit = _ref$unit === void 0 ? 'day' : _ref$unit,
+    localizer = _ref.localizer;
+  return {
+    first: dateRange[0],
+    last: localizer.add(dateRange[dateRange.length - 1], 1, unit)
+  };
+}
+
+// properly calculating segments requires working with dates in
+// the timezone we're working with, so we use the localizer
+function eventSegments(event, range, accessors, localizer) {
+  var _endOfRange = endOfRange({
+      dateRange: range,
+      localizer: localizer
+    }),
+    first = _endOfRange.first,
+    last = _endOfRange.last;
+  var slots = localizer.diff(first, last, 'day');
+  var start = localizer.max(localizer.startOf(accessors.start(event), 'day'), first);
+  var end = localizer.min(localizer.ceil(accessors.end(event), 'day'), last);
+  var padding = (0, _findIndex.default)(range, function (x) {
+    return localizer.isSameDate(x, start);
+  });
+  var span = localizer.diff(start, end, 'day');
+  span = Math.min(span, slots);
+  // The segmentOffset is necessary when adjusting for timezones
+  // ahead of the browser timezone
+  span = Math.max(span - localizer.segmentOffset, 1);
+  return {
+    event: event,
+    span: span,
+    left: padding + 1,
+    right: Math.max(padding + span, 1)
+  };
+}
+function eventLevels(rowSegments) {
+  var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Infinity;
+  var i,
+    j,
+    seg,
+    levels = [],
+    extra = [];
+  for (i = 0; i < rowSegments.length; i++) {
+    seg = rowSegments[i];
+    for (j = 0; j < levels.length; j++) if (!segsOverlap(seg, levels[j])) break;
+    if (j >= limit) {
+      extra.push(seg);
+    } else {
+      ;
+      (levels[j] || (levels[j] = [])).push(seg);
+    }
+  }
+  for (i = 0; i < levels.length; i++) {
+    levels[i].sort(function (a, b) {
+      return a.left - b.left;
+    }); //eslint-disable-line
+  }
+  return {
+    levels: levels,
+    extra: extra
+  };
+}
+function inRange(e, start, end, accessors, localizer) {
+  var event = {
+    start: accessors.start(e),
+    end: accessors.end(e)
+  };
+  var range = {
+    start: start,
+    end: end
+  };
+  return localizer.inEventRange({
+    event: event,
+    range: range
+  });
+}
+function segsOverlap(seg, otherSegs) {
+  return otherSegs.some(function (otherSeg) {
+    return otherSeg.left <= seg.right && otherSeg.right >= seg.left;
+  });
+}
+function sortWeekEvents(events, accessors, localizer) {
+  var base = (0, _toConsumableArray2.default)(events);
+  var multiDayEvents = [];
+  var standardEvents = [];
+  base.forEach(function (event) {
+    var startCheck = accessors.start(event);
+    var endCheck = accessors.end(event);
+    if (localizer.daySpan(startCheck, endCheck) > 1) {
+      multiDayEvents.push(event);
+    } else {
+      standardEvents.push(event);
+    }
+  });
+  var multiSorted = multiDayEvents.sort(function (a, b) {
+    return sortEvents(a, b, accessors, localizer);
+  });
+  var standardSorted = standardEvents.sort(function (a, b) {
+    return sortEvents(a, b, accessors, localizer);
+  });
+  return [].concat((0, _toConsumableArray2.default)(multiSorted), (0, _toConsumableArray2.default)(standardSorted));
+}
+function sortEvents(eventA, eventB, accessors, localizer) {
+  var evtA = {
+    start: accessors.start(eventA),
+    end: accessors.end(eventA),
+    allDay: accessors.allDay(eventA)
+  };
+  var evtB = {
+    start: accessors.start(eventB),
+    end: accessors.end(eventB),
+    allDay: accessors.allDay(eventB)
+  };
+  return localizer.sortEvents({
+    evtA: evtA,
+    evtB: evtB
+  });
+}

node_modules/react-big-calendar/lib/utils/helpers.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.instanceId = instanceId;
+exports.isFirstFocusedRender = isFirstFocusedRender;
+exports.notify = notify;
+var idCount = 0;
+function uniqueId(prefix) {
+  return '' + ((prefix == null ? '' : prefix) + ++idCount);
+}
+function notify(handler, args) {
+  handler && handler.apply(null, [].concat(args));
+}
+function instanceId(component) {
+  var suffix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  component.__id || (component.__id = uniqueId('rw_'));
+  return (component.props.id || component.__id) + suffix;
+}
+function isFirstFocusedRender(component) {
+  return component._firstFocus || component.state.focused && (component._firstFocus = true);
+}

node_modules/react-big-calendar/lib/utils/layout-algorithms/no-overlap.js

@@ -0,0 +1,97 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _overlap = _interopRequireDefault(require("./overlap"));
+function getMaxIdxDFS(node, maxIdx, visited) {
+  for (var i = 0; i < node.friends.length; ++i) {
+    if (visited.indexOf(node.friends[i]) > -1) continue;
+    maxIdx = maxIdx > node.friends[i].idx ? maxIdx : node.friends[i].idx;
+    // TODO : trace it by not object but kinda index or something for performance
+    visited.push(node.friends[i]);
+    var newIdx = getMaxIdxDFS(node.friends[i], maxIdx, visited);
+    maxIdx = maxIdx > newIdx ? maxIdx : newIdx;
+  }
+  return maxIdx;
+}
+function _default(_ref) {
+  var events = _ref.events,
+    minimumStartDifference = _ref.minimumStartDifference,
+    slotMetrics = _ref.slotMetrics,
+    accessors = _ref.accessors;
+  var styledEvents = (0, _overlap.default)({
+    events: events,
+    minimumStartDifference: minimumStartDifference,
+    slotMetrics: slotMetrics,
+    accessors: accessors
+  });
+  styledEvents.sort(function (a, b) {
+    a = a.style;
+    b = b.style;
+    if (a.top !== b.top) return a.top > b.top ? 1 : -1;else if (a.height !== b.height) return a.top + a.height < b.top + b.height ? 1 : -1;else return 0;
+  });
+  for (var i = 0; i < styledEvents.length; ++i) {
+    styledEvents[i].friends = [];
+    delete styledEvents[i].style.left;
+    delete styledEvents[i].style.left;
+    delete styledEvents[i].idx;
+    delete styledEvents[i].size;
+  }
+  for (var _i2 = 0; _i2 < styledEvents.length - 1; ++_i2) {
+    var se1 = styledEvents[_i2];
+    var y1 = se1.style.top;
+    var y2 = se1.style.top + se1.style.height;
+    for (var j = _i2 + 1; j < styledEvents.length; ++j) {
+      var se2 = styledEvents[j];
+      var y3 = se2.style.top;
+      var y4 = se2.style.top + se2.style.height;
+      if (y3 >= y1 && y4 <= y2 || y4 > y1 && y4 <= y2 || y3 >= y1 && y3 < y2) {
+        // TODO : hashmap would be effective for performance
+        se1.friends.push(se2);
+        se2.friends.push(se1);
+      }
+    }
+  }
+  for (var _i4 = 0; _i4 < styledEvents.length; ++_i4) {
+    var se = styledEvents[_i4];
+    var bitmap = [];
+    for (var _j2 = 0; _j2 < 100; ++_j2) bitmap.push(1); // 1 means available
+
+    for (var _j4 = 0; _j4 < se.friends.length; ++_j4) if (se.friends[_j4].idx !== undefined) bitmap[se.friends[_j4].idx] = 0; // 0 means reserved
+
+    se.idx = bitmap.indexOf(1);
+  }
+  for (var _i6 = 0; _i6 < styledEvents.length; ++_i6) {
+    var size = 0;
+    if (styledEvents[_i6].size) continue;
+    var allFriends = [];
+    var maxIdx = getMaxIdxDFS(styledEvents[_i6], 0, allFriends);
+    size = 100 / (maxIdx + 1);
+    styledEvents[_i6].size = size;
+    for (var _j6 = 0; _j6 < allFriends.length; ++_j6) allFriends[_j6].size = size;
+  }
+  for (var _i8 = 0; _i8 < styledEvents.length; ++_i8) {
+    var e = styledEvents[_i8];
+    e.style.left = e.idx * e.size;
+
+    // stretch to maximum
+    var _maxIdx = 0;
+    for (var _j8 = 0; _j8 < e.friends.length; ++_j8) {
+      var idx = e.friends[_j8].idx;
+      _maxIdx = _maxIdx > idx ? _maxIdx : idx;
+    }
+    if (_maxIdx <= e.idx) e.size = 100 - e.idx * e.size;
+
+    // padding between events
+    // for this feature, `width` is not percentage based unit anymore
+    // it will be used with calc()
+    var padding = e.idx === 0 ? 0 : 3;
+    e.style.width = "calc(".concat(e.size, "% - ").concat(padding, "px)");
+    e.style.height = "calc(".concat(e.style.height, "% - 2px)");
+    e.style.xOffset = "calc(".concat(e.style.left, "% + ").concat(padding, "px)");
+  }
+  return styledEvents;
+}

node_modules/react-big-calendar/lib/utils/layout-algorithms/overlap.js

@@ -0,0 +1,215 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getStyledEvents;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _sortBy = _interopRequireDefault(require("lodash/sortBy"));
+var Event = /*#__PURE__*/function () {
+  function Event(data, _ref) {
+    var accessors = _ref.accessors,
+      slotMetrics = _ref.slotMetrics;
+    (0, _classCallCheck2.default)(this, Event);
+    var _slotMetrics$getRange = slotMetrics.getRange(accessors.start(data), accessors.end(data)),
+      start = _slotMetrics$getRange.start,
+      startDate = _slotMetrics$getRange.startDate,
+      end = _slotMetrics$getRange.end,
+      endDate = _slotMetrics$getRange.endDate,
+      top = _slotMetrics$getRange.top,
+      height = _slotMetrics$getRange.height;
+    this.start = start;
+    this.end = end;
+    this.startMs = +startDate;
+    this.endMs = +endDate;
+    this.top = top;
+    this.height = height;
+    this.data = data;
+  }
+
+  /**
+   * The event's width without any overlap.
+   */
+  return (0, _createClass2.default)(Event, [{
+    key: "_width",
+    get: function get() {
+      // The container event's width is determined by the maximum number of
+      // events in any of its rows.
+      if (this.rows) {
+        var columns = this.rows.reduce(function (max, row) {
+          return Math.max(max, row.leaves.length + 1);
+        },
+        // add itself
+        0) + 1; // add the container
+
+        return 100 / columns;
+      }
+
+      // The row event's width is the space left by the container, divided
+      // among itself and its leaves.
+      if (this.leaves) {
+        var availableWidth = 100 - this.container._width;
+        return availableWidth / (this.leaves.length + 1);
+      }
+
+      // The leaf event's width is determined by its row's width
+      return this.row._width;
+    }
+
+    /**
+     * The event's calculated width, possibly with extra width added for
+     * overlapping effect.
+     */
+  }, {
+    key: "width",
+    get: function get() {
+      var noOverlap = this._width;
+      var overlap = Math.min(100, this._width * 1.7);
+
+      // Containers can always grow.
+      if (this.rows) {
+        return overlap;
+      }
+
+      // Rows can grow if they have leaves.
+      if (this.leaves) {
+        return this.leaves.length > 0 ? overlap : noOverlap;
+      }
+
+      // Leaves can grow unless they're the last item in a row.
+      var leaves = this.row.leaves;
+      var index = leaves.indexOf(this);
+      return index === leaves.length - 1 ? noOverlap : overlap;
+    }
+  }, {
+    key: "xOffset",
+    get: function get() {
+      // Containers have no offset.
+      if (this.rows) return 0;
+
+      // Rows always start where their container ends.
+      if (this.leaves) return this.container._width;
+
+      // Leaves are spread out evenly on the space left by its row.
+      var _this$row = this.row,
+        leaves = _this$row.leaves,
+        xOffset = _this$row.xOffset,
+        _width = _this$row._width;
+      var index = leaves.indexOf(this) + 1;
+      return xOffset + index * _width;
+    }
+  }]);
+}();
+/**
+ * Return true if event a and b is considered to be on the same row.
+ */
+function onSameRow(a, b, minimumStartDifference) {
+  return (
+    // Occupies the same start slot.
+    Math.abs(b.start - a.start) < minimumStartDifference ||
+    // A's start slot overlaps with b's end slot.
+    b.start > a.start && b.start < a.end
+  );
+}
+function sortByRender(events) {
+  var sortedByTime = (0, _sortBy.default)(events, ['startMs', function (e) {
+    return -e.endMs;
+  }]);
+  var sorted = [];
+  while (sortedByTime.length > 0) {
+    var event = sortedByTime.shift();
+    sorted.push(event);
+    for (var i = 0; i < sortedByTime.length; i++) {
+      var test = sortedByTime[i];
+
+      // Still inside this event, look for next.
+      if (event.endMs > test.startMs) continue;
+
+      // We've found the first event of the next event group.
+      // If that event is not right next to our current event, we have to
+      // move it here.
+      if (i > 0) {
+        var _event = sortedByTime.splice(i, 1)[0];
+        sorted.push(_event);
+      }
+
+      // We've already found the next event group, so stop looking.
+      break;
+    }
+  }
+  return sorted;
+}
+function getStyledEvents(_ref2) {
+  var events = _ref2.events,
+    minimumStartDifference = _ref2.minimumStartDifference,
+    slotMetrics = _ref2.slotMetrics,
+    accessors = _ref2.accessors;
+  // Create proxy events and order them so that we don't have
+  // to fiddle with z-indexes.
+  var proxies = events.map(function (event) {
+    return new Event(event, {
+      slotMetrics: slotMetrics,
+      accessors: accessors
+    });
+  });
+  var eventsInRenderOrder = sortByRender(proxies);
+
+  // Group overlapping events, while keeping order.
+  // Every event is always one of: container, row or leaf.
+  // Containers can contain rows, and rows can contain leaves.
+  var containerEvents = [];
+  var _loop = function _loop() {
+    var event = eventsInRenderOrder[i];
+
+    // Check if this event can go into a container event.
+    var container = containerEvents.find(function (c) {
+      return c.end > event.start || Math.abs(event.start - c.start) < minimumStartDifference;
+    });
+
+    // Couldn't find a container — that means this event is a container.
+    if (!container) {
+      event.rows = [];
+      containerEvents.push(event);
+      return 1; // continue
+    }
+
+    // Found a container for the event.
+    event.container = container;
+
+    // Check if the event can be placed in an existing row.
+    // Start looking from behind.
+    var row = null;
+    for (var j = container.rows.length - 1; !row && j >= 0; j--) {
+      if (onSameRow(container.rows[j], event, minimumStartDifference)) {
+        row = container.rows[j];
+      }
+    }
+    if (row) {
+      // Found a row, so add it.
+      row.leaves.push(event);
+      event.row = row;
+    } else {
+      // Couldn't find a row – that means this event is a row.
+      event.leaves = [];
+      container.rows.push(event);
+    }
+  };
+  for (var i = 0; i < eventsInRenderOrder.length; i++) {
+    if (_loop()) continue;
+  }
+
+  // Return the original events, along with their styles.
+  return eventsInRenderOrder.map(function (event) {
+    return {
+      event: event.data,
+      style: {
+        top: event.top,
+        height: event.height,
+        width: event.width,
+        xOffset: Math.max(0, event.xOffset)
+      }
+    };
+  });
+}

node_modules/react-big-calendar/lib/utils/messages.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = messages;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var defaultMessages = {
+  date: 'Date',
+  time: 'Time',
+  event: 'Event',
+  allDay: 'All Day',
+  week: 'Week',
+  work_week: 'Work Week',
+  day: 'Day',
+  month: 'Month',
+  previous: 'Back',
+  next: 'Next',
+  yesterday: 'Yesterday',
+  tomorrow: 'Tomorrow',
+  today: 'Today',
+  agenda: 'Agenda',
+  noEventsInRange: 'There are no events in this range.',
+  showMore: function showMore(total) {
+    return "+".concat(total, " more");
+  }
+};
+function messages(msgs) {
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, defaultMessages), msgs);
+}

node_modules/react-big-calendar/lib/utils/move.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = moveDate;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _invariant = _interopRequireDefault(require("invariant"));
+var _constants = require("./constants");
+var _Views = _interopRequireDefault(require("../Views"));
+var _excluded = ["action", "date", "today"];
+function moveDate(View, _ref) {
+  var action = _ref.action,
+    date = _ref.date,
+    today = _ref.today,
+    props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  View = typeof View === 'string' ? _Views.default[View] : View;
+  switch (action) {
+    case _constants.navigate.TODAY:
+      date = today || new Date();
+      break;
+    case _constants.navigate.DATE:
+      break;
+    default:
+      (0, _invariant.default)(View && typeof View.navigate === 'function', 'Calendar View components must implement a static `.navigate(date, action)` method.s');
+      date = View.navigate(date, action, props);
+  }
+  return date;
+}

node_modules/react-big-calendar/lib/utils/propTypes.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.views = exports.dateRangeFormat = exports.dateFormat = exports.accessor = exports.DayLayoutAlgorithmPropType = void 0;
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _constants = require("./constants");
+var viewNames = Object.keys(_constants.views).map(function (k) {
+  return _constants.views[k];
+});
+var accessor = exports.accessor = _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.func]);
+var dateFormat = exports.dateFormat = _propTypes.default.any;
+var dateRangeFormat = exports.dateRangeFormat = _propTypes.default.func;
+
+/**
+ * accepts either an array of builtin view names:
+ *
+ * ```
+ * views={['month', 'day', 'agenda']}
+ * ```
+ *
+ * or an object hash of the view name and the component (or boolean for builtin)
+ *
+ * ```
+ * views={{
+ *   month: true,
+ *   week: false,
+ *   workweek: WorkWeekViewComponent,
+ * }}
+ * ```
+ */
+
+var views = exports.views = _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOf(viewNames)), _propTypes.default.objectOf(function (prop, key) {
+  var isBuiltinView = viewNames.indexOf(key) !== -1 && typeof prop[key] === 'boolean';
+  if (isBuiltinView) {
+    return null;
+  } else {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    return _propTypes.default.elementType.apply(_propTypes.default, [prop, key].concat(args));
+  }
+})]);
+var DayLayoutAlgorithmPropType = exports.DayLayoutAlgorithmPropType = _propTypes.default.oneOfType([_propTypes.default.oneOf(['overlap', 'no-overlap']), _propTypes.default.func]);

node_modules/react-big-calendar/lib/utils/selection.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dateCellSelection = dateCellSelection;
+exports.getSlotAtX = getSlotAtX;
+exports.isSelected = isSelected;
+exports.pointInBox = pointInBox;
+exports.slotWidth = slotWidth;
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+function isSelected(event, selected) {
+  if (!event || selected == null) return false;
+  return (0, _isEqual.default)(event, selected);
+}
+function slotWidth(rowBox, slots) {
+  var rowWidth = rowBox.right - rowBox.left;
+  var cellWidth = rowWidth / slots;
+  return cellWidth;
+}
+function getSlotAtX(rowBox, x, rtl, slots) {
+  var cellWidth = slotWidth(rowBox, slots);
+  return rtl ? slots - 1 - Math.floor((x - rowBox.left) / cellWidth) : Math.floor((x - rowBox.left) / cellWidth);
+}
+function pointInBox(box, _ref) {
+  var x = _ref.x,
+    y = _ref.y;
+  return y >= box.top && y <= box.bottom && x >= box.left && x <= box.right;
+}
+function dateCellSelection(start, rowBox, box, slots, rtl) {
+  var startIdx = -1;
+  var endIdx = -1;
+  var lastSlotIdx = slots - 1;
+  var cellWidth = slotWidth(rowBox, slots);
+
+  // cell under the mouse
+  var currentSlot = getSlotAtX(rowBox, box.x, rtl, slots);
+
+  // Identify row as either the initial row
+  // or the row under the current mouse point
+  var isCurrentRow = rowBox.top < box.y && rowBox.bottom > box.y;
+  var isStartRow = rowBox.top < start.y && rowBox.bottom > start.y;
+
+  // this row's position relative to the start point
+  var isAboveStart = start.y > rowBox.bottom;
+  var isBelowStart = rowBox.top > start.y;
+  var isBetween = box.top < rowBox.top && box.bottom > rowBox.bottom;
+
+  // this row is between the current and start rows, so entirely selected
+  if (isBetween) {
+    startIdx = 0;
+    endIdx = lastSlotIdx;
+  }
+  if (isCurrentRow) {
+    if (isBelowStart) {
+      startIdx = 0;
+      endIdx = currentSlot;
+    } else if (isAboveStart) {
+      startIdx = currentSlot;
+      endIdx = lastSlotIdx;
+    }
+  }
+  if (isStartRow) {
+    // select the cell under the initial point
+    startIdx = endIdx = rtl ? lastSlotIdx - Math.floor((start.x - rowBox.left) / cellWidth) : Math.floor((start.x - rowBox.left) / cellWidth);
+    if (isCurrentRow) {
+      if (currentSlot < startIdx) startIdx = currentSlot;else endIdx = currentSlot; //select current range
+    } else if (start.y < box.y) {
+      // the current row is below start row
+      // select cells to the right of the start cell
+      endIdx = lastSlotIdx;
+    } else {
+      // select cells to the left of the start cell
+      startIdx = 0;
+    }
+  }
+  return {
+    startIdx: startIdx,
+    endIdx: endIdx
+  };
+}