@fremtind/jkl-datepicker-react
Version:
Jøkul react datepicker component
389 lines (388 loc) • 10.8 kB
JavaScript
import addDays from "date-fns/addDays";
import differenceInCalendarMonths from "date-fns/differenceInCalendarMonths";
import isBefore from "date-fns/isBefore";
import isToday from "date-fns/isToday";
import startOfDay from "date-fns/startOfDay";
import { parseDateString } from "../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 = differenceInCalendarMonths(
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 = differenceInCalendarMonths(
maxDate,
lastDayOfMonth
);
if (diffInMonths < offset) {
offset = diffInMonths;
}
}
return offset;
}
function isBackDisabled({
calendars,
minDate
}) {
if (!minDate) {
return false;
}
const { firstDayOfMonth } = calendars[0];
const firstDayOfMonthMinusOne = addDays(firstDayOfMonth, -1);
if (isBefore(firstDayOfMonthMinusOne, minDate)) {
return true;
}
return false;
}
function isForwardDisabled({
calendars,
maxDate
}) {
if (!maxDate) {
return false;
}
const { lastDayOfMonth } = calendars[calendars.length - 1];
const lastDayOfMonthPlusOne = addDays(lastDayOfMonth, 1);
if (isBefore(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 = startOfDay(date);
if (minDate) {
const minDateNormalized = startOfDay(minDate);
if (isBefore(startDate, minDateNormalized)) {
startDate = minDateNormalized;
}
}
if (maxDate) {
const maxDateNormalized = startOfDay(maxDate);
if (isBefore(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: isToday(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 = addDays(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 = addDays(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 && startOfDay(selectedDate).getTime() === startOfDay(date).getTime()) {
return true;
}
return false;
});
}
function isSelectable(minDate, maxDate, date) {
if (minDate && isBefore(date, minDate) || maxDate && isBefore(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 = parseDateString(value);
const defaultValueAsDate = 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;
}
export {
DEFAULT_YEARS_TO_SHOW,
addMonth,
composeEventHandlers,
dateHasChanged,
dateIsOutsideRange,
getCalendars,
getInitialDate,
getInitialDateShown,
getMonthSelectOptions,
getYearSelectOptions,
isBackDisabled,
isForwardDisabled,
isSameDay,
subtractMonth
};
//# sourceMappingURL=utils.js.map