repick-core/dist/repick-core.esm.js

import compareAsc from 'date-fns/compareAsc';
import format from 'date-fns/format';
import isValid from 'date-fns/isValid';
import startOfToday from 'date-fns/startOfToday';
import parseDate from 'date-fns/parse';
import isSameDay from 'date-fns/isSameDay';
import addDays from 'date-fns/addDays';
import addMonths from 'date-fns/addMonths';
import getDate from 'date-fns/getDate';
import getWeek from 'date-fns/getWeek';
import isSameMonth from 'date-fns/isSameMonth';
import startOfMonth from 'date-fns/startOfMonth';
import startOfWeek from 'date-fns/startOfWeek';
import subMonths from 'date-fns/subMonths';
import isAfter from 'date-fns/isAfter';
import isBefore from 'date-fns/isBefore';
import setDay from 'date-fns/setDay';
import addYears from 'date-fns/addYears';
import subDays from 'date-fns/subDays';
import subYears from 'date-fns/subYears';
import isWithinInterval from 'date-fns/isWithinInterval';

var actionBlur = 'Blur';
var actionCloseCalendar = 'CloseCalendar';
var actionDateClick = 'DateClick';
var actionEndOfWeek = 'EndOfWeek';
var actionInputBlur = 'InputBlur';
var actionInputChange = 'InputChange';
var actionInputFocus = 'InputFocus';
var actionInputKeyArrowDown = 'InputKeyArrowDown';
var actionInputKeyEnter = 'InputKeyEnter';
var actionKeyArrowDown = 'KeyArrowDown';
var actionKeyArrowLeft = 'KeyArrowLeft';
var actionKeyArrowRight = 'KeyArrowRight';
var actionKeyArrowUp = 'KeyArrowUp';
var actionKeyEnd = 'KeyEnd';
var actionKeyEnter = 'KeyEnter';
var actionKeyEscape = 'KeyEscape';
var actionKeyHome = 'KeyHome';
var actionKeyPageDown = 'KeyPageDown';
var actionKeyPageUp = 'KeyPageUp';
var actionKeyShiftPageDown = 'KeyShiftPageDown';
var actionKeyShiftPageUp = 'KeyShiftPageUp';
var actionNextDay = 'NextDay';
var actionNextMonth = 'NextMonth';
var actionNextWeek = 'NextWeek';
var actionNextYear = 'NextYear';
var actionOpenCalendar = 'OpenCalendar';
var actionPrevDay = 'PrevDay';
var actionPrevMonth = 'PrevMonth';
var actionPrevWeek = 'PrevWeek';
var actionPrevYear = 'PrevYear';
var actionSelectDate = 'SelectDate';
var actionSelectHighlighted = 'SelectHighlighted';
var actionStartOfWeek = 'StartOfWeek';

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);
}

var defaultOptions = {
  allowInput: false,
  format: 'yyyy-MM-dd',
  monthCount: 1,
  weekStartsOn: 0
};
var arrayGenerate = function arrayGenerate(arrayLength, fn) {
  return Array.apply(null, Array(arrayLength)).map(function (_, i) {
    return fn(i);
  });
};
var wrap = function wrap(min, max) {
  return function (x) {
    var d = max - min;
    return ((x - min) % d + d) % d + min;
  };
};
var wrapWeekDay = /*#__PURE__*/wrap(0, 7);
function keyToAction(key) {
  switch (key) {
    case 'ArrowLeft':
      {
        return {
          type: actionKeyArrowLeft
        };
      }

    case 'ArrowRight':
      {
        return {
          type: actionKeyArrowRight
        };
      }

    case 'ArrowUp':
      {
        return {
          type: actionKeyArrowUp
        };
      }

    case 'ArrowDown':
      {
        return {
          type: actionKeyArrowDown
        };
      }

    case 'PageDown':
      {
        return {
          type: actionKeyPageDown
        };
      }

    case 'PageUp':
      {
        return {
          type: actionKeyPageUp
        };
      }

    case 'Home':
      {
        return {
          type: actionKeyHome
        };
      }

    case 'End':
      {
        return {
          type: actionKeyEnd
        };
      }

    case 'Enter':
      {
        return {
          type: actionKeyEnter
        };
      }
  }

  return null;
}
function buildWeekdays(options) {
  if (options === void 0) {
    options = {};
  }

  var date = new Date();
  return Array.apply(null, Array(7)).map(function (_, i) {
    var day = setDay(date, wrapWeekDay(i + (options.weekStartsOn || 0)));
    return {
      "long": format(day, 'iiii', {
        locale: options.locale
      }),
      "short": format(day, 'iii', {
        locale: options.locale
      })
    };
  });
}
function sort(compareFn, array) {
  var result = [].concat(array);
  result.sort(compareFn);
  return result;
}
function arrayIncludes(compareFn, array, value) {
  return array.findIndex(function (x) {
    return compareFn(x, value);
  }) !== -1;
}
function toggleValue(compareFn, orig, value) {
  var index = orig.findIndex(function (x) {
    return compareFn(x, value);
  });
  var result = [].concat(orig);

  if (index >= 0) {
    result.splice(index, 1);
  } else {
    result.push(value);
  }

  return result;
}
function compareUndefined(compareFn) {
  return function (a, b) {
    return a !== undefined && b !== undefined ? compareFn(a, b) : 0;
  };
}
function assertNever(x) {
  throw new Error('Unexpected object: ' + x);
}
var emptyFn = function emptyFn(e) {
  return function () {
    return e;
  };
};
var dateIsSelectable = function dateIsSelectable(_ref, date) {
  var enabledDates = _ref.enabledDates,
      disabledDates = _ref.disabledDates,
      minDate = _ref.minDate,
      filterDates = _ref.filterDates,
      maxDate = _ref.maxDate;
  return !(!!filterDates && typeof filterDates === 'function' && filterDates(date) || !!enabledDates && !arrayIncludes(isSameDay, enabledDates, date) || !!disabledDates && arrayIncludes(isSameDay, disabledDates, date) || !!minDate && isAfter(minDate, date) || !!maxDate && isBefore(maxDate, date));
};
var objectCopyPartial = function objectCopyPartial(keys, obj) {
  return keys.reduce(function (res, key) {
    if (obj[key] !== undefined) {
      res[key] = obj[key];
    }

    return res;
  }, {});
};

function buildCalendarDay(isSelected, extraFn) {
  return function (state, currentMonth, date, options) {
    if (options === void 0) {
      options = {};
    }

    var prevMonth = subMonths(currentMonth, 1);
    var nextMonth = addMonths(currentMonth, 1);
    return _extends({
      date: date,
      day: getDate(date),
      nextMonth: isSameMonth(nextMonth, date),
      prevMonth: isSameMonth(prevMonth, date),
      selected: isSelected(state.selected, date),
      highlighted: isSameDay(state.highlighted, date),
      disabled: !dateIsSelectable(options, date),
      today: isSameDay(new Date(), date)
    }, extraFn(state, date));
  };
}
function buildContext(buildCalendarDay) {
  return function (state, options) {
    if (options === void 0) {
      options = {};
    }

    var highlighted = state.highlighted;
    var months = arrayGenerate(options.monthCount || 1, function (monthIndex) {
      var firstDayOfMonth = startOfMonth(addMonths(highlighted, monthIndex));
      var firstWeekOfMonth = startOfWeek(firstDayOfMonth, {
        weekStartsOn: options.weekStartsOn
      });
      var weeks = arrayGenerate(6, function (weekIndex) {
        return {
          weekNumber: getWeek(addDays(firstWeekOfMonth, weekIndex * 7), {
            weekStartsOn: options.weekStartsOn
          }),
          year: highlighted.getFullYear(),
          days: arrayGenerate(7, function (dayIndex) {
            return buildCalendarDay(state, firstDayOfMonth, addDays(firstWeekOfMonth, weekIndex * 7 + dayIndex), options);
          })
        };
      });
      var days = weeks.reduce(function (x, week) {
        return [].concat(x, week.days);
      }, []);
      return {
        month: firstDayOfMonth.getMonth() + 1,
        monthLong: format(firstDayOfMonth, 'MMMM', {
          locale: options.locale
        }),
        monthShort: format(firstDayOfMonth, 'MMM', {
          locale: options.locale
        }),
        year: firstDayOfMonth.getFullYear(),
        weeks: weeks,
        days: days
      };
    });
    var weeks = months.reduce(function (x, month) {
      return [].concat(x, month.weeks);
    }, []);
    var days = weeks.reduce(function (x, week) {
      return [].concat(x, week.days);
    }, []);
    return {
      isOpen: state.isOpen,
      inputValue: state.inputValue,
      highlighted: highlighted || null,
      month: highlighted.getMonth() + 1,
      monthLong: format(highlighted, 'MMMM', {
        locale: options.locale
      }),
      monthShort: format(highlighted, 'MMM', {
        locale: options.locale
      }),
      year: highlighted.getFullYear(),
      weekdays: buildWeekdays(options),
      selected: state.selected,
      months: months,
      weeks: weeks,
      days: days
    };
  };
}

function createReducer(selectDate, defaultFormatter, defaultParser) {
  return function reducer(state, action, argOptions) {
    var options = _extends({}, defaultOptions, argOptions);

    var formatter = options.formatter || defaultFormatter;
    var parser = options.parser || defaultParser;

    function reduceSelected(state, date) {
      if (!dateIsSelectable(options, date)) {
        return {};
      }

      var _selectDate = selectDate(state.selected, date),
          selected = _selectDate[0],
          shouldClose = _selectDate[1];

      return {
        selected: selected,
        highlighted: date,
        isOpen: !shouldClose && state.isOpen,
        inputValue: formatter(selected, options.format)
      };
    }

    switch (action.type) {
      case actionInputFocus:
      case actionInputKeyArrowDown:
      case actionOpenCalendar:
        {
          return {
            isOpen: true
          };
        }

      case actionBlur:
      case actionInputBlur:
      case actionKeyEscape:
      case actionCloseCalendar:
        {
          return {
            isOpen: false
          };
        }

      case actionInputChange:
        {
          var parsedDate = parser(action.value, options.format);
          var highlighted = parsedDate ? Array.isArray(parsedDate) ? parsedDate[0] : parsedDate : state.highlighted;
          return {
            highlighted: highlighted,
            inputValue: action.value
          };
        }

      case actionInputKeyEnter:
        {
          var _parsedDate = parser(state.inputValue, options.format);

          var _highlighted = _parsedDate ? Array.isArray(_parsedDate) ? _parsedDate[0] : _parsedDate : state.highlighted;

          var selected = _parsedDate ? _parsedDate : state.selected;
          return {
            highlighted: _highlighted,
            selected: selected,
            inputValue: formatter(selected, options.format)
          };
        }

      case actionDateClick:
      case actionSelectDate:
        {
          var date = action.date instanceof Date ? action.date : new Date(action.date);
          return reduceSelected(state, date);
        }

      case actionKeyEnter:
      case actionSelectHighlighted:
        {
          return reduceSelected(state, state.highlighted);
        }

      case actionKeyArrowLeft:
      case actionPrevDay:
        {
          return {
            highlighted: subDays(state.highlighted, 1)
          };
        }

      case actionKeyArrowRight:
      case actionNextDay:
        {
          return {
            highlighted: addDays(state.highlighted, 1)
          };
        }

      case actionKeyArrowUp:
      case actionPrevWeek:
        {
          return {
            highlighted: subDays(state.highlighted, 7)
          };
        }

      case actionKeyArrowDown:
      case actionNextWeek:
        {
          return {
            highlighted: addDays(state.highlighted, 7)
          };
        }

      case actionKeyPageDown:
      case actionPrevMonth:
        {
          return {
            highlighted: subMonths(state.highlighted, 1)
          };
        }

      case actionKeyPageUp:
      case actionNextMonth:
        {
          return {
            highlighted: addMonths(state.highlighted, 1)
          };
        }

      case actionKeyHome:
      case actionStartOfWeek:
        {
          return {
            highlighted: setDay(state.highlighted, options.weekStartsOn || 0, {
              locale: options.locale,
              weekStartsOn: options.weekStartsOn
            })
          };
        }

      case actionKeyEnd:
      case actionEndOfWeek:
        {
          return {
            highlighted: setDay(state.highlighted, wrapWeekDay(options.weekStartsOn + 6), {
              locale: options.locale,
              weekStartsOn: options.weekStartsOn
            })
          };
        }

      case actionKeyShiftPageDown:
      case actionPrevYear:
        {
          return {
            highlighted: subYears(state.highlighted, 1)
          };
        }

      case actionKeyShiftPageUp:
      case actionNextYear:
        {
          return {
            highlighted: addYears(state.highlighted, 1)
          };
        }

      default:
        {
          var _ = action;
          return _;
        }
    }
  };
}

var selectDateMulti = function selectDateMulti(selected, date) {
  return [selected !== null ? sort(compareAsc, toggleValue(isSameDay, selected, date)) : [date], false];
};
var isSelectedMulti = function isSelectedMulti(selected, date) {
  return !!selected && selected.findIndex(function (x) {
    return isSameDay(x, date);
  }) >= 0;
};
var formatMulti = function formatMulti(selected, format$1) {
  return selected ? selected.map(function (date) {
    return format(date, format$1);
  }).join(', ') : '';
};
var parseMulti = function parseMulti(dateString, format) {
  var baseDate = startOfToday();
  var parsedDate = dateString.split(/,/).map(function (x) {
    return parseDate(x, format, baseDate);
  });
  return parsedDate.every(isValid) ? parsedDate : false;
};
var reducerMulti = /*#__PURE__*/createReducer(selectDateMulti, formatMulti, parseMulti);
var buildCalendarContextDayMulti = /*#__PURE__*/buildCalendarDay(isSelectedMulti, function () {
  return {};
});
var buildContextMulti = /*#__PURE__*/buildContext(buildCalendarContextDayMulti);

var selectDateRange = function selectDateRange(selected, date) {
  return selected === null || isSameDay(selected[0], date) || selected.length === 2 ? [[date], false] : [sort(compareAsc, [].concat(selected, [date])), true];
};
var formatRange = function formatRange(selected, format$1) {
  return selected ? selected[1] !== undefined ? format(selected[0], format$1) + ' - ' + format(selected[1], format$1) : format(selected[0], format$1) : '';
};
var parseRange = function parseRange(dateString, format) {
  var baseDate = startOfToday();
  var parsedDate = dateString.split('-').map(function (x) {
    return parseDate(x, format, baseDate);
  });
  return parsedDate.length <= 2 && parsedDate.every(isValid) ? parsedDate : false;
};
var reducerRange = /*#__PURE__*/createReducer(selectDateRange, formatRange, parseRange);
var isSelectedRange = function isSelectedRange(selected, date) {
  return !!selected && (selected[1] !== undefined ? isWithinInterval(date, {
    start: selected[0],
    end: selected[1]
  }) : isSameDay(date, selected[0]));
};
var buildCalendarDayRangeExtra = function buildCalendarDayRangeExtra(state, date) {
  return {
    rangeStart: !!state.selected && isSameDay(date, state.selected[0]),
    rangeEnd: !!state.selected && !!state.selected[1] && isSameDay(date, state.selected[1])
  };
};
var buildCalendarDayRange = /*#__PURE__*/buildCalendarDay(isSelectedRange, buildCalendarDayRangeExtra);
var buildContextRange = /*#__PURE__*/buildContext(buildCalendarDayRange);

var selectDateSingle = function selectDateSingle(selected, date) {
  return [selected !== null && isSameDay(selected, date) ? null : date, true];
};
var formatSingle = function formatSingle(selected, format$1) {
  return selected ? format(selected, format$1) : '';
};
var parseSingle = function parseSingle(dateString, format) {
  var parsedDate = parseDate(dateString, format, startOfToday());
  return isValid(parsedDate) ? parsedDate : false;
};
var reducerSingle = /*#__PURE__*/createReducer(selectDateSingle, formatSingle, parseSingle);
var isSelectedSingle = function isSelectedSingle(selected, date) {
  return !!selected && isSameDay(selected, date);
};
var buildCalendarDaySingle = /*#__PURE__*/buildCalendarDay(function (selected, date) {
  return !!selected && isSameDay(selected, date);
}, function () {
  return {};
});
var buildContextSingle = /*#__PURE__*/buildContext(buildCalendarDaySingle);

export { actionBlur, actionCloseCalendar, actionDateClick, actionEndOfWeek, actionInputBlur, actionInputChange, actionInputFocus, actionInputKeyArrowDown, actionInputKeyEnter, actionKeyArrowDown, actionKeyArrowLeft, actionKeyArrowRight, actionKeyArrowUp, actionKeyEnd, actionKeyEnter, actionKeyEscape, actionKeyHome, actionKeyPageDown, actionKeyPageUp, actionKeyShiftPageDown, actionKeyShiftPageUp, actionNextDay, actionNextMonth, actionNextWeek, actionNextYear, actionOpenCalendar, actionPrevDay, actionPrevMonth, actionPrevWeek, actionPrevYear, actionSelectDate, actionSelectHighlighted, actionStartOfWeek, arrayGenerate, arrayIncludes, assertNever, buildCalendarDayRange, buildCalendarDayRangeExtra, buildCalendarDaySingle, buildContextMulti, buildContextRange, buildContextSingle, buildWeekdays, compareUndefined, dateIsSelectable, defaultOptions, emptyFn, formatMulti, formatRange, formatSingle, isSelectedMulti, isSelectedRange, isSelectedSingle, keyToAction, objectCopyPartial, parseMulti, parseRange, parseSingle, reducerMulti, reducerRange, reducerSingle, selectDateMulti, selectDateRange, selectDateSingle, sort, toggleValue, wrap, wrapWeekDay };
//# sourceMappingURL=repick-core.esm.js.map