@birdnet/advanced-react-dates 0.0.0-stage → 1.0.0

package/esm/theme/DefaultTheme.js

@@ -0,0 +1,176 @@
+var core = {
+  white: '#fff',
+  gray: '#484848',
+  grayLight: '#82888a',
+  grayLighter: '#cacccd',
+  grayLightest: '#f2f2f2',
+  borderMedium: '#c4c4c4',
+  border: '#dbdbdb',
+  borderLight: '#e4e7e7',
+  borderLighter: '#eceeee',
+  borderBright: '#f4f5f5',
+  primary: '#00a699',
+  primaryShade_1: '#33dacd',
+  primaryShade_2: '#66e2da',
+  primaryShade_3: '#80e8e0',
+  primaryShade_4: '#b2f1ec',
+  primary_dark: '#008489',
+  secondary: '#007a87',
+  yellow: '#ffe8bc',
+  yellow_dark: '#ffce71'
+};
+export default {
+  reactDates: {
+    zIndex: 0,
+    border: {
+      input: {
+        border: 0,
+        borderTop: 0,
+        borderRight: 0,
+        borderBottom: '2px solid transparent',
+        borderLeft: 0,
+        outlineFocused: 0,
+        borderFocused: 0,
+        borderTopFocused: 0,
+        borderLeftFocused: 0,
+        borderBottomFocused: "2px solid ".concat(core.primary_dark),
+        borderRightFocused: 0,
+        borderRadius: 0
+      },
+      pickerInput: {
+        borderWidth: 1,
+        borderStyle: 'solid',
+        borderRadius: 2
+      }
+    },
+    color: {
+      core: core,
+      disabled: core.grayLightest,
+      background: core.white,
+      backgroundDark: '#f2f2f2',
+      backgroundFocused: core.white,
+      border: 'rgb(219, 219, 219)',
+      text: core.gray,
+      textDisabled: core.border,
+      textFocused: '#007a87',
+      placeholderText: '#757575',
+      outside: {
+        backgroundColor: core.white,
+        backgroundColor_active: core.white,
+        backgroundColor_hover: core.white,
+        color: core.gray,
+        color_active: core.gray,
+        color_hover: core.gray
+      },
+      highlighted: {
+        backgroundColor: core.yellow,
+        backgroundColor_active: core.yellow_dark,
+        backgroundColor_hover: core.yellow_dark,
+        color: core.gray,
+        color_active: core.gray,
+        color_hover: core.gray
+      },
+      minimumNights: {
+        backgroundColor: core.white,
+        backgroundColor_active: core.white,
+        backgroundColor_hover: core.white,
+        borderColor: core.borderLighter,
+        color: core.grayLighter,
+        color_active: core.grayLighter,
+        color_hover: core.grayLighter
+      },
+      hoveredSpan: {
+        backgroundColor: core.primaryShade_4,
+        backgroundColor_active: core.primaryShade_3,
+        backgroundColor_hover: core.primaryShade_4,
+        borderColor: core.primaryShade_3,
+        borderColor_active: core.primaryShade_3,
+        borderColor_hover: core.primaryShade_3,
+        color: core.secondary,
+        color_active: core.secondary,
+        color_hover: core.secondary
+      },
+      selectedSpan: {
+        backgroundColor: core.primaryShade_2,
+        backgroundColor_active: core.primaryShade_1,
+        backgroundColor_hover: core.primaryShade_1,
+        borderColor: core.primaryShade_1,
+        borderColor_active: core.primary,
+        borderColor_hover: core.primary,
+        color: core.white,
+        color_active: core.white,
+        color_hover: core.white
+      },
+      selected: {
+        backgroundColor: core.primary,
+        backgroundColor_active: core.primary,
+        backgroundColor_hover: core.primary,
+        borderColor: core.primary,
+        borderColor_active: core.primary,
+        borderColor_hover: core.primary,
+        color: core.white,
+        color_active: core.white,
+        color_hover: core.white
+      },
+      blocked_calendar: {
+        backgroundColor: core.grayLighter,
+        backgroundColor_active: core.grayLighter,
+        backgroundColor_hover: core.grayLighter,
+        borderColor: core.grayLighter,
+        borderColor_active: core.grayLighter,
+        borderColor_hover: core.grayLighter,
+        color: core.grayLight,
+        color_active: core.grayLight,
+        color_hover: core.grayLight
+      },
+      blocked_out_of_range: {
+        backgroundColor: core.white,
+        backgroundColor_active: core.white,
+        backgroundColor_hover: core.white,
+        borderColor: core.borderLight,
+        borderColor_active: core.borderLight,
+        borderColor_hover: core.borderLight,
+        color: core.grayLighter,
+        color_active: core.grayLighter,
+        color_hover: core.grayLighter
+      }
+    },
+    spacing: {
+      dayPickerHorizontalPadding: 9,
+      captionPaddingTop: 22,
+      captionPaddingBottom: 37,
+      inputPadding: 0,
+      displayTextPaddingVertical: undefined,
+      displayTextPaddingTop: 11,
+      displayTextPaddingBottom: 9,
+      displayTextPaddingHorizontal: undefined,
+      displayTextPaddingLeft: 11,
+      displayTextPaddingRight: 11,
+      displayTextPaddingVertical_small: undefined,
+      displayTextPaddingTop_small: 7,
+      displayTextPaddingBottom_small: 5,
+      displayTextPaddingHorizontal_small: undefined,
+      displayTextPaddingLeft_small: 7,
+      displayTextPaddingRight_small: 7
+    },
+    sizing: {
+      inputWidth: 130,
+      inputWidth_small: 97,
+      arrowWidth: 24
+    },
+    noScrollBarOnVerticalScrollable: false,
+    font: {
+      size: 14,
+      captionSize: 18,
+      input: {
+        size: 19,
+        weight: 200,
+        lineHeight: '24px',
+        size_small: 15,
+        lineHeight_small: '18px',
+        letterSpacing_small: '0.2px',
+        styleDisabled: 'italic'
+      }
+    }
+  }
+};

package/esm/utils/calculateDimension.js

@@ -0,0 +1,28 @@
+export default function calculateDimension(el, axis) {
+  var borderBox = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var withMargin = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  if (!el) {
+    return 0;
+  }
+  var axisStart = axis === 'width' ? 'Left' : 'Top';
+  var axisEnd = axis === 'width' ? 'Right' : 'Bottom';
+
+  // Only read styles if we need to
+  var style = !borderBox || withMargin ? window.getComputedStyle(el) : null;
+
+  // Offset includes border and padding
+  var offsetWidth = el.offsetWidth,
+    offsetHeight = el.offsetHeight;
+  var size = axis === 'width' ? offsetWidth : offsetHeight;
+
+  // Get the inner size
+  if (!borderBox) {
+    size -= parseFloat(style["padding".concat(axisStart)]) + parseFloat(style["padding".concat(axisEnd)]) + parseFloat(style["border".concat(axisStart, "Width")]) + parseFloat(style["border".concat(axisEnd, "Width")]);
+  }
+
+  // Apply margin
+  if (withMargin) {
+    size += parseFloat(style["margin".concat(axisStart)]) + parseFloat(style["margin".concat(axisEnd)]);
+  }
+  return size;
+}

package/esm/utils/disableScroll.js

@@ -0,0 +1,67 @@
+var getScrollingRoot = function getScrollingRoot() {
+  return document.scrollingElement || document.documentElement;
+};
+
+/**
+ * Recursively finds the scroll parent of a node. The scroll parrent of a node
+ * is the closest node that is scrollable. A node is scrollable if:
+ *  - it is allowed to scroll via CSS ('overflow-y' not visible or hidden);
+ *  - and its children/content are "bigger" than the node's box height.
+ *
+ * The root of the document always scrolls by default.
+ *
+ * @param {HTMLElement} node Any DOM element.
+ * @return {HTMLElement} The scroll parent element.
+ */
+export function getScrollParent(node) {
+  var parent = node.parentElement;
+  if (parent == null) return getScrollingRoot();
+  var _window$getComputedSt = window.getComputedStyle(parent),
+    overflowY = _window$getComputedSt.overflowY;
+  var canScroll = overflowY !== 'visible' && overflowY !== 'hidden';
+  if (canScroll && parent.scrollHeight > parent.clientHeight) {
+    return parent;
+  }
+  return getScrollParent(parent);
+}
+
+/**
+ * Recursively traverses the tree upwards from the given node, capturing all
+ * ancestor nodes that scroll along with their current 'overflow-y' CSS
+ * property.
+ *
+ * @param {HTMLElement} node Any DOM element.
+ * @param {Map<HTMLElement,string>} [acc] Accumulator map.
+ * @return {Map<HTMLElement,string>} Map of ancestors with their 'overflow-y' value.
+ */
+export function getScrollAncestorsOverflowY(node) {
+  var acc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Map();
+  var scrollingRoot = getScrollingRoot();
+  var scrollParent = getScrollParent(node);
+  acc.set(scrollParent, scrollParent.style.overflowY);
+  if (scrollParent === scrollingRoot) return acc;
+  return getScrollAncestorsOverflowY(scrollParent, acc);
+}
+
+/**
+ * Disabling the scroll on a node involves finding all the scrollable ancestors
+ * and set their 'overflow-y' CSS property to 'hidden'. When all ancestors have
+ * 'overflow-y: hidden' (up to the document element) there is no scroll
+ * container, thus all the scroll outside of the node is disabled. In order to
+ * enable scroll again, we store the previous value of the 'overflow-y' for
+ * every ancestor in a closure and reset it back.
+ *
+ * @param {HTMLElement} node Any DOM element.
+ */
+export default function disableScroll(node) {
+  var scrollAncestorsOverflowY = getScrollAncestorsOverflowY(node);
+  var toggle = function toggle(on) {
+    return scrollAncestorsOverflowY.forEach(function (overflowY, ancestor) {
+      ancestor.style.setProperty('overflow-y', on ? 'hidden' : overflowY);
+    });
+  };
+  toggle(true);
+  return function () {
+    return toggle(false);
+  };
+}

package/esm/utils/getActiveElement.js

@@ -0,0 +1,3 @@
+export default function getActiveElement() {
+  return typeof document !== 'undefined' && document.activeElement;
+}

package/esm/utils/getCalendarDaySettings.js

@@ -0,0 +1,48 @@
+import getPhrase from './getPhrase';
+import { BLOCKED_MODIFIER } from '../constants';
+function isSelected(modifiers) {
+  return modifiers.has('selected') || modifiers.has('selected-span') || modifiers.has('selected-start') || modifiers.has('selected-end');
+}
+function shouldUseDefaultCursor(modifiers) {
+  return modifiers.has('blocked-minimum-nights') || modifiers.has('blocked-calendar') || modifiers.has('blocked-out-of-range');
+}
+function isHoveredSpan(modifiers) {
+  if (isSelected(modifiers)) return false;
+  return modifiers.has('hovered-span') || modifiers.has('after-hovered-start') || modifiers.has('before-hovered-end');
+}
+function getAriaLabel(phrases, modifiers, day, ariaLabelFormat) {
+  var chooseAvailableDate = phrases.chooseAvailableDate,
+    dateIsUnavailable = phrases.dateIsUnavailable,
+    dateIsSelected = phrases.dateIsSelected,
+    dateIsSelectedAsStartDate = phrases.dateIsSelectedAsStartDate,
+    dateIsSelectedAsEndDate = phrases.dateIsSelectedAsEndDate;
+  var formattedDate = {
+    date: day.format(ariaLabelFormat)
+  };
+  if (modifiers.has('selected-start') && dateIsSelectedAsStartDate) {
+    return getPhrase(dateIsSelectedAsStartDate, formattedDate);
+  }
+  if (modifiers.has('selected-end') && dateIsSelectedAsEndDate) {
+    return getPhrase(dateIsSelectedAsEndDate, formattedDate);
+  }
+  if (isSelected(modifiers) && dateIsSelected) {
+    return getPhrase(dateIsSelected, formattedDate);
+  }
+  if (modifiers.has(BLOCKED_MODIFIER)) {
+    return getPhrase(dateIsUnavailable, formattedDate);
+  }
+  return getPhrase(chooseAvailableDate, formattedDate);
+}
+export default function getCalendarDaySettings(day, ariaLabelFormat, daySize, modifiers, phrases) {
+  return {
+    ariaLabel: getAriaLabel(phrases, modifiers, day, ariaLabelFormat),
+    hoveredSpan: isHoveredSpan(modifiers),
+    isOutsideRange: modifiers.has('blocked-out-of-range'),
+    selected: isSelected(modifiers),
+    useDefaultCursor: shouldUseDefaultCursor(modifiers),
+    daySizeStyles: {
+      width: daySize,
+      height: daySize - 1
+    }
+  };
+}

package/esm/utils/getCalendarMonthWeeks.js

@@ -0,0 +1,37 @@
+import moment from 'moment';
+import { WEEKDAYS } from '../constants';
+export default function getCalendarMonthWeeks(month, enableOutsideDays) {
+  var firstDayOfWeek = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : moment.localeData().firstDayOfWeek();
+  if (!moment.isMoment(month) || !month.isValid()) {
+    throw new TypeError('`month` must be a valid moment object');
+  }
+  if (WEEKDAYS.indexOf(firstDayOfWeek) === -1) {
+    throw new TypeError('`firstDayOfWeek` must be an integer between 0 and 6');
+  }
+
+  // set utc offset to get correct dates in future (when timezone changes)
+  var firstOfMonth = month.clone().startOf('month').hour(12);
+  var lastOfMonth = month.clone().endOf('month').hour(12);
+
+  // calculate the exact first and last days to fill the entire matrix
+  // (considering days outside month)
+  var prevDays = (firstOfMonth.day() + 7 - firstDayOfWeek) % 7;
+  var nextDays = (firstDayOfWeek + 6 - lastOfMonth.day()) % 7;
+  var firstDay = firstOfMonth.clone().subtract(prevDays, 'day');
+  var lastDay = lastOfMonth.clone().add(nextDays, 'day');
+  var totalDays = lastDay.diff(firstDay, 'days') + 1;
+  var currentDay = firstDay.clone();
+  var weeksInMonth = [];
+  for (var i = 0; i < totalDays; i += 1) {
+    if (i % 7 === 0) {
+      weeksInMonth.push([]);
+    }
+    var day = null;
+    if (i >= prevDays && i < totalDays - nextDays || enableOutsideDays) {
+      day = currentDay.clone();
+    }
+    weeksInMonth[weeksInMonth.length - 1].push(day);
+    currentDay.add(1, 'day');
+  }
+  return weeksInMonth;
+}

package/esm/utils/getCalendarMonthWidth.js

@@ -0,0 +1,4 @@
+export default function getCalendarMonthWidth(daySize) {
+  var calendarMonthPadding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  return 7 * daySize + 2 * calendarMonthPadding + 1;
+}

package/esm/utils/getDetachedContainerStyles.js

@@ -0,0 +1,36 @@
+import { OPEN_UP, ANCHOR_RIGHT } from '../constants';
+
+/**
+ * Calculate and return a CSS transform style to position a detached element
+ * next to a reference element. The open and anchor direction indicate wether
+ * it should be positioned above/below and/or to the left/right of the
+ * reference element.
+ *
+ * Assuming r(0,0), r(1,1), d(0,0), d(1,1) for the bottom-left and top-right
+ * corners of the reference and detached elements, respectively:
+ *  - openDirection = DOWN, anchorDirection = LEFT => d(0,1) == r(0,1)
+ *  - openDirection = UP, anchorDirection = LEFT => d(0,0) == r(0,0)
+ *  - openDirection = DOWN, anchorDirection = RIGHT => d(1,1) == r(1,1)
+ *  - openDirection = UP, anchorDirection = RIGHT => d(1,0) == r(1,0)
+ *
+ * By using a CSS transform, we allow to further position it using
+ * top/bottom CSS properties for the anchor gutter.
+ *
+ * @param {string} openDirection The vertical positioning of the popup
+ * @param {string} anchorDirection The horizontal position of the popup
+ * @param {HTMLElement} referenceEl The reference element
+ */
+export default function getDetachedContainerStyles(openDirection, anchorDirection, referenceEl) {
+  var referenceRect = referenceEl.getBoundingClientRect();
+  var offsetX = referenceRect.left;
+  var offsetY = referenceRect.top;
+  if (openDirection === OPEN_UP) {
+    offsetY = -(window.innerHeight - referenceRect.bottom);
+  }
+  if (anchorDirection === ANCHOR_RIGHT) {
+    offsetX = -(window.innerWidth - referenceRect.right);
+  }
+  return {
+    transform: "translate3d(".concat(Math.round(offsetX), "px, ").concat(Math.round(offsetY), "px, 0)")
+  };
+}

package/esm/utils/getInputHeight.js

@@ -0,0 +1,42 @@
+/* eslint-disable camelcase */
+
+function getPadding(vertical, top, bottom) {
+  var isTopDefined = typeof top === 'number';
+  var isBottomDefined = typeof bottom === 'number';
+  var isVerticalDefined = typeof vertical === 'number';
+  if (isTopDefined && isBottomDefined) {
+    return top + bottom;
+  }
+  if (isTopDefined && isVerticalDefined) {
+    return top + vertical;
+  }
+  if (isTopDefined) {
+    return top;
+  }
+  if (isBottomDefined && isVerticalDefined) {
+    return bottom + vertical;
+  }
+  if (isBottomDefined) {
+    return bottom;
+  }
+  if (isVerticalDefined) {
+    return 2 * vertical;
+  }
+  return 0;
+}
+export default function getInputHeight(_ref, small) {
+  var _ref$font$input = _ref.font.input,
+    lineHeight = _ref$font$input.lineHeight,
+    lineHeight_small = _ref$font$input.lineHeight_small,
+    _ref$spacing = _ref.spacing,
+    inputPadding = _ref$spacing.inputPadding,
+    displayTextPaddingVertical = _ref$spacing.displayTextPaddingVertical,
+    displayTextPaddingTop = _ref$spacing.displayTextPaddingTop,
+    displayTextPaddingBottom = _ref$spacing.displayTextPaddingBottom,
+    displayTextPaddingVertical_small = _ref$spacing.displayTextPaddingVertical_small,
+    displayTextPaddingTop_small = _ref$spacing.displayTextPaddingTop_small,
+    displayTextPaddingBottom_small = _ref$spacing.displayTextPaddingBottom_small;
+  var calcLineHeight = small ? lineHeight_small : lineHeight;
+  var padding = small ? getPadding(displayTextPaddingVertical_small, displayTextPaddingTop_small, displayTextPaddingBottom_small) : getPadding(displayTextPaddingVertical, displayTextPaddingTop, displayTextPaddingBottom);
+  return parseInt(calcLineHeight, 10) + 2 * inputPadding + padding;
+}

package/esm/utils/getNumberOfCalendarMonthWeeks.js

@@ -0,0 +1,11 @@
+import moment from 'moment';
+function getBlankDaysBeforeFirstDay(firstDayOfMonth, firstDayOfWeek) {
+  var weekDayDiff = firstDayOfMonth.day() - firstDayOfWeek;
+  return (weekDayDiff + 7) % 7;
+}
+export default function getNumberOfCalendarMonthWeeks(month) {
+  var firstDayOfWeek = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : moment.localeData().firstDayOfWeek();
+  var firstDayOfMonth = month.clone().startOf('month').hour(12);
+  var numBlankDays = getBlankDaysBeforeFirstDay(firstDayOfMonth, firstDayOfWeek);
+  return Math.ceil((numBlankDays + month.daysInMonth()) / 7);
+}

package/esm/utils/getPhrase.js

@@ -0,0 +1,7 @@
+export default function getPhrase(phrase, args) {
+  if (typeof phrase === 'string') return phrase;
+  if (typeof phrase === 'function') {
+    return phrase(args);
+  }
+  return '';
+}

package/esm/utils/getPhrasePropTypes.js

@@ -0,0 +1,9 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import PropTypes from 'prop-types';
+export default function getPhrasePropTypes(defaultPhrases) {
+  return Object.keys(defaultPhrases).reduce(function (phrases, key) {
+    return _objectSpread(_objectSpread({}, phrases), {}, _defineProperty({}, key, PropTypes.oneOfType([PropTypes.string, PropTypes.func, PropTypes.node])));
+  }, {});
+}

package/esm/utils/getPooledMoment.js

@@ -0,0 +1,8 @@
+import moment from 'moment';
+var momentPool = new Map();
+export default function getPooledMoment(dayString) {
+  if (!momentPool.has(dayString)) {
+    momentPool.set(dayString, moment(dayString));
+  }
+  return momentPool.get(dayString);
+}

package/esm/utils/getPreviousMonthMemoLast.js

@@ -0,0 +1,9 @@
+var getPreviousMonthMemoKey;
+var getPreviousMonthMemoValue;
+export default function getPreviousMonthMemoLast(month) {
+  if (month !== getPreviousMonthMemoKey) {
+    getPreviousMonthMemoKey = month;
+    getPreviousMonthMemoValue = month.clone().subtract(1, 'month');
+  }
+  return getPreviousMonthMemoValue;
+}

package/esm/utils/getResponsiveContainerStyles.js

@@ -0,0 +1,8 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { ANCHOR_LEFT } from '../constants';
+export default function getResponsiveContainerStyles(anchorDirection, currentOffset, containerEdge, margin) {
+  var windowWidth = typeof window !== 'undefined' ? window.innerWidth : 0;
+  var calculatedOffset = anchorDirection === ANCHOR_LEFT ? windowWidth - containerEdge : containerEdge;
+  var calculatedMargin = margin || 0;
+  return _defineProperty({}, anchorDirection, Math.min(currentOffset + calculatedOffset - calculatedMargin, 0));
+}

package/esm/utils/getSelectedDateOffset.js

@@ -0,0 +1,8 @@
+var defaultModifier = function defaultModifier(day) {
+  return day;
+};
+export default function getSelectedDateOffset(fn, day) {
+  var modifier = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultModifier;
+  if (!fn) return day;
+  return modifier(fn(day.clone()));
+}

package/esm/utils/getTransformStyles.js

@@ -0,0 +1,8 @@
+export default function getTransformStyles(transformValue) {
+  return {
+    transform: transformValue,
+    msTransform: transformValue,
+    MozTransform: transformValue,
+    WebkitTransform: transformValue
+  };
+}

package/esm/utils/getVisibleDays.js

@@ -0,0 +1,42 @@
+import moment from 'moment';
+import toISOMonthString from './toISOMonthString';
+export default function getVisibleDays(month, numberOfMonths, enableOutsideDays, withoutTransitionMonths) {
+  if (!moment.isMoment(month)) return {};
+  var visibleDaysByMonth = {};
+  var currentMonth = withoutTransitionMonths ? month.clone() : month.clone().subtract(1, 'month');
+  for (var i = 0; i < (withoutTransitionMonths ? numberOfMonths : numberOfMonths + 2); i += 1) {
+    var visibleDays = [];
+
+    // set utc offset to get correct dates in future (when timezone changes)
+    var baseDate = currentMonth.clone();
+    var firstOfMonth = baseDate.clone().startOf('month').hour(12);
+    var lastOfMonth = baseDate.clone().endOf('month').hour(12);
+    var currentDay = firstOfMonth.clone();
+
+    // days belonging to the previous month
+    if (enableOutsideDays) {
+      for (var j = 0; j < currentDay.weekday(); j += 1) {
+        var prevDay = currentDay.clone().subtract(j + 1, 'day');
+        visibleDays.unshift(prevDay);
+      }
+    }
+    while (currentDay < lastOfMonth) {
+      visibleDays.push(currentDay.clone());
+      currentDay.add(1, 'day');
+    }
+    if (enableOutsideDays) {
+      // weekday() returns the index of the day of the week according to the locale
+      // this means if the week starts on Monday, weekday() will return 0 for a Monday date, not 1
+      if (currentDay.weekday() !== 0) {
+        // days belonging to the next month
+        for (var k = currentDay.weekday(), count = 0; k < 7; k += 1, count += 1) {
+          var nextDay = currentDay.clone().add(count, 'day');
+          visibleDays.push(nextDay);
+        }
+      }
+    }
+    visibleDaysByMonth[toISOMonthString(currentMonth)] = visibleDays;
+    currentMonth = currentMonth.clone().add(1, 'month');
+  }
+  return visibleDaysByMonth;
+}

package/esm/utils/isAfterDay.js

@@ -0,0 +1,7 @@
+import moment from 'moment';
+import isBeforeDay from './isBeforeDay';
+import isSameDay from './isSameDay';
+export default function isAfterDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  return !isBeforeDay(a, b) && !isSameDay(a, b);
+}

package/esm/utils/isBeforeDay.js

@@ -0,0 +1,13 @@
+import moment from 'moment';
+export default function isBeforeDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  var aYear = a.year();
+  var aMonth = a.month();
+  var bYear = b.year();
+  var bMonth = b.month();
+  var isSameYear = aYear === bYear;
+  var isSameMonth = aMonth === bMonth;
+  if (isSameYear && isSameMonth) return a.date() < b.date();
+  if (isSameYear) return aMonth < bMonth;
+  return aYear < bYear;
+}

package/esm/utils/isDayVisible.js

@@ -0,0 +1,38 @@
+import moment from 'moment';
+import isBeforeDay from './isBeforeDay';
+import isAfterDay from './isAfterDay';
+import toISOMonthString from './toISOMonthString';
+var startCacheOutsideDays = new Map();
+var endCacheOutsideDays = new Map();
+var startCacheInsideDays = new Map();
+var endCacheInsideDays = new Map();
+export default function isDayVisible(day, month, numberOfMonths, enableOutsideDays) {
+  if (!moment.isMoment(day)) return false;
+
+  // Cloning is a little expensive, so we want to do it as little as possible.
+
+  var startKey = toISOMonthString(month);
+  // eslint-disable-next-line prefer-template
+  var endKey = startKey + '+' + numberOfMonths;
+  if (enableOutsideDays) {
+    if (!startCacheOutsideDays.has(startKey)) {
+      startCacheOutsideDays.set(startKey, month.clone().startOf('month').startOf('week').hour(12));
+    }
+    if (isBeforeDay(day, startCacheOutsideDays.get(startKey))) return false;
+    if (!endCacheOutsideDays.has(endKey)) {
+      endCacheOutsideDays.set(endKey, month.clone().endOf('week').add(numberOfMonths - 1, 'months').endOf('month').endOf('week').hour(12));
+    }
+    return !isAfterDay(day, endCacheOutsideDays.get(endKey));
+  }
+
+  // !enableOutsideDays
+
+  if (!startCacheInsideDays.has(startKey)) {
+    startCacheInsideDays.set(startKey, month.clone().startOf('month').hour(12));
+  }
+  if (isBeforeDay(day, startCacheInsideDays.get(startKey))) return false;
+  if (!endCacheInsideDays.has(endKey)) {
+    endCacheInsideDays.set(endKey, month.clone().add(numberOfMonths - 1, 'months').endOf('month').hour(12));
+  }
+  return !isAfterDay(day, endCacheInsideDays.get(endKey));
+}

package/esm/utils/isInclusivelyAfterDay.js

@@ -0,0 +1,6 @@
+import moment from 'moment';
+import isBeforeDay from './isBeforeDay';
+export default function isInclusivelyAfterDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  return !isBeforeDay(a, b);
+}

package/esm/utils/isInclusivelyBeforeDay.js

@@ -0,0 +1,6 @@
+import moment from 'moment';
+import isAfterDay from './isAfterDay';
+export default function isInclusivelyBeforeDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  return !isAfterDay(a, b);
+}

package/esm/utils/isNextDay.js

@@ -0,0 +1,7 @@
+import moment from 'moment';
+import isSameDay from './isSameDay';
+export default function isNextDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  var nextDay = moment(a).add(1, 'day');
+  return isSameDay(nextDay, b);
+}