dayzed/preact/dist/dayzed.esm.js

Primitives to build simple, flexible, WAI-ARIA compliant React datepicker components.

import { useState } from 'preact/hooks';
import PropTypes from 'prop-types';

function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };

  return _extends.apply(this, arguments);
}

function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;

  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }

  return target;
}

function toInteger(dirtyNumber) {
  if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
    return NaN;
  }

  var number = Number(dirtyNumber);

  if (isNaN(number)) {
    return number;
  }

  return number < 0 ? Math.ceil(number) : Math.floor(number);
}

/**
 * @name toDate
 * @category Common Helpers
 * @summary Convert the given argument to an instance of Date.
 *
 * @description
 * Convert the given argument to an instance of Date.
 *
 * If the argument is an instance of Date, the function returns its clone.
 *
 * If the argument is a number, it is treated as a timestamp.
 *
 * If the argument is none of the above, the function returns Invalid Date.
 *
 * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
 *
 * @param {Date|Number} argument - the value to convert
 * @returns {Date} the parsed date in the local time zone
 * @throws {TypeError} 1 argument required
 *
 * @example
 * // Clone the date:
 * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
 * //=> Tue Feb 11 2014 11:30:30
 *
 * @example
 * // Convert the timestamp to date:
 * const result = toDate(1392098430000)
 * //=> Tue Feb 11 2014 11:30:30
 */
function toDate(argument) {
  if (arguments.length < 1) {
    throw new TypeError('1 argument required, but only ' + arguments.length + ' present');
  }

  var argStr = Object.prototype.toString.call(argument); // Clone the date

  if (argument instanceof Date || typeof argument === 'object' && argStr === '[object Date]') {
    // Prevent the date to lose the milliseconds when passed to new Date() in IE10
    return new Date(argument.getTime());
  } else if (typeof argument === 'number' || argStr === '[object Number]') {
    return new Date(argument);
  } else {
    if ((typeof argument === 'string' || argStr === '[object String]') && typeof console !== 'undefined') {
      // eslint-disable-next-line no-console
      console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as arguments. Please use `parseISO` to parse strings. See: https://git.io/fjule"); // eslint-disable-next-line no-console

      console.warn(new Error().stack);
    }

    return new Date(NaN);
  }
}

/**
 * @name addDays
 * @category Day Helpers
 * @summary Add the specified number of days to the given date.
 *
 * @description
 * Add the specified number of days to the given date.
 *
 * ### v2.0.0 breaking changes:
 *
 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
 *
 * @param {Date|Number} date - the date to be changed
 * @param {Number} amount - the amount of days to be added
 * @returns {Date} the new date with the days added
 * @throws {TypeError} 2 arguments required
 *
 * @example
 * // Add 10 days to 1 September 2014:
 * var result = addDays(new Date(2014, 8, 1), 10)
 * //=> Thu Sep 11 2014 00:00:00
 */

function addDays(dirtyDate, dirtyAmount) {
  if (arguments.length < 2) {
    throw new TypeError('2 arguments required, but only ' + arguments.length + ' present');
  }

  var date = toDate(dirtyDate);
  var amount = toInteger(dirtyAmount);
  date.setDate(date.getDate() + amount);
  return date;
}

/**
 * @name isBefore
 * @category Common Helpers
 * @summary Is the first date before the second one?
 *
 * @description
 * Is the first date before the second one?
 *
 * ### v2.0.0 breaking changes:
 *
 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
 *
 * @param {Date|Number} date - the date that should be before the other one to return true
 * @param {Date|Number} dateToCompare - the date to compare with
 * @returns {Boolean} the first date is before the second date
 * @throws {TypeError} 2 arguments required
 *
 * @example
 * // Is 10 July 1989 before 11 February 1987?
 * var result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))
 * //=> false
 */

function isBefore(dirtyDate, dirtyDateToCompare) {
  if (arguments.length < 2) {
    throw new TypeError('2 arguments required, but only ' + arguments.length + ' present');
  }

  var date = toDate(dirtyDate);
  var dateToCompare = toDate(dirtyDateToCompare);
  return date.getTime() < dateToCompare.getTime();
}

/**
 * @name startOfDay
 * @category Day Helpers
 * @summary Return the start of a day for the given date.
 *
 * @description
 * Return the start of a day for the given date.
 * The result will be in the local timezone.
 *
 * ### v2.0.0 breaking changes:
 *
 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
 *
 * @param {Date|Number} date - the original date
 * @returns {Date} the start of a day
 * @throws {TypeError} 1 argument required
 *
 * @example
 * // The start of a day for 2 September 2014 11:55:00:
 * var result = startOfDay(new Date(2014, 8, 2, 11, 55, 0))
 * //=> Tue Sep 02 2014 00:00:00
 */

function startOfDay(dirtyDate) {
  if (arguments.length < 1) {
    throw new TypeError('1 argument required, but only ' + arguments.length + ' present');
  }

  var date = toDate(dirtyDate);
  date.setHours(0, 0, 0, 0);
  return date;
}

/**
 * @name isSameDay
 * @category Day Helpers
 * @summary Are the given dates in the same day?
 *
 * @description
 * Are the given dates in the same day?
 *
 * ### v2.0.0 breaking changes:
 *
 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
 *
 * @param {Date|Number} dateLeft - the first date to check
 * @param {Date|Number} dateRight - the second date to check
 * @returns {Boolean} the dates are in the same day
 * @throws {TypeError} 2 arguments required
 *
 * @example
 * // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day?
 * var result = isSameDay(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 18, 0))
 * //=> true
 */

function isSameDay(dirtyDateLeft, dirtyDateRight) {
  if (arguments.length < 2) {
    throw new TypeError('2 arguments required, but only ' + arguments.length + ' present');
  }

  var dateLeftStartOfDay = startOfDay(dirtyDateLeft);
  var dateRightStartOfDay = startOfDay(dirtyDateRight);
  return dateLeftStartOfDay.getTime() === dateRightStartOfDay.getTime();
}

/**
 * @name isToday
 * @category Day Helpers
 * @summary Is the given date today?
 * @pure false
 *
 * @description
 * Is the given date today?
 *
 * > ⚠️ Please note that this function is not present in the FP submodule as
 * > it uses `Date.now()` internally hence impure and can't be safely curried.
 *
 * ### v2.0.0 breaking changes:
 *
 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
 *
 * @param {Date|Number} date - the date to check
 * @returns {Boolean} the date is today
 * @throws {TypeError} 1 argument required
 *
 * @example
 * // If today is 6 October 2014, is 6 October 14:00:00 today?
 * var result = isToday(new Date(2014, 9, 6, 14, 0))
 * //=> true
 */

function isToday(dirtyDate) {
  if (arguments.length < 1) {
    throw new TypeError('1 argument required, but only ' + arguments.length + ' present');
  }

  return isSameDay(dirtyDate, Date.now());
}

/**
 * @name differenceInCalendarMonths
 * @category Month Helpers
 * @summary Get the number of calendar months between the given dates.
 *
 * @description
 * Get the number of calendar months between the given dates.
 *
 * ### v2.0.0 breaking changes:
 *
 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
 *
 * @param {Date|Number} dateLeft - the later date
 * @param {Date|Number} dateRight - the earlier date
 * @returns {Number} the number of calendar months
 * @throws {TypeError} 2 arguments required
 *
 * @example
 * // How many calendar months are between 31 January 2014 and 1 September 2014?
 * var result = differenceInCalendarMonths(
 *   new Date(2014, 8, 1),
 *   new Date(2014, 0, 31)
 * )
 * //=> 8
 */

function differenceInCalendarMonths(dirtyDateLeft, dirtyDateRight) {
  if (arguments.length < 2) {
    throw new TypeError('2 arguments required, but only ' + arguments.length + ' present');
  }

  var dateLeft = toDate(dirtyDateLeft);
  var dateRight = toDate(dirtyDateRight);
  var yearDiff = dateLeft.getFullYear() - dateRight.getFullYear();
  var monthDiff = dateLeft.getMonth() - dateRight.getMonth();
  return yearDiff * 12 + monthDiff;
}

/**
 * This is intended to be used to compose event handlers
 * They are executed in order until one of them calls
 * `event.preventDefault()`. Not sure this is the best
 * way to do this, but it seems legit...
 * @param {Function} fns the event hanlder functions
 * @return {Function} the event handler to add to an element
 */

function composeEventHandlers() {
  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
    fns[_key] = arguments[_key];
  }

  return function (event) {
    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
      args[_key2 - 1] = arguments[_key2];
    }

    return fns.some(function (fn) {
      fn && fn.apply(void 0, [event].concat(args));
      return event.defaultPrevented;
    });
  };
}
/**
 * Throws a helpful error message for required properties. Useful
 * to be used as a default in destructuring or object params.
 * @param {String} fnName the function name
 * @param {String} propName the prop name
 */

function requiredProp(fnName, propName) {
  throw new Error("The property \"" + propName + "\" is required in \"" + fnName + "\"");
}
/**
 * Takes an argument and if it's an array, returns the first item in the array
 * otherwise returns the argument.
 * @param {*} arg the maybe-array
 * @return {*} the arg or it's first item
 */

function unwrapChildrenForPreact(arg) {
  arg = Array.isArray(arg) ?
  /* istanbul ignore next (preact) */
  arg[0] : arg;
  return arg || noop;
}

function noop() {}
/**
 * Takes a calendars array and figures out the number of months to subtract
 * based on the current offset and the minDate allowed.
 * @param {Object} param The param object
 * @param {Array} param.calendars The calendars array created by the getCalendars function
 * @param {Number} param.offset The num of months to be subtracted
 * @param {Date} param.minDate The earliest date we are allow to subtract back to
 * @returns {Number} The number of months to subtract
 */


function subtractMonth(_ref) {
  var calendars = _ref.calendars,
      offset = _ref.offset,
      minDate = _ref.minDate;

  if (offset > 1 && minDate) {
    var firstDayOfMonth = calendars[0].firstDayOfMonth;
    var diffInMonths = differenceInCalendarMonths(firstDayOfMonth, minDate);

    if (diffInMonths < offset) {
      offset = diffInMonths;
    }
  }

  return offset;
}
/**
 * Takes a calendars array and figures out the number of months to add
 * based on the current offset and the maxDate allowed.
 * @param {Object} param The param object
 * @param {Array} param.calendars The calendars array created by the getCalendars function
 * @param {Number} param.offset The num of months to be added
 * @param {Date} param.maxDate The furthest date we are allow to add forward to
 * @returns {Number} The number of months to add
 */

function addMonth(_ref2) {
  var calendars = _ref2.calendars,
      offset = _ref2.offset,
      maxDate = _ref2.maxDate;

  if (offset > 1 && maxDate) {
    var lastDayOfMonth = calendars[calendars.length - 1].lastDayOfMonth;
    var diffInMonths = differenceInCalendarMonths(maxDate, lastDayOfMonth);

    if (diffInMonths < offset) {
      offset = diffInMonths;
    }
  }

  return offset;
}
/**
 * Takes a calendars array and figures out if the back button should be
 * disabled based on the minDate allowed.
 * @param {Object} param The param object
 * @param {Array} param.calendars The calendars array created by the getCalendars function
 * @param {Date} param.minDate The earliest date available
 * @returns {Boolean} Whether the back button should be disabled.
 */

function isBackDisabled(_ref3) {
  var calendars = _ref3.calendars,
      minDate = _ref3.minDate;

  if (!minDate) {
    return false;
  }

  var firstDayOfMonth = calendars[0].firstDayOfMonth;
  var firstDayOfMonthMinusOne = addDays(firstDayOfMonth, -1);

  if (isBefore(firstDayOfMonthMinusOne, minDate)) {
    return true;
  }

  return false;
}
/**
 * Takes a calendars array and figures out if the forward button should be
 * disabled based on the maxDate allowed.
 * @param {Object} param The param object
 * @param {Array} param.calendars The calendars array created by the getCalendars function
 * @param {Date} param.maxDate The furthest date available
 * @returns {Boolean} Whether the forward button should be disabled.
 */

function isForwardDisabled(_ref4) {
  var calendars = _ref4.calendars,
      maxDate = _ref4.maxDate;

  if (!maxDate) {
    return false;
  }

  var lastDayOfMonth = calendars[calendars.length - 1].lastDayOfMonth;
  var lastDayOfMonthPlusOne = addDays(lastDayOfMonth, 1);

  if (isBefore(maxDate, lastDayOfMonthPlusOne)) {
    return true;
  }

  return false;
}
/**
 * Figures out the months data needed based off the number of monthsToDisplay
 * and other options provided.
 * @param {Object} param The param object
 * @param {Date} param.date The date to start the calendar at
 * @param {Array.<Date>} param.selected An array of dates currently selected
 * @param {Number} param.monthsToDisplay The number of months to return in the calendar view
 * @param {Number} param.offset The number of months to offset based off the param.date given
 * @param {Date} param.minDate The earliest date available
 * @param {Date} param.maxDate The furthest date available
 * @param {Number} param.firstDayOfWeek First day of week, 0-6 (Sunday to Saturday)
 * @param {Bool} param.showOutsideDays Flag to fill front and back weeks with dates from adjacent months
 * @returns {Array.<Object>} An array of objects with month data
 */

function getCalendars(_ref5) {
  var date = _ref5.date,
      selected = _ref5.selected,
      monthsToDisplay = _ref5.monthsToDisplay,
      offset = _ref5.offset,
      minDate = _ref5.minDate,
      maxDate = _ref5.maxDate,
      firstDayOfWeek = _ref5.firstDayOfWeek,
      showOutsideDays = _ref5.showOutsideDays;
  var months = [];
  var startDate = getStartDate(date, minDate, maxDate);

  for (var i = 0; i < monthsToDisplay; i++) {
    var calendarDates = getMonths({
      month: startDate.getMonth() + i + offset,
      year: startDate.getFullYear(),
      selectedDates: selected,
      minDate: minDate,
      maxDate: maxDate,
      firstDayOfWeek: firstDayOfWeek,
      showOutsideDays: showOutsideDays
    });
    months.push(calendarDates);
  }

  return months;
}
/**
 * Figures out the actual start date based on
 * the min and max dates available.
 * @param {Date} date The we want to start the calendar at
 * @param {Date} minDate The earliest date available to start at
 * @param {Date} maxDate The latest date available to start at
 * @returns {Date} The actual start date
 */

function getStartDate(date, minDate, maxDate) {
  var startDate = startOfDay(date);

  if (minDate) {
    var minDateNormalized = startOfDay(minDate);

    if (isBefore(startDate, minDateNormalized)) {
      startDate = minDateNormalized;
    }
  }

  if (maxDate) {
    var maxDateNormalized = startOfDay(maxDate);

    if (isBefore(maxDateNormalized, startDate)) {
      startDate = maxDateNormalized;
    }
  }

  return startDate;
}
/**
 * Figures what week/day data to return for the given month
 * and year. Adds flags to day data if found in the given selectedDates,
 * if is selectable inside the given min and max dates, or is today.
 * @param {Object} param The param object
 * @param {Number} param.month The month to grab data for
 * @param {Number} param.year The year to grab data for
 * @param {Array.<Date>} sparam.electedDates An array of dates currently selected
 * @param {Date} param.minDate The earliest date available
 * @param {Date} param.maxDate The furthest date available
 * @param {Number} param.firstDayOfWeek First day of week, 0-6 (Sunday to Saturday)
 * @param {Bool} param.showOutsideDays Flag to fill front and back weeks with dates from adjacent months
 * @returns {Object} The data for the selected month/year
 */


function getMonths(_ref6) {
  var month = _ref6.month,
      year = _ref6.year,
      selectedDates = _ref6.selectedDates,
      minDate = _ref6.minDate,
      maxDate = _ref6.maxDate,
      firstDayOfWeek = _ref6.firstDayOfWeek,
      showOutsideDays = _ref6.showOutsideDays;
  // Get the normalized month and year, along with days in the month.
  var daysMonthYear = getNumDaysMonthYear(month, year);
  var daysInMonth = daysMonthYear.daysInMonth;
  month = daysMonthYear.month;
  year = daysMonthYear.year; // Fill out the dates for the month.

  var dates = [];

  for (var day = 1; day <= daysInMonth; day++) {
    var date = new Date(year, month, day);
    var dateObj = {
      date: date,
      selected: isSelected(selectedDates, date),
      selectable: isSelectable(minDate, maxDate, date),
      today: isToday(date),
      prevMonth: false,
      nextMonth: false
    };
    dates.push(dateObj);
  }

  var firstDayOfMonth = new Date(year, month, 1);
  var lastDayOfMonth = new Date(year, month, daysInMonth);
  var frontWeekBuffer = fillFrontWeek({
    firstDayOfMonth: firstDayOfMonth,
    minDate: minDate,
    maxDate: maxDate,
    selectedDates: selectedDates,
    firstDayOfWeek: firstDayOfWeek,
    showOutsideDays: showOutsideDays
  });
  var backWeekBuffer = fillBackWeek({
    lastDayOfMonth: lastDayOfMonth,
    minDate: minDate,
    maxDate: maxDate,
    selectedDates: selectedDates,
    firstDayOfWeek: firstDayOfWeek,
    showOutsideDays: showOutsideDays
  });
  dates.unshift.apply(dates, frontWeekBuffer);
  dates.push.apply(dates, backWeekBuffer); // Get the filled out weeks for the
  // given dates.

  var weeks = getWeeks(dates); // return the calendar data.

  return {
    firstDayOfMonth: firstDayOfMonth,
    lastDayOfMonth: lastDayOfMonth,
    month: month,
    year: year,
    weeks: weeks
  };
}
/**
 * Fill front week with either empty buffer or dates from previous month,
 * depending on showOutsideDays flag
 * @param {Object} param The param object
 * @param {Array.<Date>} param.selectedDates An array of dates currently selected
 * @param {Date} param.minDate The earliest date available
 * @param {Date} param.maxDate The furthest date available
 * @param {Date} param.firstDayOfMonth First day of the month
 * @param {Number} param.firstDayOfWeek First day of week, 0-6 (Sunday to Saturday)
 * @param {Bool} param.showOutsideDays Flag to fill front and back weeks with dates from adjacent months
 * @returns {Array.<Date>} Buffer to fill front week
 */


function fillFrontWeek(_ref7) {
  var firstDayOfMonth = _ref7.firstDayOfMonth,
      minDate = _ref7.minDate,
      maxDate = _ref7.maxDate,
      selectedDates = _ref7.selectedDates,
      firstDayOfWeek = _ref7.firstDayOfWeek,
      showOutsideDays = _ref7.showOutsideDays;
  var dates = [];
  var firstDay = (firstDayOfMonth.getDay() + 7 - firstDayOfWeek) % 7;

  if (showOutsideDays) {
    var lastDayOfPrevMonth = addDays(firstDayOfMonth, -1);
    var prevDate = lastDayOfPrevMonth.getDate();
    var prevDateMonth = lastDayOfPrevMonth.getMonth();
    var prevDateYear = lastDayOfPrevMonth.getFullYear(); // Fill out front week for days from
    // preceding month with dates from previous month.

    var counter = 0;

    while (counter < firstDay) {
      var date = new Date(prevDateYear, prevDateMonth, prevDate - counter);
      var dateObj = {
        date: date,
        selected: isSelected(selectedDates, date),
        selectable: isSelectable(minDate, maxDate, date),
        today: false,
        prevMonth: true,
        nextMonth: false
      };
      dates.unshift(dateObj);
      counter++;
    }
  } else {
    // Fill out front week for days from
    // preceding month with buffer.
    while (firstDay > 0) {
      dates.unshift('');
      firstDay--;
    }
  }

  return dates;
}
/**
 * Fill back weeks with either empty buffer or dates from next month,
 * depending on showOutsideDays flag
 * @param {Object} param The param object
 * @param {Array.<Date>} param.selectedDates An array of dates currently selected
 * @param {Date} param.minDate The earliest date available
 * @param {Date} param.maxDate The furthest date available
 * @param {Date} param.lastDayOfMonth Last day of the month
 * @param {Number} param.firstDayOfWeek First day of week, 0-6 (Sunday to Saturday)
 * @param {Bool} param.showOutsideDays Flag to fill front and back weeks with dates from adjacent months
 * @returns {Array.<Date>} Buffer to fill back week
 */


function fillBackWeek(_ref8) {
  var lastDayOfMonth = _ref8.lastDayOfMonth,
      minDate = _ref8.minDate,
      maxDate = _ref8.maxDate,
      selectedDates = _ref8.selectedDates,
      firstDayOfWeek = _ref8.firstDayOfWeek,
      showOutsideDays = _ref8.showOutsideDays;
  var dates = [];
  var lastDay = (lastDayOfMonth.getDay() + 7 - firstDayOfWeek) % 7;

  if (showOutsideDays) {
    var firstDayOfNextMonth = addDays(lastDayOfMonth, 1);
    var nextDateMonth = firstDayOfNextMonth.getMonth();
    var nextDateYear = firstDayOfNextMonth.getFullYear(); // Fill out back week for days from
    // following month with dates from next month.

    var counter = 0;

    while (counter < 6 - lastDay) {
      var date = new Date(nextDateYear, nextDateMonth, 1 + counter);
      var dateObj = {
        date: date,
        selected: isSelected(selectedDates, date),
        selectable: isSelectable(minDate, maxDate, date),
        today: false,
        prevMonth: false,
        nextMonth: true
      };
      dates.push(dateObj);
      counter++;
    }
  } else {
    // Fill out back week for days from
    // following month with buffer.
    while (lastDay < 6) {
      dates.push('');
      lastDay++;
    }
  }

  return dates;
}
/**
 * Normalizes month (could be overflow) and year pairs and returns the
 * normalized month and year along with the number of days in the month.
 * @param {Number} month The month to normalize
 * @param {Number} year The year to normalize
 * @returns {Object} The normalized month and year along with the number of days in the month
 */


function getNumDaysMonthYear(month, year) {
  // If a parameter you specify is outside of the expected range for Month or Day,
  // JS Date attempts to update the date information in the Date object accordingly!
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMonth
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setDate
  // Let Date handle the overflow of the month,
  // which should return the normalized month and year.
  var normalizedMonthYear = new Date(year, month, 1);
  month = normalizedMonthYear.getMonth();
  year = normalizedMonthYear.getFullYear(); // Overflow the date to the next month, then subtract the difference
  // to get the number of days in the previous month.
  // This will also account for leap years!

  var daysInMonth = 32 - new Date(year, month, 32).getDate();
  return {
    daysInMonth: daysInMonth,
    month: month,
    year: year
  };
}
/**
 * Takes an array of dates, and turns them into a multi dimensional
 * array with 7 entries for each week.
 * @param {Array.<Object>} dates An array of dates
 * @returns {Array} The weeks as a multi dimensional array
 */


function getWeeks(dates) {
  var weeksLength = Math.ceil(dates.length / 7);
  var weeks = [];

  for (var i = 0; i < weeksLength; i++) {
    weeks[i] = [];

    for (var x = 0; x < 7; x++) {
      weeks[i].push(dates[i * 7 + x]);
    }
  }

  return weeks;
}
/**
 * Normalizes dates to the beginning of the day,
 * then checks to see if the day given is found
 * in the selectedDates.
 * @param {Array.<Date>} selectedDates An array of dates currently selected
 * @param {Date} date The date to search with against selectedDates
 * @returns {Boolean} Whether day is found in selectedDates
 */


function isSelected(selectedDates, date) {
  selectedDates = Array.isArray(selectedDates) ? selectedDates : [selectedDates];
  return selectedDates.some(function (selectedDate) {
    if (selectedDate instanceof Date && startOfDay(selectedDate).getTime() === startOfDay(date).getTime()) {
      return true;
    }

    return false;
  });
}
/**
 * Checks to see if the date given is
 * between the min and max dates.
 * @param {Date} minDate The earliest date available
 * @param {Date} maxDate The furthest date available
 * @param {Date} date The date to compare with
 * @returns {Boolean} Whether the date is between min and max date
 */


function isSelectable(minDate, maxDate, date) {
  if (minDate && isBefore(date, minDate) || maxDate && isBefore(maxDate, date)) {
    return false;
  }

  return true;
}

function isOffsetControlled(propOffset) {
  return propOffset !== undefined;
}

function getOffset(prop, state) {
  return isOffsetControlled(prop) ? prop : state;
}

function getDateProps(onDateSelected, _temp) {
  var _ref = _temp === void 0 ? {} : _temp,
      onClick = _ref.onClick,
      _ref$dateObj = _ref.dateObj,
      dateObj = _ref$dateObj === void 0 ? requiredProp('getDateProps', 'dateObj') : _ref$dateObj,
      rest = _objectWithoutPropertiesLoose(_ref, ["onClick", "dateObj"]);

  return _extends({
    onClick: composeEventHandlers(onClick, function (event) {
      onDateSelected(dateObj, event);
    }),
    disabled: !dateObj.selectable,
    'aria-label': dateObj.date.toDateString(),
    'aria-pressed': dateObj.selected,
    role: 'button'
  }, rest);
}

function getBackProps(_ref2, _temp2) {
  var minDate = _ref2.minDate,
      offsetMonth = _ref2.offsetMonth,
      handleOffsetChanged = _ref2.handleOffsetChanged;

  var _ref3 = _temp2 === void 0 ? {} : _temp2,
      onClick = _ref3.onClick,
      _ref3$offset = _ref3.offset,
      offset = _ref3$offset === void 0 ? 1 : _ref3$offset,
      _ref3$calendars = _ref3.calendars,
      calendars = _ref3$calendars === void 0 ? requiredProp('getBackProps', 'calendars') : _ref3$calendars,
      rest = _objectWithoutPropertiesLoose(_ref3, ["onClick", "offset", "calendars"]);

  return _extends({
    onClick: composeEventHandlers(onClick, function () {
      handleOffsetChanged(offsetMonth - subtractMonth({
        calendars: calendars,
        offset: offset,
        minDate: minDate
      }));
    }),
    disabled: isBackDisabled({
      calendars: calendars,
      offset: offset,
      minDate: minDate
    }),
    'aria-label': "Go back " + offset + " month" + (offset === 1 ? '' : 's')
  }, rest);
}

function getForwardProps(_ref4, _temp3) {
  var maxDate = _ref4.maxDate,
      offsetMonth = _ref4.offsetMonth,
      handleOffsetChanged = _ref4.handleOffsetChanged;

  var _ref5 = _temp3 === void 0 ? {} : _temp3,
      onClick = _ref5.onClick,
      _ref5$offset = _ref5.offset,
      offset = _ref5$offset === void 0 ? 1 : _ref5$offset,
      _ref5$calendars = _ref5.calendars,
      calendars = _ref5$calendars === void 0 ? requiredProp('getForwardProps', 'calendars') : _ref5$calendars,
      rest = _objectWithoutPropertiesLoose(_ref5, ["onClick", "offset", "calendars"]);

  return _extends({
    onClick: composeEventHandlers(onClick, function () {
      handleOffsetChanged(offsetMonth + addMonth({
        calendars: calendars,
        offset: offset,
        maxDate: maxDate
      }));
    }),
    disabled: isForwardDisabled({
      calendars: calendars,
      offset: offset,
      maxDate: maxDate
    }),
    'aria-label': "Go forward " + offset + " month" + (offset === 1 ? '' : 's')
  }, rest);
}

function useDayzed(_ref6) {
  var _ref6$date = _ref6.date,
      date = _ref6$date === void 0 ? new Date() : _ref6$date,
      maxDate = _ref6.maxDate,
      minDate = _ref6.minDate,
      _ref6$monthsToDisplay = _ref6.monthsToDisplay,
      monthsToDisplay = _ref6$monthsToDisplay === void 0 ? 1 : _ref6$monthsToDisplay,
      _ref6$firstDayOfWeek = _ref6.firstDayOfWeek,
      firstDayOfWeek = _ref6$firstDayOfWeek === void 0 ? 0 : _ref6$firstDayOfWeek,
      _ref6$showOutsideDays = _ref6.showOutsideDays,
      showOutsideDays = _ref6$showOutsideDays === void 0 ? false : _ref6$showOutsideDays,
      offset = _ref6.offset,
      onDateSelected = _ref6.onDateSelected,
      _ref6$onOffsetChanged = _ref6.onOffsetChanged,
      onOffsetChanged = _ref6$onOffsetChanged === void 0 ? function () {} : _ref6$onOffsetChanged,
      selected = _ref6.selected;

  var _useState = useState(0),
      stateOffset = _useState[0],
      setStateOffset = _useState[1];

  var offsetMonth = getOffset(offset, stateOffset);

  function handleOffsetChanged(newOffset) {
    if (!isOffsetControlled(offset)) {
      setStateOffset(newOffset);
    }

    onOffsetChanged(newOffset);
  }

  var calendars = getCalendars({
    date: date,
    selected: selected,
    monthsToDisplay: monthsToDisplay,
    minDate: minDate,
    maxDate: maxDate,
    offset: offsetMonth,
    firstDayOfWeek: firstDayOfWeek,
    showOutsideDays: showOutsideDays
  });
  return {
    calendars: calendars,
    getDateProps: getDateProps.bind(null, onDateSelected),
    getBackProps: getBackProps.bind(null, {
      minDate: minDate,
      offsetMonth: offsetMonth,
      handleOffsetChanged: handleOffsetChanged
    }),
    getForwardProps: getForwardProps.bind(null, {
      maxDate: maxDate,
      offsetMonth: offsetMonth,
      handleOffsetChanged: handleOffsetChanged
    })
  };
}

function Dayzed(props) {
  var dayzedCalendar = useDayzed(props);
  var children = unwrapChildrenForPreact(props.render || props.children);
  return children(dayzedCalendar);
}

Dayzed.defaultProps = {
  date: new Date(),
  monthsToDisplay: 1,
  onOffsetChanged: function onOffsetChanged() {},
  firstDayOfWeek: 0,
  showOutsideDays: false
};
Dayzed.propTypes = {
  render: PropTypes.func,
  children: PropTypes.func,
  date: PropTypes.instanceOf(Date),
  maxDate: PropTypes.instanceOf(Date),
  minDate: PropTypes.instanceOf(Date),
  monthsToDisplay: PropTypes.number,
  firstDayOfWeek: PropTypes.number,
  showOutsideDays: PropTypes.bool,
  offset: PropTypes.number,
  onDateSelected: PropTypes.func.isRequired,
  onOffsetChanged: PropTypes.func,
  selected: PropTypes.oneOfType([PropTypes.arrayOf(Date), PropTypes.instanceOf(Date)])
};

export default Dayzed;
export { useDayzed };