@planningcenter/tapestry-react 2.10.0-rc.8 → 2.10.0

package/dist/esm/Button/Button.test.js

@@ -0,0 +1,170 @@
+import React from 'react';
+import { render, fireEvent, createEvent } from '@testing-library/react';
+import { Button } from './Button';
+
+var _ref = /*#__PURE__*/React.createElement(Button, null);
+
+it("should render as <button> with type=\"button\" by default", function () {
+  var _render = render(_ref),
+      container = _render.container;
+
+  var button = container.querySelector('button');
+  expect(button.getAttribute('type')).toEqual('button');
+});
+
+var _ref2 = /*#__PURE__*/React.createElement(Button, {
+  type: "submit"
+});
+
+it("should render as <button> with type=\"submit\"", function () {
+  var _render2 = render(_ref2),
+      container = _render2.container;
+
+  var button = container.querySelector('button');
+  expect(button.getAttribute('type')).toEqual('submit');
+});
+
+var _ref3 = /*#__PURE__*/React.createElement(Button, {
+  disabled: true
+});
+
+it("if \"disabled\" prop is provided, set \"aria-disabled\" attribute", function () {
+  var _render3 = render(_ref3),
+      container = _render3.container;
+
+  var button = container.querySelector('button');
+  expect(button.getAttribute("aria-disabled")).toEqual("true");
+  expect(button.disabled).toBe(false);
+});
+
+var _ref4 = /*#__PURE__*/React.createElement(Button, {
+  disabled: true
+});
+
+it("if \"disabled\" prop is provided, prevent \"Click\" event from firing", function () {
+  var _render4 = render(_ref4),
+      container = _render4.container;
+
+  var button = container.querySelector('button');
+  var clickEvent = createEvent.click(button);
+  fireEvent(button, clickEvent);
+  expect(clickEvent.defaultPrevented).toBe(true);
+});
+
+var _ref5 = /*#__PURE__*/React.createElement(Button, {
+  disabled: true
+});
+
+it("if \"disabled\" prop is provided, prevent keyDown \"Enter\" event from firing", function () {
+  var _render5 = render(_ref5),
+      container = _render5.container;
+
+  var button = container.querySelector('button');
+  var keyDownEvent = createEvent.keyDown(button, {
+    key: 'Enter'
+  });
+  fireEvent(button, keyDownEvent);
+  expect(keyDownEvent.defaultPrevented).toBe(true);
+});
+
+var _ref6 = /*#__PURE__*/React.createElement(Button, {
+  disabled: true
+});
+
+it("if \"disabled\" prop is provided, prevent keyDown \"Space\" event from firing", function () {
+  var _render6 = render(_ref6),
+      container = _render6.container;
+
+  var button = container.querySelector('button');
+  var keyDownEvent = createEvent.keyDown(button, {
+    key: ' '
+  });
+  fireEvent(button, keyDownEvent);
+  expect(keyDownEvent.defaultPrevented).toBe(true);
+});
+it("should render title", function () {
+  var title = 'Hello';
+
+  var _render7 = render( /*#__PURE__*/React.createElement(Button, {
+    title: title
+  })),
+      getByText = _render7.getByText;
+
+  getByText(title);
+});
+
+var _ref7 = /*#__PURE__*/React.createElement(Button, {
+  to: "#"
+});
+
+it("should render <a> without a type if \"to\" is provided", function () {
+  var _render8 = render(_ref7),
+      container = _render8.container;
+
+  var button = container.querySelector('a');
+  expect(button.getAttribute('type')).toBeNull();
+});
+
+var _ref8 = /*#__PURE__*/React.createElement(Button, {
+  href: "#"
+});
+
+it("should render <a> without a type if \"href\" is provided", function () {
+  var _render9 = render(_ref8),
+      container = _render9.container;
+
+  var button = container.querySelector('a');
+  expect(button.getAttribute('type')).toBeNull();
+});
+
+var _ref9 = /*#__PURE__*/React.createElement(Button, {
+  to: "#"
+});
+
+it("should render <a> with \"href\" if \"to\" is specifed", function () {
+  var _render10 = render(_ref9),
+      container = _render10.container;
+
+  var button = container.querySelector('a');
+  expect(button.getAttribute('href')).toEqual('#');
+});
+it("should render href and external link values", function () {
+  var title = 'Hello';
+
+  var _render11 = render( /*#__PURE__*/React.createElement(Button, {
+    external: true,
+    title: title,
+    to: "https://www.planningcenter.com"
+  })),
+      getByText = _render11.getByText;
+
+  var button = getByText(title);
+  expect(button.getAttribute('href')).toEqual('https://www.planningcenter.com');
+  expect(button.getAttribute('rel')).toEqual('noopener noreferrer');
+  expect(button.getAttribute('target')).toEqual('_blank');
+});
+it("should call onClick when clicked or Enter or Space key is pressed", function () {
+  var onClick = jest.fn();
+
+  var _render12 = render( /*#__PURE__*/React.createElement(Button, {
+    onClick: onClick
+  })),
+      container = _render12.container;
+
+  fireEvent.click(container.firstChild);
+  expect(onClick).toHaveBeenCalledTimes(1);
+});
+
+var _ref10 = /*#__PURE__*/React.createElement(Button, null);
+
+it("should not call onClick when Enter or Space key is pressed and onClick isn't present", function () {
+  var _render13 = render(_ref10),
+      container = _render13.container;
+
+  fireEvent.keyDown(container.firstChild, {
+    key: 'Enter'
+  });
+  fireEvent.keyDown(container.firstChild, {
+    key: 'Space'
+  });
+});

package/dist/esm/Button/Input.js

@@ -0,0 +1,163 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import React, { Children, cloneElement, forwardRef, useImperativeHandle, useLayoutEffect, useRef, useState } from 'react';
+import { tabbable } from 'tabbable';
+import ResizeObserver from 'resize-observer-polyfill';
+import { Box } from '../Box';
+import { useBoxSize } from '../system';
+import { getRect } from '../utils';
+import { Button } from './Button';
+
+function getFixedValue(value) {
+  // Safari doesn't like sub pixels
+  return parseInt(value.toFixed(0), 10) + 1;
+}
+
+var ButtonInput = /*#__PURE__*/forwardRef(function (_ref, ref) {
+  var children = _ref.children,
+      style = _ref.style,
+      size = _ref.size,
+      onOpen = _ref.onOpen,
+      onClose = _ref.onClose,
+      restProps = _objectWithoutPropertiesLoose(_ref, ["children", "style", "size", "onOpen", "onClose"]);
+
+  var containerRef = useRef();
+  var inputRef = useRef();
+  var buttonRef = useRef();
+
+  var _useState = useState(false),
+      isOpen = _useState[0],
+      setOpen = _useState[1];
+
+  var _useBoxSize = useBoxSize(size),
+      boxSize = _useBoxSize.boxSize;
+
+  var containerProps = {
+    innerRef: containerRef,
+    height: boxSize,
+    position: 'relative',
+    overflow: 'hidden',
+    transition: 'width 200ms cubic-bezier(.02,.8,.38,1)'
+  };
+  var inputContainerProps = {
+    innerRef: inputRef,
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    left: 0,
+    opacity: isOpen ? 1 : 0,
+    transition: 'opacity 180ms ease'
+  };
+  var inputProps = {
+    size: size,
+    secondaryStroke: false,
+    disabled: !isOpen,
+    onBlur: function onBlur() {
+      var input = inputRef.current.querySelector('input');
+
+      if (input.value.length === 0) {
+        close();
+      }
+    },
+    onKeyDown: function onKeyDown(event) {
+      if (event.key === 'Escape') {
+        close();
+      }
+    }
+  };
+  var buttonContainerProps = {
+    innerRef: buttonRef,
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    left: 0,
+    opacity: isOpen ? 0 : 1,
+    transition: 'opacity 180ms ease'
+  };
+
+  var buttonProps = _objectSpread(_objectSpread({}, restProps), {}, {
+    size: size,
+    disabled: isOpen,
+    onClick: open
+  });
+
+  function open() {
+    setOpen(true);
+    var input = inputRef.current.querySelector('input');
+
+    if (input && input.focus) {
+      setTimeout(function () {
+        return input.focus();
+      });
+    }
+
+    if (onOpen) {
+      onOpen();
+    }
+  }
+
+  function close() {
+    setOpen(false);
+
+    var _tabbable = tabbable(buttonRef.current),
+        button = _tabbable[0];
+
+    if (button && button.focus) {
+      setTimeout(function () {
+        return button.focus();
+      });
+    }
+
+    if (onClose) {
+      onClose();
+    }
+  }
+
+  function transition() {
+    var container = containerRef.current;
+    var inputChild = inputRef.current.firstChild;
+    var buttonChild = buttonRef.current.firstChild;
+    inputChild.style.width = '';
+    buttonChild.style.width = '';
+    var inputRect = getRect(inputChild, {
+      clone: true
+    });
+    var buttonRect = getRect(buttonChild, {
+      clone: true
+    });
+    var containerWidth = getFixedValue(isOpen ? inputRect.width : buttonRect.width);
+    container.style.width = containerWidth + 'px';
+    inputChild.style.width = '100%';
+    buttonChild.style.width = '100%';
+  }
+
+  useLayoutEffect(function () {
+    transition();
+    var ro = new ResizeObserver(transition);
+    ro.observe(isOpen ? inputRef.current : buttonRef.current);
+    return function () {
+      ro.disconnect();
+    };
+  }, [isOpen]);
+  useImperativeHandle(ref, function () {
+    return {
+      open: open,
+      close: close
+    };
+  }, []); // @ts-ignore
+
+  var button = /*#__PURE__*/React.createElement(Button, buttonProps);
+  return /*#__PURE__*/React.createElement(Box, containerProps, /*#__PURE__*/React.createElement(Box, inputContainerProps, typeof children === 'function' ? children({
+    inputProps: inputProps,
+    isOpen: isOpen,
+    open: open,
+    close: close
+  }) : /*#__PURE__*/cloneElement(Children.only(children), inputProps)), /*#__PURE__*/React.createElement(Box, buttonContainerProps, button));
+});
+ButtonInput.displayName = 'Button.Input';
+export default ButtonInput;

package/dist/esm/Button/index.js

@@ -0,0 +1,2 @@
+export * from './Button';
+export { Button as default } from './Button';

package/dist/esm/Calendar/Calendar.js

@@ -0,0 +1,370 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React, { Children, forwardRef, useEffect, useImperativeHandle, useRef, useState } from 'react';
+import { addMonths, addYears, format, getMonth, getYear, isAfter, isBefore, isSameDay, isSameMonth, isWithinInterval } from 'date-fns';
+import Box from '../Box';
+import Button from '../Button';
+import { useThemeValue } from '../system';
+import Group from '../Group';
+import HeadingUppercase from '../HeadingUppercase';
+import StackView from '../StackView';
+import { useHover } from '../hooks';
+import Day from './Day';
+import { getMonthWeekDays, getMonthWeeks, getNextOccurrenceOfDay, getYears, MAX_MONTH_DEFAULT, MAX_YEAR_DEFAULT, MIN_MONTH_DEFAULT, MIN_YEAR_DEFAULT, MONTHS, TODAY } from './utils';
+var sizes = {
+  sm: {
+    buttonSize: 'sm',
+    cellSize: 4,
+    fontSize: 4,
+    headerFontSize: 4,
+    statusOffset: '12.5%',
+    trimWeekdays: 2
+  },
+  md: {
+    buttonSize: 'sm',
+    cellSize: 5,
+    fontSize: 4,
+    headerFontSize: 2,
+    trimWeekdays: 3
+  },
+  lg: {
+    buttonSize: 'sm',
+    cellSize: 7,
+    fontSize: 3,
+    headerFontSize: 2,
+    trimWeekdays: 3
+  }
+}; // NOTE: This additional type is to support the `forwardRef` call below and
+// the static properties that are added to the `Calendar` component.
+
+var Calendar = /*#__PURE__*/forwardRef(function (_ref, calendarRef) {
+  var _ref$date = _ref.date,
+      date = _ref$date === void 0 ? null : _ref$date,
+      _ref$initialDate = _ref.initialDate,
+      initialDate = _ref$initialDate === void 0 ? TODAY : _ref$initialDate,
+      _ref$maxDate = _ref.maxDate,
+      maxDate = _ref$maxDate === void 0 ? null : _ref$maxDate,
+      _ref$minDate = _ref.minDate,
+      minDate = _ref$minDate === void 0 ? null : _ref$minDate,
+      _ref$onDateChange = _ref.onDateChange,
+      onDateChange = _ref$onDateChange === void 0 ? null : _ref$onDateChange,
+      _ref$onDateSelect = _ref.onDateSelect,
+      onDateSelect = _ref$onDateSelect === void 0 ? null : _ref$onDateSelect,
+      _ref$renderDay = _ref.renderDay,
+      renderDay = _ref$renderDay === void 0 ? function (props) {
+    return /*#__PURE__*/React.createElement(Day, props);
+  } : _ref$renderDay,
+      _ref$selected = _ref.selected,
+      selected = _ref$selected === void 0 ? null : _ref$selected,
+      _ref$size = _ref.size,
+      size = _ref$size === void 0 ? 'md' : _ref$size,
+      _ref$weekStartsOn = _ref.weekStartsOn,
+      weekStartsOn = _ref$weekStartsOn === void 0 ? null : _ref$weekStartsOn,
+      restProps = _objectWithoutPropertiesLoose(_ref, ["date", "initialDate", "maxDate", "minDate", "onDateChange", "onDateSelect", "renderDay", "selected", "size", "weekStartsOn"]);
+
+  var calendarTheme = useThemeValue('calendar');
+  var lastDate = useRef(date);
+
+  var _useHover = useHover(),
+      hover = _useHover.hover,
+      hoverProps = _useHover.hoverProps;
+
+  var _useState = useState(date || initialDate),
+      currentDate = _useState[0],
+      setCurrentDate = _useState[1];
+
+  var _useState2 = useState('calendar'),
+      currentView = _useState2[0],
+      setCurrentView = _useState2[1];
+
+  var isCalendarView = currentView === 'calendar';
+  var isYearsView = currentView === 'years';
+  var isMonthsView = currentView === 'months';
+  var currentMonth = getMonth(currentDate);
+  var currentYear = getYear(currentDate);
+  var currentYears = getYears(currentYear);
+  var minMonth = getMonth(minDate) || MIN_MONTH_DEFAULT;
+  var maxMonth = getMonth(maxDate) || MAX_MONTH_DEFAULT;
+  var minYear = getYear(minDate) || MIN_YEAR_DEFAULT;
+  var maxYear = getYear(maxDate) || MAX_YEAR_DEFAULT;
+  var _sizes$size = sizes[size],
+      buttonSize = _sizes$size.buttonSize,
+      cellSize = _sizes$size.cellSize,
+      fontSize = _sizes$size.fontSize,
+      headerFontSize = _sizes$size.headerFontSize,
+      statusOffset = _sizes$size.statusOffset,
+      trimWeekdays = _sizes$size.trimWeekdays;
+  var weekdays = getMonthWeekDays({
+    trimWeekdays: trimWeekdays,
+    weekStartsOn: weekStartsOn || calendarTheme.weekStartsOn || 0
+  });
+  var weeks = getMonthWeeks(currentDate, {
+    forceSixWeeks: true,
+    weekStartsOn: weekStartsOn || calendarTheme.weekStartsOn || 0
+  });
+
+  var setDate = function setDate(nextDate, moveToCalendarView) {
+    var nextView = moveToCalendarView ? 'calendar' : currentView;
+
+    if (Calendar.isBeforeDay(nextDate, minDate)) {
+      nextDate = minDate;
+    } else if (Calendar.isAfterDay(nextDate, maxDate)) {
+      nextDate = maxDate;
+    }
+
+    if (date === null) {
+      setCurrentDate(nextDate);
+      setCurrentView(nextView);
+    } else {
+      setCurrentView(nextView);
+    }
+
+    if (onDateChange) {
+      onDateChange(nextDate);
+    }
+  };
+
+  var navigateCalendar = function navigateCalendar(step) {
+    var isYearsView = currentView === 'years';
+    var add = isYearsView ? addYears : addMonths;
+    setDate(add(currentDate, step));
+  };
+
+  useEffect(function () {
+    if (date !== null && !isSameDay(lastDate.current, date)) {
+      setCurrentDate(date);
+    }
+
+    lastDate.current = date;
+  }, [date]);
+  useImperativeHandle(calendarRef, function () {
+    return {
+      setDate: setDate,
+      navigateCalendar: navigateCalendar
+    };
+  });
+  return /*#__PURE__*/React.createElement(StackView, _extends({
+    innerRef: calendarRef
+  }, hoverProps, restProps), /*#__PURE__*/React.createElement(StackView, {
+    axis: "horizontal",
+    alignment: "center",
+    distribution: "space-between",
+    padding: 0.5,
+    paddingBottom: 0
+  }, /*#__PURE__*/React.createElement(StackView, {
+    axis: "horizontal",
+    spacing: 0.5
+  }, /*#__PURE__*/React.createElement(Box, {
+    "aria-label": isMonthsView ? 'Choose dates' : 'Choose month',
+    as: "button",
+    backgroundColor: hover ? 'highlight' : 'transparent',
+    cursor: "pointer",
+    fontSize: headerFontSize,
+    hover: {
+      backgroundColor: 'highlightSecondary'
+    },
+    lineHeight: 3,
+    onClick: function onClick() {
+      setCurrentView(isMonthsView ? 'calendar' : 'months');
+    },
+    padding: 0.25,
+    radius: 3,
+    tabIndex: -1
+  }, format(currentDate, 'MMMM')), /*#__PURE__*/React.createElement(Box, {
+    "aria-label": isYearsView ? 'Choose dates' : 'Choose year',
+    as: "button",
+    backgroundColor: hover ? 'highlight' : 'transparent',
+    cursor: "pointer",
+    fontSize: headerFontSize,
+    hover: {
+      backgroundColor: 'highlightSecondary'
+    },
+    lineHeight: 3,
+    onClick: function onClick() {
+      setCurrentView(isYearsView ? 'calendar' : 'years');
+    },
+    padding: 0.25,
+    radius: 3,
+    tabIndex: -1
+  }, currentYear)), /*#__PURE__*/React.createElement(Group, {
+    marginRight: 0.5,
+    childProps: {
+      variant: 'outline',
+      size: buttonSize
+    }
+  }, /*#__PURE__*/React.createElement(Button, {
+    disabled: isYearsView ? currentYear <= minYear : isSameMonth(currentDate, minDate),
+    icon: {
+      name: 'general.leftChevron',
+      size: 'xxs'
+    },
+    onClick: function onClick() {
+      return navigateCalendar(-1);
+    },
+    tabIndex: -1,
+    title: "Previous month"
+  }), /*#__PURE__*/React.createElement(Button, {
+    icon: {
+      name: 'tapestry.radio1'
+    },
+    onClick: function onClick() {
+      return setDate(TODAY, true);
+    },
+    tabIndex: -1,
+    tooltip: {
+      title: 'Today'
+    }
+  }), /*#__PURE__*/React.createElement(Button, {
+    disabled: isYearsView ? currentYear >= maxYear : isSameMonth(currentDate, maxDate),
+    icon: {
+      name: 'general.rightChevron',
+      size: 'xxs'
+    },
+    onClick: function onClick() {
+      return navigateCalendar(1);
+    },
+    tabIndex: -1,
+    title: "Next month"
+  }))), isMonthsView && /*#__PURE__*/React.createElement(StackView, {
+    axis: "horizontal",
+    width: cellSize * 7,
+    height: cellSize * 6 + 3.5,
+    marginTop: 0.5,
+    wrap: true
+  }, MONTHS.map(function (month, monthIndex) {
+    var monthDisabled = !Calendar.isWithinRange(new Date(currentYear, monthIndex, 1), {
+      start: new Date(minYear, minMonth, 1),
+      end: new Date(maxYear, maxMonth, 1)
+    });
+    return /*#__PURE__*/React.createElement(StackView, {
+      key: month,
+      as: "button",
+      basis: cellSize * 7 / 3,
+      alignment: "center",
+      distribution: "center",
+      fontWeight: 700,
+      cursor: monthDisabled ? 'not-allowed' : 'pointer',
+      backgroundColor: currentMonth === monthIndex ? 'surfaceSecondary' : 'transparent',
+      opacity: monthDisabled ? 0.6 : undefined,
+      hover: {
+        backgroundColor: monthDisabled ? undefined : 'highlight'
+      },
+      disabled: monthDisabled,
+      onClick: function onClick() {
+        var monthDifference = monthIndex - currentMonth;
+        setDate(addMonths(currentDate, monthDifference), true);
+      },
+      children: /*#__PURE__*/React.createElement(HeadingUppercase, {
+        cursor: "inherit"
+      }, month.substring(0, 3))
+    });
+  })), isYearsView && /*#__PURE__*/React.createElement(StackView, {
+    axis: "horizontal",
+    width: cellSize * 7,
+    height: cellSize * 6 + 3.5,
+    marginTop: 0.5,
+    wrap: true
+  }, currentYears.map(function (year) {
+    var yearDisabled = !(year >= minYear && year <= maxYear);
+    return /*#__PURE__*/React.createElement(StackView, {
+      key: year,
+      as: "button",
+      basis: cellSize * 7 / 3,
+      alignment: "center",
+      distribution: "center",
+      fontWeight: 700,
+      cursor: yearDisabled ? 'not-allowed' : 'pointer',
+      backgroundColor: currentYear === year ? 'surfaceTertiary' : 'transparent',
+      opacity: yearDisabled ? 0.6 : undefined,
+      hover: {
+        backgroundColor: yearDisabled ? undefined : 'highlight'
+      },
+      disabled: yearDisabled,
+      onClick: function onClick() {
+        var yearDifference = year - currentYear;
+        setDate(addYears(currentDate, yearDifference), true);
+      },
+      children: /*#__PURE__*/React.createElement(HeadingUppercase, {
+        cursor: "inherit"
+      }, year)
+    });
+  })), isCalendarView && /*#__PURE__*/React.createElement(StackView, null, /*#__PURE__*/React.createElement(StackView, {
+    axis: "horizontal"
+  }, weekdays.map(function (weekday) {
+    return /*#__PURE__*/React.createElement(StackView, {
+      key: weekday.full,
+      alignment: "center",
+      distribution: "center",
+      width: cellSize,
+      height: 4
+    }, /*#__PURE__*/React.createElement(HeadingUppercase, {
+      fontSize: 6
+    }, weekday.trimmed));
+  })), weeks.map(function (week, index) {
+    return /*#__PURE__*/React.createElement(StackView, {
+      key: index,
+      axis: "horizontal"
+    }, Children.toArray(week.map(function (date) {
+      var inSameMonth = isSameMonth(date, currentDate);
+      var isMinDate = isBefore(date, minDate);
+      var isMaxDate = isAfter(date, maxDate);
+      var isSelected = isSameDay(date, selected);
+      var isToday = isSameDay(date, TODAY);
+      var backgroundColor = isMinDate || isMaxDate ? 'surfaceSecondary' : 'inherit';
+      var color = isSelected ? 'white' : inSameMonth ? 'inherit' : 'foregroundTertiary';
+      return renderDay({
+        backgroundColor: backgroundColor,
+        cellSize: cellSize,
+        color: color,
+        date: date,
+        fontSize: fontSize,
+        inSameMonth: inSameMonth,
+        isMinDate: isMinDate,
+        isMaxDate: isMaxDate,
+        isSelected: isSelected,
+        isToday: isToday,
+        selectDate: onDateSelect,
+        statusOffset: statusOffset
+      });
+    })));
+  })));
+});
+Calendar.defaultProps = {
+  date: null,
+  initialDate: TODAY,
+  minDate: null,
+  maxDate: null,
+  renderDay: function renderDay(props) {
+    return /*#__PURE__*/React.createElement(Day, props);
+  },
+  size: 'md'
+};
+Calendar.TODAY = TODAY;
+Calendar.Day = Day;
+Calendar.getNextOccurrenceOfDay = getNextOccurrenceOfDay;
+
+Calendar.isAfterDay = function (date, dateToCompare) {
+  return date && dateToCompare && isAfter(date, dateToCompare);
+};
+
+Calendar.isBeforeDay = function (date, dateToCompare) {
+  return date && dateToCompare && isBefore(date, dateToCompare);
+};
+
+Calendar.isSameDay = function (dateLeft, dateRight) {
+  return dateLeft && dateRight && isSameDay(dateLeft, dateRight);
+};
+
+Calendar.isWithinRange = function (date, _ref2) {
+  var start = _ref2.start,
+      end = _ref2.end;
+
+  if (date && start && end && isAfter(end, start)) {
+    return isWithinInterval(date, {
+      start: start,
+      end: end
+    });
+  }
+};
+
+export default Calendar;