Latest repo

node_modules/react-big-calendar/lib/addons/dragAndDrop/DnDContext.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DnDContext = void 0;
+var _react = _interopRequireDefault(require("react"));
+var DnDContext = exports.DnDContext = /*#__PURE__*/_react.default.createContext();

node_modules/react-big-calendar/lib/addons/dragAndDrop/EventContainerWrapper.js

@@ -0,0 +1,338 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _DnDContext = require("./DnDContext");
+var _domHelpers = require("dom-helpers");
+var _querySelectorAll = _interopRequireDefault(require("dom-helpers/cjs/querySelectorAll"));
+var _Selection = _interopRequireWildcard(require("../../Selection"));
+var _TimeGridEvent = _interopRequireDefault(require("../../TimeGridEvent"));
+var _common = require("./common");
+var EventContainerWrapper = /*#__PURE__*/function (_React$Component) {
+  function EventContainerWrapper() {
+    var _this;
+    (0, _classCallCheck2.default)(this, EventContainerWrapper);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, EventContainerWrapper, [].concat(args));
+    _this.handleMove = function (point, bounds) {
+      if (!(0, _common.pointInColumn)(bounds, point)) return _this.reset();
+      var event = _this.context.draggable.dragAndDropAction.event;
+      var _this$props = _this.props,
+        accessors = _this$props.accessors,
+        slotMetrics = _this$props.slotMetrics;
+      var newSlot = slotMetrics.closestSlotFromPoint({
+        y: point.y - _this.eventOffsetTop,
+        x: point.x
+      }, bounds);
+      var _eventTimes = (0, _common.eventTimes)(event, accessors, _this.props.localizer),
+        duration = _eventTimes.duration;
+      var newEnd = _this.props.localizer.add(newSlot, duration, 'milliseconds');
+      _this.update(event, slotMetrics.getRange(newSlot, newEnd, false, true));
+    };
+    _this._cleanupPreviewElements = function () {
+      if (_this.ref.current) {
+        var previewElements = (0, _querySelectorAll.default)(_this.ref.current, '.rbc-addons-dnd-drag-preview');
+        previewElements.forEach(function (el) {
+          if (el.parentNode) {
+            try {
+              el.parentNode.removeChild(el);
+            } catch (err) {
+              // Ignore removal errors
+            }
+          }
+        });
+      }
+    };
+    _this.handleDropFromOutside = function (point, boundaryBox) {
+      var _this$props2 = _this.props,
+        slotMetrics = _this$props2.slotMetrics,
+        resource = _this$props2.resource;
+      var start = slotMetrics.closestSlotFromPoint({
+        y: point.y,
+        x: point.x
+      }, boundaryBox);
+      var end = _this._calculateDnDEnd(start);
+      _this.context.draggable.onDropFromOutside({
+        start: start,
+        end: end,
+        allDay: false,
+        resource: resource
+      });
+      _this.reset();
+      // Only call cleanup here, after dropping from outside
+      _this._cleanupPreviewElements();
+    };
+    _this.handleDragOverFromOutside = function (point, bounds) {
+      var slotMetrics = _this.props.slotMetrics;
+      var start = slotMetrics.closestSlotFromPoint({
+        y: point.y,
+        x: point.x
+      }, bounds);
+      var end = _this._calculateDnDEnd(start);
+      var event = _this.context.draggable.dragFromOutsideItem();
+      _this.update(event, slotMetrics.getRange(start, end, false, true));
+    };
+    _this._calculateDnDEnd = function (start) {
+      var _this$props3 = _this.props,
+        accessors = _this$props3.accessors,
+        slotMetrics = _this$props3.slotMetrics,
+        localizer = _this$props3.localizer;
+      var event = _this.context.draggable.dragFromOutsideItem();
+      var _eventTimes2 = (0, _common.eventTimes)(event, accessors, localizer),
+        eventDuration = _eventTimes2.duration;
+      var end = slotMetrics.nextSlot(start);
+      var eventHasDuration = !isNaN(eventDuration);
+      if (eventHasDuration) {
+        var eventEndSlot = localizer.add(start, eventDuration, 'milliseconds');
+        end = new Date(Math.max(eventEndSlot, end));
+      }
+      return end;
+    };
+    _this.updateParentScroll = function (parent, node) {
+      setTimeout(function () {
+        var draggedEl = (0, _querySelectorAll.default)(node, '.rbc-addons-dnd-drag-preview')[0];
+        if (draggedEl) {
+          if (draggedEl.offsetTop < parent.scrollTop) {
+            (0, _domHelpers.scrollTop)(parent, Math.max(draggedEl.offsetTop, 0));
+          } else if (draggedEl.offsetTop + draggedEl.offsetHeight > parent.scrollTop + parent.clientHeight) {
+            (0, _domHelpers.scrollTop)(parent, Math.min(draggedEl.offsetTop - parent.offsetHeight + draggedEl.offsetHeight, parent.scrollHeight));
+          }
+        }
+      });
+    };
+    _this._selectable = function () {
+      var wrapper = _this.ref.current;
+      var node = wrapper.children[0];
+      var isBeingDragged = false;
+      var selector = _this._selector = new _Selection.default(function () {
+        return wrapper.closest('.rbc-time-view');
+      });
+      var parent = (0, _domHelpers.scrollParent)(wrapper);
+      selector.on('beforeSelect', function (point) {
+        var dragAndDropAction = _this.context.draggable.dragAndDropAction;
+        if (!dragAndDropAction.action) return false;
+        if (dragAndDropAction.action === 'resize') {
+          return (0, _common.pointInColumn)((0, _Selection.getBoundsForNode)(node), point);
+        }
+        var eventNode = (0, _Selection.getEventNodeFromPoint)(node, point);
+        if (!eventNode) return false;
+
+        // eventOffsetTop is distance from the top of the event to the initial
+        // mouseDown position. We need this later to compute the new top of the
+        // event during move operations, since the final location is really a
+        // delta from this point. note: if we want to DRY this with WeekWrapper,
+        // probably better just to capture the mouseDown point here and do the
+        // placement computation in handleMove()...
+        _this.eventOffsetTop = point.y - (0, _Selection.getBoundsForNode)(eventNode).top;
+      });
+      selector.on('selecting', function (box) {
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        var dragAndDropAction = _this.context.draggable.dragAndDropAction;
+        if (dragAndDropAction.action === 'move') {
+          _this.updateParentScroll(parent, node);
+          _this.handleMove(box, bounds);
+        }
+        if (dragAndDropAction.action === 'resize') {
+          _this.updateParentScroll(parent, node);
+          _this.handleResize(box, bounds);
+        }
+      });
+      selector.on('dropFromOutside', function (point) {
+        if (!_this.context.draggable.onDropFromOutside) return;
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        if (!(0, _common.pointInColumn)(bounds, point)) return;
+        _this.handleDropFromOutside(point, bounds);
+      });
+      selector.on('dragOverFromOutside', function (point) {
+        var item = _this.context.draggable.dragFromOutsideItem ? _this.context.draggable.dragFromOutsideItem() : null;
+        if (!item) return;
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        if (!(0, _common.pointInColumn)(bounds, point)) return _this.reset();
+        _this.handleDragOverFromOutside(point, bounds);
+      });
+      selector.on('selectStart', function () {
+        isBeingDragged = true;
+        _this.context.draggable.onStart();
+      });
+      selector.on('select', function (point) {
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        isBeingDragged = false;
+        var dragAndDropAction = _this.context.draggable.dragAndDropAction;
+        if (dragAndDropAction.action === 'resize') {
+          _this.handleInteractionEnd();
+        } else if (!_this.state.event || !(0, _common.pointInColumn)(bounds, point)) {
+          return;
+        } else {
+          _this.handleInteractionEnd();
+        }
+      });
+      selector.on('click', function () {
+        if (isBeingDragged) _this.reset();
+        _this.context.draggable.onEnd(null);
+      });
+      selector.on('reset', function () {
+        _this.reset();
+        _this.context.draggable.onEnd(null);
+      });
+    };
+    _this.handleInteractionEnd = function () {
+      var resource = _this.props.resource;
+      var event = _this.state.event;
+      _this.reset();
+      _this.context.draggable.onEnd({
+        start: event.start,
+        end: event.end,
+        resourceId: resource
+      });
+    };
+    _this._teardownSelectable = function () {
+      if (!_this._selector) return;
+      _this._selector.teardown();
+      _this._selector = null;
+    };
+    _this.state = {};
+    _this.ref = /*#__PURE__*/_react.default.createRef();
+    return _this;
+  }
+  (0, _inherits2.default)(EventContainerWrapper, _React$Component);
+  return (0, _createClass2.default)(EventContainerWrapper, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this._selectable();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._teardownSelectable();
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      if (this.state.event) this.setState({
+        event: null,
+        top: null,
+        height: null
+      });
+    }
+  }, {
+    key: "update",
+    value: function update(event, _ref) {
+      var startDate = _ref.startDate,
+        endDate = _ref.endDate,
+        top = _ref.top,
+        height = _ref.height;
+      var lastEvent = this.state.event;
+      if (lastEvent && startDate === lastEvent.start && endDate === lastEvent.end) {
+        return;
+      }
+      this.setState({
+        top: top,
+        height: height,
+        event: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, event), {}, {
+          start: startDate,
+          end: endDate
+        })
+      });
+    }
+  }, {
+    key: "handleResize",
+    value: function handleResize(point, bounds) {
+      var _this$props4 = this.props,
+        accessors = _this$props4.accessors,
+        slotMetrics = _this$props4.slotMetrics,
+        localizer = _this$props4.localizer;
+      var _this$context$draggab = this.context.draggable.dragAndDropAction,
+        event = _this$context$draggab.event,
+        direction = _this$context$draggab.direction;
+      var newTime = slotMetrics.closestSlotFromPoint(point, bounds);
+      var _eventTimes3 = (0, _common.eventTimes)(event, accessors, localizer),
+        start = _eventTimes3.start,
+        end = _eventTimes3.end;
+      var newRange;
+      if (direction === 'UP') {
+        var newStart = localizer.min(newTime, slotMetrics.closestSlotFromDate(end, -1));
+        // Get the new range based on the new start
+        // but don't overwrite the end date as it could be outside this day boundary.
+        newRange = slotMetrics.getRange(newStart, end);
+        newRange = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, newRange), {}, {
+          endDate: end
+        });
+      } else if (direction === 'DOWN') {
+        // Get the new range based on the new end
+        // but don't overwrite the start date as it could be outside this day boundary.
+        var newEnd = localizer.max(newTime, slotMetrics.closestSlotFromDate(start));
+        newRange = slotMetrics.getRange(start, newEnd);
+        newRange = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, newRange), {}, {
+          startDate: start
+        });
+      }
+      this.update(event, newRange);
+    }
+  }, {
+    key: "renderContent",
+    value: function renderContent() {
+      var _this$props5 = this.props,
+        children = _this$props5.children,
+        accessors = _this$props5.accessors,
+        components = _this$props5.components,
+        getters = _this$props5.getters,
+        slotMetrics = _this$props5.slotMetrics,
+        localizer = _this$props5.localizer;
+      var _this$state = this.state,
+        event = _this$state.event,
+        top = _this$state.top,
+        height = _this$state.height;
+      if (!event) return children;
+      var events = children.props.children;
+      var start = event.start,
+        end = event.end;
+      var label;
+      var format = 'eventTimeRangeFormat';
+      var startsBeforeDay = slotMetrics.startsBeforeDay(start);
+      var startsAfterDay = slotMetrics.startsAfterDay(end);
+      if (startsBeforeDay) format = 'eventTimeRangeEndFormat';else if (startsAfterDay) format = 'eventTimeRangeStartFormat';
+      if (startsBeforeDay && startsAfterDay) label = localizer.messages.allDay;else label = localizer.format({
+        start: start,
+        end: end
+      }, format);
+      return /*#__PURE__*/_react.default.cloneElement(children, {
+        children: /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, events, event && /*#__PURE__*/_react.default.createElement(_TimeGridEvent.default, {
+          event: event,
+          label: label,
+          className: "rbc-addons-dnd-drag-preview",
+          style: {
+            top: top,
+            height: height,
+            width: 100
+          },
+          getters: getters,
+          components: components,
+          accessors: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, accessors), _common.dragAccessors),
+          continuesPrior: startsBeforeDay,
+          continuesAfter: startsAfterDay
+        }))
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react.default.createElement("div", {
+        ref: this.ref
+      }, this.renderContent());
+    }
+  }]);
+}(_react.default.Component);
+EventContainerWrapper.contextType = _DnDContext.DnDContext;
+var _default = exports.default = EventContainerWrapper;

node_modules/react-big-calendar/lib/addons/dragAndDrop/EventWrapper.js

@@ -0,0 +1,153 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _accessors = require("../../utils/accessors");
+var _DnDContext = require("./DnDContext");
+var EventWrapper = /*#__PURE__*/function (_React$Component) {
+  function EventWrapper() {
+    var _this;
+    (0, _classCallCheck2.default)(this, EventWrapper);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, EventWrapper, [].concat(args));
+    _this.handleResizeUp = function (e) {
+      if (e.button !== 0) return;
+      _this.context.draggable.onBeginAction(_this.props.event, 'resize', 'UP');
+    };
+    _this.handleResizeDown = function (e) {
+      if (e.button !== 0) return;
+      _this.context.draggable.onBeginAction(_this.props.event, 'resize', 'DOWN');
+    };
+    _this.handleResizeLeft = function (e) {
+      if (e.button !== 0) return;
+      _this.context.draggable.onBeginAction(_this.props.event, 'resize', 'LEFT');
+    };
+    _this.handleResizeRight = function (e) {
+      if (e.button !== 0) return;
+      _this.context.draggable.onBeginAction(_this.props.event, 'resize', 'RIGHT');
+    };
+    _this.handleStartDragging = function (e) {
+      var _e$target$getAttribut;
+      if (e.button !== 0) return;
+      // hack: because of the way the anchors are arranged in the DOM, resize
+      // anchor events will bubble up to the move anchor listener. Don't start
+      // move operations when we're on a resize anchor.
+      var isResizeHandle = (_e$target$getAttribut = e.target.getAttribute('class')) === null || _e$target$getAttribut === void 0 ? void 0 : _e$target$getAttribut.includes('rbc-addons-dnd-resize');
+      if (!isResizeHandle) {
+        var extendedEvent = (0, _objectSpread2.default)({}, _this.props.event);
+        extendedEvent.sourceResource = _this.props.resource;
+        _this.context.draggable.onBeginAction(_this.props.event, 'move');
+      }
+    };
+    return _this;
+  }
+  (0, _inherits2.default)(EventWrapper, _React$Component);
+  return (0, _createClass2.default)(EventWrapper, [{
+    key: "renderAnchor",
+    value: function renderAnchor(direction) {
+      var cls = direction === 'Up' || direction === 'Down' ? 'ns' : 'ew';
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-addons-dnd-resize-".concat(cls, "-anchor"),
+        onMouseDown: this["handleResize".concat(direction)]
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-addons-dnd-resize-".concat(cls, "-icon")
+      }));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        event = _this$props.event,
+        type = _this$props.type,
+        continuesPrior = _this$props.continuesPrior,
+        continuesAfter = _this$props.continuesAfter,
+        resizable = _this$props.resizable;
+      var children = this.props.children;
+      if (event.__isPreview) return /*#__PURE__*/_react.default.cloneElement(children, {
+        className: (0, _clsx.default)(children.props.className, 'rbc-addons-dnd-drag-preview')
+      });
+      var draggable = this.context.draggable;
+      var draggableAccessor = draggable.draggableAccessor,
+        resizableAccessor = draggable.resizableAccessor;
+      var isDraggable = draggableAccessor ? !!(0, _accessors.accessor)(event, draggableAccessor) : true;
+
+      /* Event is not draggable, no need to wrap it */
+      if (!isDraggable) {
+        return children;
+      }
+
+      /*
+       * The resizability of events depends on whether they are
+       * allDay events and how they are displayed.
+       *
+       * 1. If the event is being shown in an event row (because
+       * it is an allDay event shown in the header row or because as
+       * in month view the view is showing all events as rows) then we
+       * allow east-west resizing.
+       *
+       * 2. Otherwise the event is being displayed
+       * normally, we can drag it north-south to resize the times.
+       *
+       * See `DropWrappers` for handling of the drop of such events.
+       *
+       * Notwithstanding the above, we never show drag anchors for
+       * events which continue beyond current component. This happens
+       * in the middle of events when showMultiDay is true, and to
+       * events at the edges of the calendar's min/max location.
+       */
+      var isResizable = resizable && (resizableAccessor ? !!(0, _accessors.accessor)(event, resizableAccessor) : true);
+      if (isResizable || isDraggable) {
+        /*
+         * props.children is the singular <Event> component.
+         * BigCalendar positions the Event abolutely and we
+         * need the anchors to be part of that positioning.
+         * So we insert the anchors inside the Event's children
+         * rather than wrap the Event here as the latter approach
+         * would lose the positioning.
+         */
+        var newProps = {
+          onMouseDown: this.handleStartDragging,
+          onTouchStart: this.handleStartDragging
+        };
+        if (isResizable) {
+          // replace original event child with anchor-embellished child
+          var StartAnchor = null;
+          var EndAnchor = null;
+          if (type === 'date') {
+            StartAnchor = !continuesPrior && this.renderAnchor('Left');
+            EndAnchor = !continuesAfter && this.renderAnchor('Right');
+          } else {
+            StartAnchor = !continuesPrior && this.renderAnchor('Up');
+            EndAnchor = !continuesAfter && this.renderAnchor('Down');
+          }
+          newProps.children = /*#__PURE__*/_react.default.createElement("div", {
+            className: "rbc-addons-dnd-resizable"
+          }, StartAnchor, children.props.children, EndAnchor);
+        }
+        if (draggable.dragAndDropAction.interacting &&
+        // if an event is being dragged right now
+        draggable.dragAndDropAction.event === event // and it's the current event
+        ) {
+          // add a new class to it
+          newProps.className = (0, _clsx.default)(children.props.className, 'rbc-addons-dnd-dragged-event');
+        }
+        children = /*#__PURE__*/_react.default.cloneElement(children, newProps);
+      }
+      return children;
+    }
+  }]);
+}(_react.default.Component);
+EventWrapper.contextType = _DnDContext.DnDContext;
+var _default = exports.default = EventWrapper;

node_modules/react-big-calendar/lib/addons/dragAndDrop/WeekWrapper.js

@@ -0,0 +1,252 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _EventRow = _interopRequireDefault(require("../../EventRow"));
+var _Selection = _interopRequireWildcard(require("../../Selection"));
+var _eventLevels = require("../../utils/eventLevels");
+var _selection = require("../../utils/selection");
+var _common = require("./common");
+var _DnDContext = require("./DnDContext");
+var WeekWrapper = /*#__PURE__*/function (_React$Component) {
+  function WeekWrapper() {
+    var _this;
+    (0, _classCallCheck2.default)(this, WeekWrapper);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, WeekWrapper, [].concat(args));
+    _this.handleMove = function (point, bounds, draggedEvent) {
+      if (!(0, _selection.pointInBox)(bounds, point)) return _this.reset();
+      var event = _this.context.draggable.dragAndDropAction.event || draggedEvent;
+      var _this$props = _this.props,
+        accessors = _this$props.accessors,
+        slotMetrics = _this$props.slotMetrics,
+        rtl = _this$props.rtl,
+        localizer = _this$props.localizer;
+      var slot = (0, _selection.getSlotAtX)(bounds, point.x, rtl, slotMetrics.slots);
+      var date = slotMetrics.getDateForSlot(slot);
+
+      // Adjust the dates, but maintain the times when moving
+      var _eventTimes = (0, _common.eventTimes)(event, accessors, localizer),
+        start = _eventTimes.start,
+        duration = _eventTimes.duration;
+      start = localizer.merge(date, start);
+      var end = localizer.add(start, duration, 'milliseconds');
+      // LATER: when dragging a multi-row event, only the first row is animating
+      _this.update(event, start, end);
+    };
+    _this.handleDropFromOutside = function (point, bounds) {
+      if (!_this.context.draggable.onDropFromOutside) return;
+      var _this$props2 = _this.props,
+        slotMetrics = _this$props2.slotMetrics,
+        rtl = _this$props2.rtl,
+        localizer = _this$props2.localizer;
+      var slot = (0, _selection.getSlotAtX)(bounds, point.x, rtl, slotMetrics.slots);
+      var start = slotMetrics.getDateForSlot(slot);
+      _this.context.draggable.onDropFromOutside({
+        start: start,
+        end: localizer.add(start, 1, 'day'),
+        allDay: false
+      });
+    };
+    _this.handleDragOverFromOutside = function (point, node) {
+      var item = _this.context.draggable.dragFromOutsideItem ? _this.context.draggable.dragFromOutsideItem() : null;
+      if (!item) return;
+      _this.handleMove(point, node, item);
+    };
+    _this._selectable = function () {
+      var node = _this.ref.current.closest('.rbc-month-row, .rbc-allday-cell');
+      var container = node.closest('.rbc-month-view, .rbc-time-view');
+      var isMonthRow = node.classList.contains('rbc-month-row');
+
+      // Valid container check only necessary in TimeGrid views
+      var selector = _this._selector = new _Selection.default(function () {
+        return container;
+      }, {
+        validContainers: (0, _toConsumableArray2.default)(!isMonthRow ? ['.rbc-day-slot', '.rbc-allday-cell'] : [])
+      });
+      selector.on('beforeSelect', function (point) {
+        var isAllDay = _this.props.isAllDay;
+        var action = _this.context.draggable.dragAndDropAction.action;
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        var isInBox = (0, _selection.pointInBox)(bounds, point);
+        return action === 'move' || action === 'resize' && (!isAllDay || isInBox);
+      });
+      selector.on('selecting', function (box) {
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        var dragAndDropAction = _this.context.draggable.dragAndDropAction;
+        if (dragAndDropAction.action === 'move') _this.handleMove(box, bounds);
+        if (dragAndDropAction.action === 'resize') _this.handleResize(box, bounds);
+      });
+      selector.on('selectStart', function () {
+        return _this.context.draggable.onStart();
+      });
+      selector.on('select', function (point) {
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        if (!_this.state.segment) return;
+        if (!(0, _selection.pointInBox)(bounds, point)) {
+          _this.reset();
+        } else {
+          _this.handleInteractionEnd();
+        }
+      });
+      selector.on('dropFromOutside', function (point) {
+        if (!_this.context.draggable.onDropFromOutside) return;
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        if (!(0, _selection.pointInBox)(bounds, point)) return;
+        _this.handleDropFromOutside(point, bounds);
+      });
+      selector.on('dragOverFromOutside', function (point) {
+        if (!_this.context.draggable.dragFromOutsideItem) return;
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        _this.handleDragOverFromOutside(point, bounds);
+      });
+      selector.on('click', function () {
+        return _this.context.draggable.onEnd(null);
+      });
+      selector.on('reset', function () {
+        _this.reset();
+        _this.context.draggable.onEnd(null);
+      });
+    };
+    _this.handleInteractionEnd = function () {
+      var _this$props3 = _this.props,
+        resourceId = _this$props3.resourceId,
+        isAllDay = _this$props3.isAllDay;
+      var event = _this.state.segment.event;
+      _this.reset();
+      _this.context.draggable.onEnd({
+        start: event.start,
+        end: event.end,
+        resourceId: resourceId,
+        isAllDay: isAllDay
+      });
+    };
+    _this._teardownSelectable = function () {
+      if (!_this._selector) return;
+      _this._selector.teardown();
+      _this._selector = null;
+    };
+    _this.state = {};
+    _this.ref = /*#__PURE__*/_react.default.createRef();
+    return _this;
+  }
+  (0, _inherits2.default)(WeekWrapper, _React$Component);
+  return (0, _createClass2.default)(WeekWrapper, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this._selectable();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._teardownSelectable();
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      if (this.state.segment) this.setState({
+        segment: null
+      });
+    }
+  }, {
+    key: "update",
+    value: function update(event, start, end) {
+      var segment = (0, _eventLevels.eventSegments)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, event), {}, {
+        end: end,
+        start: start,
+        __isPreview: true
+      }), this.props.slotMetrics.range, _common.dragAccessors, this.props.localizer);
+      var lastSegment = this.state.segment;
+      if (lastSegment && segment.span === lastSegment.span && segment.left === lastSegment.left && segment.right === lastSegment.right) {
+        return;
+      }
+      this.setState({
+        segment: segment
+      });
+    }
+  }, {
+    key: "handleResize",
+    value: function handleResize(point, bounds) {
+      var _this$context$draggab = this.context.draggable.dragAndDropAction,
+        event = _this$context$draggab.event,
+        direction = _this$context$draggab.direction;
+      var _this$props4 = this.props,
+        accessors = _this$props4.accessors,
+        slotMetrics = _this$props4.slotMetrics,
+        rtl = _this$props4.rtl,
+        localizer = _this$props4.localizer;
+      var _eventTimes2 = (0, _common.eventTimes)(event, accessors, localizer),
+        start = _eventTimes2.start,
+        end = _eventTimes2.end;
+      var slot = (0, _selection.getSlotAtX)(bounds, point.x, rtl, slotMetrics.slots);
+      var date = slotMetrics.getDateForSlot(slot);
+      var cursorInRow = (0, _selection.pointInBox)(bounds, point);
+      if (direction === 'RIGHT') {
+        if (cursorInRow) {
+          if (slotMetrics.last < start) return this.reset();
+          if (localizer.eq(localizer.startOf(end, 'day'), end)) end = localizer.add(date, 1, 'day');else end = date;
+        } else if (localizer.inRange(start, slotMetrics.first, slotMetrics.last) || bounds.bottom < point.y && +slotMetrics.first > +start) {
+          end = localizer.add(slotMetrics.last, 1, 'milliseconds');
+        } else {
+          this.setState({
+            segment: null
+          });
+          return;
+        }
+        var originalEnd = accessors.end(event);
+        end = localizer.merge(end, originalEnd);
+        if (localizer.lt(end, start)) {
+          end = originalEnd;
+        }
+      } else if (direction === 'LEFT') {
+        if (cursorInRow) {
+          if (slotMetrics.first > end) return this.reset();
+          start = date;
+        } else if (localizer.inRange(end, slotMetrics.first, slotMetrics.last) || bounds.top > point.y && localizer.lt(slotMetrics.last, end)) {
+          start = localizer.add(slotMetrics.first, -1, 'milliseconds');
+        } else {
+          this.reset();
+          return;
+        }
+        var originalStart = accessors.start(event);
+        start = localizer.merge(start, originalStart);
+        if (localizer.gt(start, end)) {
+          start = originalStart;
+        }
+      }
+      this.update(event, start, end);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props5 = this.props,
+        children = _this$props5.children,
+        accessors = _this$props5.accessors;
+      var segment = this.state.segment;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        ref: this.ref,
+        className: "rbc-addons-dnd-row-body"
+      }, children, segment && /*#__PURE__*/_react.default.createElement(_EventRow.default, Object.assign({}, this.props, {
+        selected: null,
+        className: "rbc-addons-dnd-drag-row",
+        segments: [segment],
+        accessors: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, accessors), _common.dragAccessors)
+      })));
+    }
+  }]);
+}(_react.default.Component);
+WeekWrapper.contextType = _DnDContext.DnDContext;
+var _default = exports.default = WeekWrapper;

node_modules/react-big-calendar/lib/addons/dragAndDrop/common.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dragAccessors = void 0;
+exports.eventTimes = eventTimes;
+exports.mergeComponents = mergeComponents;
+exports.pointInColumn = pointInColumn;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _accessors = require("../../utils/accessors");
+var _react = require("react");
+var _excluded = ["children"];
+var dragAccessors = exports.dragAccessors = {
+  start: (0, _accessors.wrapAccessor)(function (e) {
+    return e.start;
+  }),
+  end: (0, _accessors.wrapAccessor)(function (e) {
+    return e.end;
+  })
+};
+function nest() {
+  for (var _len = arguments.length, Components = new Array(_len), _key = 0; _key < _len; _key++) {
+    Components[_key] = arguments[_key];
+  }
+  var factories = Components.filter(Boolean).map(_react.createFactory);
+  var Nest = function Nest(_ref) {
+    var children = _ref.children,
+      props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+    return factories.reduceRight(function (child, factory) {
+      return factory(props, child);
+    }, children);
+  };
+  return Nest;
+}
+function mergeComponents() {
+  var components = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var addons = arguments.length > 1 ? arguments[1] : undefined;
+  var keys = Object.keys(addons);
+  var result = (0, _objectSpread2.default)({}, components);
+  keys.forEach(function (key) {
+    result[key] = components[key] ? nest(components[key], addons[key]) : addons[key];
+  });
+  return result;
+}
+function pointInColumn(bounds, point) {
+  var left = bounds.left,
+    right = bounds.right,
+    top = bounds.top;
+  var x = point.x,
+    y = point.y;
+  return x < right + 10 && x > left && y > top;
+}
+function eventTimes(event, accessors, localizer) {
+  var start = accessors.start(event);
+  var end = accessors.end(event);
+  var isZeroDuration = localizer.eq(start, end, 'minutes') && localizer.diff(start, end, 'minutes') === 0;
+  // make zero duration midnight events at least one day long
+  if (isZeroDuration) end = localizer.add(end, 1, 'day');
+  var duration = localizer.diff(start, end, 'milliseconds');
+  return {
+    start: start,
+    end: end,
+    duration: duration
+  };
+}

node_modules/react-big-calendar/lib/addons/dragAndDrop/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _withDragAndDrop = _interopRequireDefault(require("./withDragAndDrop"));
+var _default = exports.default = _withDragAndDrop.default;

node_modules/react-big-calendar/lib/addons/dragAndDrop/styles.css

@@ -0,0 +1,68 @@
+.rbc-addons-dnd .rbc-addons-dnd-row-body {
+  position: relative;
+}
+.rbc-addons-dnd .rbc-addons-dnd-drag-row {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-over {
+  background-color: rgba(0, 0, 0, 0.3);
+}
+.rbc-addons-dnd .rbc-event {
+  transition: opacity 150ms;
+}
+.rbc-addons-dnd .rbc-event:hover .rbc-addons-dnd-resize-ns-icon, .rbc-addons-dnd .rbc-event:hover .rbc-addons-dnd-resize-ew-icon {
+  display: block;
+}
+.rbc-addons-dnd .rbc-addons-dnd-dragged-event {
+  opacity: 0;
+}
+.rbc-addons-dnd.rbc-addons-dnd-is-dragging .rbc-event:not(.rbc-addons-dnd-dragged-event):not(.rbc-addons-dnd-drag-preview) {
+  opacity: 0.5;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resizable {
+  position: relative;
+  width: 100%;
+  height: 100%;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ns-anchor {
+  width: 100%;
+  text-align: center;
+  position: absolute;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ns-anchor:first-child {
+  top: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ns-anchor:last-child {
+  bottom: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ns-anchor .rbc-addons-dnd-resize-ns-icon {
+  display: none;
+  border-top: 3px double;
+  margin: 0 auto;
+  width: 10px;
+  cursor: ns-resize;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ew-anchor {
+  position: absolute;
+  top: 4px;
+  bottom: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ew-anchor:first-child {
+  left: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ew-anchor:last-child {
+  right: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ew-anchor .rbc-addons-dnd-resize-ew-icon {
+  display: none;
+  border-left: 3px double;
+  margin-top: auto;
+  margin-bottom: auto;
+  height: 10px;
+  cursor: ew-resize;
+}
+
+/*# sourceMappingURL=styles.css.map */

node_modules/react-big-calendar/lib/addons/dragAndDrop/styles.css.map

@@ -0,0 +1 @@
+{"version":3,"sourceRoot":"","sources":["styles.scss"],"names":[],"mappings":"AAGE;EACE;;AAEF;EACE;EACA;EACA;EACA;;AAIF;EACE;;AAQF;EACE;;AAGE;EAAiE;;AAIrE;EACE;;AAGF;EACE;;AAGF;EACE;EACA;EACA;;AAGF;EACE;EACA;EACA;;AACA;EAAgB;;AAChB;EAAe;;AAEf;EACE;EACA;EACA;EACA;EACA;;AAIJ;EACE;EACA;EACA;;AACA;EAAgB;;AAChB;EAAe;;AAEf;EACE;EACA;EACA;EACA;EACA;EACA","file":"styles.css"}

node_modules/react-big-calendar/lib/addons/dragAndDrop/styles.scss

@@ -0,0 +1,78 @@
+@import '../../sass/variables';
+
+.rbc-addons-dnd {
+  .rbc-addons-dnd-row-body {
+    position: relative;
+  }
+  .rbc-addons-dnd-drag-row {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+  }
+
+
+  .rbc-addons-dnd-over {
+    background-color: rgba(
+      red($date-selection-bg-color),
+      green($date-selection-bg-color),
+      blue($date-selection-bg-color),
+      .3
+    );
+  }
+
+  .rbc-event {
+    transition: opacity 150ms;
+
+    &:hover {
+      .rbc-addons-dnd-resize-ns-icon, .rbc-addons-dnd-resize-ew-icon { display: block; }
+    }
+  }
+
+  .rbc-addons-dnd-dragged-event {
+    opacity: 0;
+  }
+
+  &.rbc-addons-dnd-is-dragging .rbc-event:not(.rbc-addons-dnd-dragged-event):not(.rbc-addons-dnd-drag-preview) {
+    opacity: .50;
+  }
+
+  .rbc-addons-dnd-resizable {
+    position: relative;
+    width: 100%;
+    height: 100%;
+  }
+
+  .rbc-addons-dnd-resize-ns-anchor {
+    width: 100%;
+    text-align: center;
+    position: absolute;
+    &:first-child { top: 0; }
+    &:last-child { bottom: 0; }
+
+    .rbc-addons-dnd-resize-ns-icon {
+      display: none;
+      border-top: 3px double;
+      margin: 0 auto;
+      width: 10px;
+      cursor: ns-resize;
+    }
+  }
+
+  .rbc-addons-dnd-resize-ew-anchor {
+    position: absolute;
+    top: 4px;
+    bottom: 0;
+    &:first-child { left: 0; }
+    &:last-child { right: 0; }
+
+    .rbc-addons-dnd-resize-ew-icon {
+      display: none;
+      border-left: 3px double;
+      margin-top: auto;
+      margin-bottom: auto;
+      height: 10px;
+      cursor: ew-resize;
+    }
+  }
+}

node_modules/react-big-calendar/lib/addons/dragAndDrop/withDragAndDrop.js

@@ -0,0 +1,131 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = withDragAndDrop;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _propTypes = require("../../utils/propTypes");
+var _EventWrapper = _interopRequireDefault(require("./EventWrapper"));
+var _EventContainerWrapper = _interopRequireDefault(require("./EventContainerWrapper"));
+var _WeekWrapper = _interopRequireDefault(require("./WeekWrapper"));
+var _common = require("./common");
+var _DnDContext = require("./DnDContext");
+var _excluded = ["selectable", "elementProps", "components"];
+function withDragAndDrop(Calendar) {
+  var DragAndDropCalendar = /*#__PURE__*/function (_React$Component) {
+    function DragAndDropCalendar() {
+      var _this;
+      (0, _classCallCheck2.default)(this, DragAndDropCalendar);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = (0, _callSuper2.default)(this, DragAndDropCalendar, [].concat(args));
+      _this.defaultOnDragOver = function (event) {
+        event.preventDefault();
+      };
+      _this.handleBeginAction = function (event, action, direction) {
+        _this.setState({
+          event: event,
+          action: action,
+          direction: direction
+        });
+        var onDragStart = _this.props.onDragStart;
+        if (onDragStart) onDragStart({
+          event: event,
+          action: action,
+          direction: direction
+        });
+      };
+      _this.handleInteractionStart = function () {
+        if (_this.state.interacting === false) _this.setState({
+          interacting: true
+        });
+      };
+      _this.handleInteractionEnd = function (interactionInfo) {
+        var _this$state = _this.state,
+          action = _this$state.action,
+          event = _this$state.event;
+        if (!action) return;
+        _this.setState({
+          action: null,
+          event: null,
+          interacting: false,
+          direction: null
+        });
+        if (interactionInfo == null) return;
+        interactionInfo.event = event;
+        var _this$props = _this.props,
+          onEventDrop = _this$props.onEventDrop,
+          onEventResize = _this$props.onEventResize;
+        if (action === 'move' && onEventDrop) onEventDrop(interactionInfo);
+        if (action === 'resize' && onEventResize) onEventResize(interactionInfo);
+      };
+      _this.state = {
+        interacting: false
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(DragAndDropCalendar, _React$Component);
+    return (0, _createClass2.default)(DragAndDropCalendar, [{
+      key: "getDnDContextValue",
+      value: function getDnDContextValue() {
+        return {
+          draggable: {
+            onStart: this.handleInteractionStart,
+            onEnd: this.handleInteractionEnd,
+            onBeginAction: this.handleBeginAction,
+            onDropFromOutside: this.props.onDropFromOutside,
+            dragFromOutsideItem: this.props.dragFromOutsideItem,
+            draggableAccessor: this.props.draggableAccessor,
+            resizableAccessor: this.props.resizableAccessor,
+            dragAndDropAction: this.state
+          }
+        };
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props2 = this.props,
+          selectable = _this$props2.selectable,
+          elementProps = _this$props2.elementProps,
+          components = _this$props2.components,
+          props = (0, _objectWithoutProperties2.default)(_this$props2, _excluded);
+        var interacting = this.state.interacting;
+        delete props.onEventDrop;
+        delete props.onEventResize;
+        props.selectable = selectable ? 'ignoreEvents' : false;
+        this.components = (0, _common.mergeComponents)(components, {
+          eventWrapper: _EventWrapper.default,
+          eventContainerWrapper: _EventContainerWrapper.default,
+          weekWrapper: _WeekWrapper.default
+        });
+        var elementPropsWithDropFromOutside = this.props.onDropFromOutside ? (0, _objectSpread2.default)((0, _objectSpread2.default)({}, elementProps), {}, {
+          onDragOver: this.props.onDragOver || this.defaultOnDragOver
+        }) : elementProps;
+        props.className = (0, _clsx.default)(props.className, 'rbc-addons-dnd', !!interacting && 'rbc-addons-dnd-is-dragging');
+        var context = this.getDnDContextValue();
+        return /*#__PURE__*/_react.default.createElement(_DnDContext.DnDContext.Provider, {
+          value: context
+        }, /*#__PURE__*/_react.default.createElement(Calendar, Object.assign({}, props, {
+          elementProps: elementPropsWithDropFromOutside,
+          components: this.components
+        })));
+      }
+    }]);
+  }(_react.default.Component);
+  DragAndDropCalendar.defaultProps = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, Calendar.defaultProps), {}, {
+    draggableAccessor: null,
+    resizableAccessor: null,
+    resizable: true
+  });
+  return DragAndDropCalendar;
+}