@fremtind/jkl-datepicker-react/build/cjs/internal/utils.js

Jøkul react datepicker component

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var utils_exports = {};
__export(utils_exports, {
  DEFAULT_YEARS_TO_SHOW: () => DEFAULT_YEARS_TO_SHOW,
  addMonth: () => addMonth,
  composeEventHandlers: () => composeEventHandlers,
  dateHasChanged: () => dateHasChanged,
  dateIsOutsideRange: () => dateIsOutsideRange,
  getCalendars: () => getCalendars,
  getInitialDate: () => getInitialDate,
  getInitialDateShown: () => getInitialDateShown,
  getMonthSelectOptions: () => getMonthSelectOptions,
  getYearSelectOptions: () => getYearSelectOptions,
  isBackDisabled: () => isBackDisabled,
  isForwardDisabled: () => isForwardDisabled,
  isSameDay: () => isSameDay,
  subtractMonth: () => subtractMonth
});
module.exports = __toCommonJS(utils_exports);
var import_addDays = __toESM(require("date-fns/addDays"));
var import_differenceInCalendarMonths = __toESM(require("date-fns/differenceInCalendarMonths"));
var import_isBefore = __toESM(require("date-fns/isBefore"));
var import_isToday = __toESM(require("date-fns/isToday"));
var import_startOfDay = __toESM(require("date-fns/startOfDay"));
var import_utils = require("../utils");
function composeEventHandlers(...fns) {
  return (event) => fns.some((fn) => {
    fn && fn(event);
    return event.defaultPrevented;
  });
}
function subtractMonth({
  calendars,
  offset,
  minDate
}) {
  if (offset > 1 && minDate) {
    const { firstDayOfMonth } = calendars[0];
    const diffInMonths = (0, import_differenceInCalendarMonths.default)(
      firstDayOfMonth,
      minDate
    );
    if (diffInMonths < offset) {
      offset = diffInMonths;
    }
  }
  return offset;
}
const DEFAULT_YEARS_TO_SHOW = 3;
function getYearSelectOptions(currentYear, minDate, maxDate, yearsToShow) {
  if (minDate && minDate.getFullYear() > currentYear) {
    return [minDate.getFullYear().toString()];
  }
  if (maxDate && maxDate.getFullYear() < currentYear) {
    return [maxDate.getFullYear().toString()];
  }
  let showAllYears = false;
  let previousYearsToShow;
  let comingYearsToShow;
  if (yearsToShow === "all") {
    showAllYears = true;
    previousYearsToShow = DEFAULT_YEARS_TO_SHOW;
    comingYearsToShow = DEFAULT_YEARS_TO_SHOW;
  } else {
    previousYearsToShow = typeof yearsToShow === "number" ? yearsToShow : yearsToShow.previous;
    comingYearsToShow = typeof yearsToShow === "number" ? yearsToShow : yearsToShow.coming;
  }
  let startYear = currentYear - previousYearsToShow;
  if (minDate) {
    const earliestStartYear = showAllYears ? minDate.getFullYear() : startYear;
    startYear = Math.max(minDate.getFullYear(), earliestStartYear);
  }
  let endYear = currentYear + comingYearsToShow;
  if (maxDate) {
    const latestEndYear = showAllYears ? maxDate.getFullYear() : endYear;
    endYear = Math.min(maxDate.getFullYear(), latestEndYear);
  }
  const numYears = Math.max(endYear - startYear + 1, 1);
  const range = [...Array(numYears).keys()].map((x) => x + startYear);
  const stringRange = range.map((item) => item.toString());
  return stringRange;
}
function getMonthSelectOptions(currentYear, monthNames, minDate, maxDate) {
  const minDateYear = (minDate == null ? void 0 : minDate.getFullYear()) || currentYear;
  const minDateMonth = (minDate == null ? void 0 : minDate.getMonth()) === void 0 ? 0 : minDate.getMonth();
  const maxDateYear = (maxDate == null ? void 0 : maxDate.getFullYear()) || currentYear;
  const maxDateMonth = (maxDate == null ? void 0 : maxDate.getMonth()) === void 0 ? 11 : maxDate.getMonth();
  let startMonth = 0;
  let endMonth = 11;
  if (minDateYear === currentYear) {
    startMonth = minDateMonth;
  }
  if (maxDateYear === currentYear) {
    endMonth = maxDateMonth;
  }
  const filteredMonths = monthNames.map((month, index) => ({
    value: index.toString(),
    label: month
  })).filter(
    ({ value }) => parseInt(value) >= startMonth && parseInt(value) <= endMonth
  );
  return filteredMonths;
}
function addMonth({
  calendars,
  offset,
  maxDate
}) {
  if (offset > 1 && maxDate) {
    const { lastDayOfMonth } = calendars[calendars.length - 1];
    const diffInMonths = (0, import_differenceInCalendarMonths.default)(
      maxDate,
      lastDayOfMonth
    );
    if (diffInMonths < offset) {
      offset = diffInMonths;
    }
  }
  return offset;
}
function isBackDisabled({
  calendars,
  minDate
}) {
  if (!minDate) {
    return false;
  }
  const { firstDayOfMonth } = calendars[0];
  const firstDayOfMonthMinusOne = (0, import_addDays.default)(firstDayOfMonth, -1);
  if ((0, import_isBefore.default)(firstDayOfMonthMinusOne, minDate)) {
    return true;
  }
  return false;
}
function isForwardDisabled({
  calendars,
  maxDate
}) {
  if (!maxDate) {
    return false;
  }
  const { lastDayOfMonth } = calendars[calendars.length - 1];
  const lastDayOfMonthPlusOne = (0, import_addDays.default)(lastDayOfMonth, 1);
  if ((0, import_isBefore.default)(maxDate, lastDayOfMonthPlusOne)) {
    return true;
  }
  return false;
}
function getCalendars({
  date,
  selected,
  monthsToDisplay,
  offset,
  minDate,
  maxDate,
  firstDayOfWeek,
  showOutsideDays
}) {
  const months = [];
  const startDate = getStartDate(date, minDate, maxDate);
  for (let i = 0; i < monthsToDisplay; i++) {
    const calendarDates = getMonths({
      month: startDate.getMonth() + i + offset,
      year: startDate.getFullYear(),
      selectedDates: selected,
      minDate,
      maxDate,
      firstDayOfWeek,
      showOutsideDays
    });
    months.push(calendarDates);
  }
  return months;
}
function getStartDate(date, minDate, maxDate) {
  let startDate = (0, import_startOfDay.default)(date);
  if (minDate) {
    const minDateNormalized = (0, import_startOfDay.default)(minDate);
    if ((0, import_isBefore.default)(startDate, minDateNormalized)) {
      startDate = minDateNormalized;
    }
  }
  if (maxDate) {
    const maxDateNormalized = (0, import_startOfDay.default)(maxDate);
    if ((0, import_isBefore.default)(maxDateNormalized, startDate)) {
      startDate = maxDateNormalized;
    }
  }
  return startDate;
}
function getMonths({
  month,
  year,
  selectedDates,
  minDate,
  maxDate,
  firstDayOfWeek,
  showOutsideDays
}) {
  const daysMonthYear = getNumDaysMonthYear(month, year);
  const daysInMonth = daysMonthYear.daysInMonth;
  month = daysMonthYear.month;
  year = daysMonthYear.year;
  const dates = [];
  for (let day = 1; day <= daysInMonth; day++) {
    const date = new Date(year, month, day);
    const dateObj = {
      date,
      selected: isSelected(selectedDates, date),
      selectable: isSelectable(minDate, maxDate, date),
      today: (0, import_isToday.default)(date),
      prevMonth: false,
      nextMonth: false
    };
    dates.push(dateObj);
  }
  const firstDayOfMonth = new Date(year, month, 1);
  const lastDayOfMonth = new Date(year, month, daysInMonth);
  const frontWeekBuffer = fillFrontWeek({
    firstDayOfMonth,
    minDate,
    maxDate,
    selectedDates,
    firstDayOfWeek,
    showOutsideDays
  });
  const backWeekBuffer = fillBackWeek({
    lastDayOfMonth,
    minDate,
    maxDate,
    selectedDates,
    firstDayOfWeek,
    showOutsideDays
  });
  dates.unshift(...frontWeekBuffer);
  dates.push(...backWeekBuffer);
  const weeks = getWeeks(dates);
  return {
    firstDayOfMonth,
    lastDayOfMonth,
    month,
    year,
    weeks
  };
}
function fillFrontWeek({
  firstDayOfMonth,
  minDate,
  maxDate,
  selectedDates,
  firstDayOfWeek,
  showOutsideDays
}) {
  const dates = [];
  let firstDay = (firstDayOfMonth.getDay() + 7 - firstDayOfWeek) % 7;
  if (showOutsideDays) {
    const lastDayOfPrevMonth = (0, import_addDays.default)(firstDayOfMonth, -1);
    const prevDate = lastDayOfPrevMonth.getDate();
    const prevDateMonth = lastDayOfPrevMonth.getMonth();
    const prevDateYear = lastDayOfPrevMonth.getFullYear();
    let counter = 0;
    while (counter < firstDay) {
      const date = new Date(
        prevDateYear,
        prevDateMonth,
        prevDate - counter
      );
      const dateObj = {
        date,
        selected: isSelected(selectedDates, date),
        selectable: isSelectable(minDate, maxDate, date),
        today: false,
        prevMonth: true,
        nextMonth: false
      };
      dates.unshift(dateObj);
      counter++;
    }
  } else {
    while (firstDay > 0) {
      dates.unshift("");
      firstDay--;
    }
  }
  return dates;
}
function fillBackWeek({
  lastDayOfMonth,
  minDate,
  maxDate,
  selectedDates,
  firstDayOfWeek,
  showOutsideDays
}) {
  const dates = [];
  let lastDay = (lastDayOfMonth.getDay() + 7 - firstDayOfWeek) % 7;
  if (showOutsideDays) {
    const firstDayOfNextMonth = (0, import_addDays.default)(lastDayOfMonth, 1);
    const nextDateMonth = firstDayOfNextMonth.getMonth();
    const nextDateYear = firstDayOfNextMonth.getFullYear();
    let counter = 0;
    while (counter < 6 - lastDay) {
      const date = new Date(nextDateYear, nextDateMonth, 1 + counter);
      const dateObj = {
        date,
        selected: isSelected(selectedDates, date),
        selectable: isSelectable(minDate, maxDate, date),
        today: false,
        prevMonth: false,
        nextMonth: true
      };
      dates.push(dateObj);
      counter++;
    }
  } else {
    while (lastDay < 6) {
      dates.push("");
      lastDay++;
    }
  }
  return dates;
}
function getNumDaysMonthYear(month, year) {
  const normalizedMonthYear = new Date(year, month, 1);
  month = normalizedMonthYear.getMonth();
  year = normalizedMonthYear.getFullYear();
  const daysInMonth = 32 - new Date(year, month, 32).getDate();
  return { daysInMonth, month, year };
}
function getWeeks(dates) {
  const weeksLength = Math.ceil(dates.length / 7);
  const weeks = [];
  for (let i = 0; i < weeksLength; i++) {
    weeks[i] = [];
    for (let x = 0; x < 7; x++) {
      weeks[i].push(dates[i * 7 + x]);
    }
  }
  return weeks;
}
function isSelected(selectedDates, date) {
  if (!selectedDates) {
    return false;
  }
  selectedDates = Array.isArray(selectedDates) ? selectedDates : [selectedDates];
  return selectedDates.some((selectedDate) => {
    if (selectedDate instanceof Date && (0, import_startOfDay.default)(selectedDate).getTime() === (0, import_startOfDay.default)(date).getTime()) {
      return true;
    }
    return false;
  });
}
function isSelectable(minDate, maxDate, date) {
  if (minDate && (0, import_isBefore.default)(date, minDate) || maxDate && (0, import_isBefore.default)(maxDate, date)) {
    return false;
  }
  return true;
}
function isSameDay(date1, date2) {
  return date1.getDate() === date2.getDate() && date1.getMonth() === date2.getMonth() && date1.getFullYear() === date2.getFullYear();
}
function dateHasChanged(date, newDate) {
  return !date || !isSameDay(date, newDate);
}
function dateIsOutsideRange(date, rangeStart, rangeEnd) {
  return Boolean(
    rangeEnd && date > rangeEnd || rangeStart && date < rangeStart
  );
}
function getInitialDate(value, defaultValue, minDate, maxDate) {
  const valueAsDate = (0, import_utils.parseDateString)(value);
  const defaultValueAsDate = (0, import_utils.parseDateString)(defaultValue);
  if (valueAsDate) {
    return !dateIsOutsideRange(valueAsDate, minDate, maxDate) ? valueAsDate : null;
  }
  if (defaultValueAsDate) {
    return !dateIsOutsideRange(defaultValueAsDate, minDate, maxDate) ? defaultValueAsDate : null;
  }
  return null;
}
function getInitialDateShown(date, defaultSelected, minDate, maxDate) {
  let initialDate = date || defaultSelected || /* @__PURE__ */ new Date();
  if (minDate) {
    initialDate = minDate > initialDate ? minDate : initialDate;
  }
  if (maxDate) {
    initialDate = maxDate < initialDate ? maxDate : initialDate;
  }
  return initialDate;
}
//# sourceMappingURL=utils.js.map