@coopdigital/react 0.49.1 → 0.51.0

package/dist/node_modules/react-day-picker/dist/esm/helpers/createGetModifiers.js

@@ -0,0 +1,95 @@
+import { DayFlag } from '../UI.js';
+import { dateMatchModifiers } from '../utils/dateMatchModifiers.js';
+
+/**
+ * Creates a function to retrieve the modifiers for a given day.
+ *
+ * This function calculates both internal and custom modifiers for each day
+ * based on the provided calendar days and DayPicker props.
+ *
+ * @private
+ * @param days The array of `CalendarDay` objects to process.
+ * @param props The DayPicker props, including modifiers and configuration
+ *   options.
+ * @param dateLib The date library to use for date manipulation.
+ * @returns A function that retrieves the modifiers for a given `CalendarDay`.
+ */
+function createGetModifiers(days, props, navStart, navEnd, dateLib) {
+    const { disabled, hidden, modifiers, showOutsideDays, broadcastCalendar, today = dateLib.today(), } = props;
+    const { isSameDay, isSameMonth, startOfMonth, isBefore, endOfMonth, isAfter, } = dateLib;
+    const computedNavStart = navStart && startOfMonth(navStart);
+    const computedNavEnd = navEnd && endOfMonth(navEnd);
+    const internalModifiersMap = {
+        [DayFlag.focused]: [],
+        [DayFlag.outside]: [],
+        [DayFlag.disabled]: [],
+        [DayFlag.hidden]: [],
+        [DayFlag.today]: [],
+    };
+    const customModifiersMap = {};
+    for (const day of days) {
+        const { date, displayMonth } = day;
+        const isOutside = Boolean(displayMonth && !isSameMonth(date, displayMonth));
+        const isBeforeNavStart = Boolean(computedNavStart && isBefore(date, computedNavStart));
+        const isAfterNavEnd = Boolean(computedNavEnd && isAfter(date, computedNavEnd));
+        const isDisabled = Boolean(disabled && dateMatchModifiers(date, disabled, dateLib));
+        const isHidden = Boolean(hidden && dateMatchModifiers(date, hidden, dateLib)) ||
+            isBeforeNavStart ||
+            isAfterNavEnd ||
+            // Broadcast calendar will show outside days as default
+            (!broadcastCalendar && !showOutsideDays && isOutside) ||
+            (broadcastCalendar && showOutsideDays === false && isOutside);
+        const isToday = isSameDay(date, today);
+        if (isOutside)
+            internalModifiersMap.outside.push(day);
+        if (isDisabled)
+            internalModifiersMap.disabled.push(day);
+        if (isHidden)
+            internalModifiersMap.hidden.push(day);
+        if (isToday)
+            internalModifiersMap.today.push(day);
+        // Add custom modifiers
+        if (modifiers) {
+            Object.keys(modifiers).forEach((name) => {
+                const modifierValue = modifiers?.[name];
+                const isMatch = modifierValue
+                    ? dateMatchModifiers(date, modifierValue, dateLib)
+                    : false;
+                if (!isMatch)
+                    return;
+                if (customModifiersMap[name]) {
+                    customModifiersMap[name].push(day);
+                }
+                else {
+                    customModifiersMap[name] = [day];
+                }
+            });
+        }
+    }
+    return (day) => {
+        // Initialize all the modifiers to false
+        const dayFlags = {
+            [DayFlag.focused]: false,
+            [DayFlag.disabled]: false,
+            [DayFlag.hidden]: false,
+            [DayFlag.outside]: false,
+            [DayFlag.today]: false,
+        };
+        const customModifiers = {};
+        // Find the modifiers for the given day
+        for (const name in internalModifiersMap) {
+            const days = internalModifiersMap[name];
+            dayFlags[name] = days.some((d) => d === day);
+        }
+        for (const name in customModifiersMap) {
+            customModifiers[name] = customModifiersMap[name].some((d) => d === day);
+        }
+        return {
+            ...dayFlags,
+            // custom modifiers should override all the previous ones
+            ...customModifiers,
+        };
+    };
+}
+
+export { createGetModifiers };

package/dist/node_modules/react-day-picker/dist/esm/helpers/endOfBroadcastWeek.js

@@ -0,0 +1,22 @@
+import { getBroadcastWeeksInMonth } from './getBroadcastWeeksInMonth.js';
+import { startOfBroadcastWeek } from './startOfBroadcastWeek.js';
+
+/**
+ * Returns the end date of the week in the broadcast calendar.
+ *
+ * The broadcast week ends on the last day of the last broadcast week for the
+ * given date.
+ *
+ * @since 9.4.0
+ * @param date The date for which to calculate the end of the broadcast week.
+ * @param dateLib The date library to use for date manipulation.
+ * @returns The end date of the broadcast week.
+ */
+function endOfBroadcastWeek(date, dateLib) {
+    const startDate = startOfBroadcastWeek(date, dateLib);
+    const numberOfWeeks = getBroadcastWeeksInMonth(date, dateLib);
+    const endDate = dateLib.addDays(startDate, numberOfWeeks * 7 - 1);
+    return endDate;
+}
+
+export { endOfBroadcastWeek };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getBroadcastWeeksInMonth.js

@@ -0,0 +1,28 @@
+const FIVE_WEEKS = 5;
+const FOUR_WEEKS = 4;
+/**
+ * Returns the number of weeks to display in the broadcast calendar for a given
+ * month.
+ *
+ * The broadcast calendar may have either 4 or 5 weeks in a month, depending on
+ * the start and end dates of the broadcast weeks.
+ *
+ * @since 9.4.0
+ * @param month The month for which to calculate the number of weeks.
+ * @param dateLib The date library to use for date manipulation.
+ * @returns The number of weeks in the broadcast calendar (4 or 5).
+ */
+function getBroadcastWeeksInMonth(month, dateLib) {
+    // Get the first day of the month
+    const firstDayOfMonth = dateLib.startOfMonth(month);
+    // Get the day of the week for the first day of the month (1-7, where 1 is Monday)
+    const firstDayOfWeek = firstDayOfMonth.getDay() > 0 ? firstDayOfMonth.getDay() : 7;
+    const broadcastStartDate = dateLib.addDays(month, -firstDayOfWeek + 1);
+    const lastDateOfLastWeek = dateLib.addDays(broadcastStartDate, FIVE_WEEKS * 7 - 1);
+    const numberOfWeeks = dateLib.getMonth(month) === dateLib.getMonth(lastDateOfLastWeek)
+        ? FIVE_WEEKS
+        : FOUR_WEEKS;
+    return numberOfWeeks;
+}
+
+export { getBroadcastWeeksInMonth };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getClassNamesForModifiers.js

@@ -0,0 +1,33 @@
+import { DayFlag, SelectionState, UI } from '../UI.js';
+
+/**
+ * Returns the class names for a day based on its modifiers.
+ *
+ * This function combines the base class name for the day with any class names
+ * associated with active modifiers.
+ *
+ * @param modifiers The modifiers applied to the day.
+ * @param classNames The base class names for the calendar elements.
+ * @param modifiersClassNames The class names associated with specific
+ *   modifiers.
+ * @returns An array of class names for the day.
+ */
+function getClassNamesForModifiers(modifiers, classNames, modifiersClassNames = {}) {
+    const modifierClassNames = Object.entries(modifiers)
+        .filter(([, active]) => active === true)
+        .reduce((previousValue, [key]) => {
+        if (modifiersClassNames[key]) {
+            previousValue.push(modifiersClassNames[key]);
+        }
+        else if (classNames[DayFlag[key]]) {
+            previousValue.push(classNames[DayFlag[key]]);
+        }
+        else if (classNames[SelectionState[key]]) {
+            previousValue.push(classNames[SelectionState[key]]);
+        }
+        return previousValue;
+    }, [classNames[UI.Day]]);
+    return modifierClassNames;
+}
+
+export { getClassNamesForModifiers };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getComponents.js

@@ -0,0 +1,20 @@
+import * as customComponents from '../components/custom-components.js';
+
+/**
+ * Merges custom components from the props with the default components.
+ *
+ * This function ensures that any custom components provided in the props
+ * override the default components.
+ *
+ * @param customComponents The custom components provided in the DayPicker
+ *   props.
+ * @returns An object containing the merged components.
+ */
+function getComponents(customComponents$1) {
+    return {
+        ...customComponents,
+        ...customComponents$1,
+    };
+}
+
+export { getComponents };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getDataAttributes.js

@@ -0,0 +1,27 @@
+/**
+ * Extracts `data-` attributes from the DayPicker props.
+ *
+ * This function collects all `data-` attributes from the props and adds
+ * additional attributes based on the DayPicker configuration.
+ *
+ * @param props The DayPicker props.
+ * @returns An object containing the `data-` attributes.
+ */
+function getDataAttributes(props) {
+    const dataAttributes = {
+        "data-mode": props.mode ?? undefined,
+        "data-required": "required" in props ? props.required : undefined,
+        "data-multiple-months": (props.numberOfMonths && props.numberOfMonths > 1) || undefined,
+        "data-week-numbers": props.showWeekNumber || undefined,
+        "data-broadcast-calendar": props.broadcastCalendar || undefined,
+        "data-nav-layout": props.navLayout || undefined,
+    };
+    Object.entries(props).forEach(([key, val]) => {
+        if (key.startsWith("data-")) {
+            dataAttributes[key] = val;
+        }
+    });
+    return dataAttributes;
+}
+
+export { getDataAttributes };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getDates.js

@@ -0,0 +1,59 @@
+/**
+ * Returns all the dates to display in the calendar.
+ *
+ * This function calculates the range of dates to display based on the provided
+ * display months, constraints, and calendar configuration.
+ *
+ * @param displayMonths The months to display in the calendar.
+ * @param maxDate The maximum date to include in the range.
+ * @param props The DayPicker props, including calendar configuration options.
+ * @param dateLib The date library to use for date manipulation.
+ * @returns An array of dates to display in the calendar.
+ */
+function getDates(displayMonths, maxDate, props, dateLib) {
+    const firstMonth = displayMonths[0];
+    const lastMonth = displayMonths[displayMonths.length - 1];
+    const { ISOWeek, fixedWeeks, broadcastCalendar } = props ?? {};
+    const { addDays, differenceInCalendarDays, differenceInCalendarMonths, endOfBroadcastWeek, endOfISOWeek, endOfMonth, endOfWeek, isAfter, startOfBroadcastWeek, startOfISOWeek, startOfWeek, } = dateLib;
+    const startWeekFirstDate = broadcastCalendar
+        ? startOfBroadcastWeek(firstMonth, dateLib)
+        : ISOWeek
+            ? startOfISOWeek(firstMonth)
+            : startOfWeek(firstMonth);
+    const displayMonthsWeekEnd = broadcastCalendar
+        ? endOfBroadcastWeek(lastMonth)
+        : ISOWeek
+            ? endOfISOWeek(endOfMonth(lastMonth))
+            : endOfWeek(endOfMonth(lastMonth));
+    // If maxDate is set, clamp the grid to the end of that week.
+    const constraintWeekEnd = maxDate &&
+        (broadcastCalendar
+            ? endOfBroadcastWeek(maxDate)
+            : ISOWeek
+                ? endOfISOWeek(maxDate)
+                : endOfWeek(maxDate));
+    // Pick the earliest week end between the displayed months and the constraint.
+    const gridEndDate = constraintWeekEnd && isAfter(displayMonthsWeekEnd, constraintWeekEnd)
+        ? constraintWeekEnd
+        : displayMonthsWeekEnd;
+    const nOfDays = differenceInCalendarDays(gridEndDate, startWeekFirstDate);
+    const nOfMonths = differenceInCalendarMonths(lastMonth, firstMonth) + 1;
+    const dates = [];
+    for (let i = 0; i <= nOfDays; i++) {
+        const date = addDays(startWeekFirstDate, i);
+        dates.push(date);
+    }
+    // If fixed weeks is enabled, add the extra dates to the array
+    const nrOfDaysWithFixedWeeks = broadcastCalendar ? 35 : 42;
+    const extraDates = nrOfDaysWithFixedWeeks * nOfMonths;
+    if (fixedWeeks && dates.length < extraDates) {
+        const daysToAdd = extraDates - dates.length;
+        for (let i = 0; i < daysToAdd; i++) {
+            const date = addDays(dates[dates.length - 1], 1);
+            dates.push(date);
+        }
+    }
+    return dates;
+}
+
+export { getDates };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getDays.js

@@ -0,0 +1,19 @@
+/**
+ * Returns all the days belonging to the calendar by merging the days in the
+ * weeks for each month.
+ *
+ * @param calendarMonths The array of calendar months.
+ * @returns An array of `CalendarDay` objects representing all the days in the
+ *   calendar.
+ */
+function getDays(calendarMonths) {
+    const initialDays = [];
+    return calendarMonths.reduce((days, month) => {
+        const weekDays = month.weeks.reduce((weekDays, week) => {
+            return weekDays.concat(week.days.slice());
+        }, initialDays.slice());
+        return days.concat(weekDays.slice());
+    }, initialDays.slice());
+}
+
+export { getDays };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getDefaultClassNames.js

@@ -0,0 +1,33 @@
+import { UI, DayFlag, SelectionState, Animation } from '../UI.js';
+
+/**
+ * Returns the default class names for the UI elements.
+ *
+ * This function generates a mapping of default class names for various UI
+ * elements, day flags, selection states, and animations.
+ *
+ * @returns An object containing the default class names.
+ * @group Utilities
+ */
+function getDefaultClassNames() {
+    const classNames = {};
+    for (const key in UI) {
+        classNames[UI[key]] =
+            `rdp-${UI[key]}`;
+    }
+    for (const key in DayFlag) {
+        classNames[DayFlag[key]] =
+            `rdp-${DayFlag[key]}`;
+    }
+    for (const key in SelectionState) {
+        classNames[SelectionState[key]] =
+            `rdp-${SelectionState[key]}`;
+    }
+    for (const key in Animation) {
+        classNames[Animation[key]] =
+            `rdp-${Animation[key]}`;
+    }
+    return classNames;
+}
+
+export { getDefaultClassNames };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getDisplayMonths.js

@@ -0,0 +1,24 @@
+/**
+ * Returns the months to display in the calendar.
+ *
+ * @param firstDisplayedMonth The first month currently displayed in the
+ *   calendar.
+ * @param calendarEndMonth The latest month the user can navigate to.
+ * @param props The DayPicker props, including `numberOfMonths`.
+ * @param dateLib The date library to use for date manipulation.
+ * @returns An array of dates representing the months to display.
+ */
+function getDisplayMonths(firstDisplayedMonth, calendarEndMonth, props, dateLib) {
+    const { numberOfMonths = 1 } = props;
+    const months = [];
+    for (let i = 0; i < numberOfMonths; i++) {
+        const month = dateLib.addMonths(firstDisplayedMonth, i);
+        if (calendarEndMonth && month > calendarEndMonth) {
+            break;
+        }
+        months.push(month);
+    }
+    return months;
+}
+
+export { getDisplayMonths };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getFocusableDate.js

@@ -0,0 +1,46 @@
+/**
+ * Calculates the next date that should be focused in the calendar.
+ *
+ * This function determines the next focusable date based on the movement
+ * direction, constraints, and calendar configuration.
+ *
+ * @param moveBy The unit of movement (e.g., "day", "week").
+ * @param moveDir The direction of movement ("before" or "after").
+ * @param refDate The reference date from which to calculate the next focusable
+ *   date.
+ * @param navStart The earliest date the user can navigate to.
+ * @param navEnd The latest date the user can navigate to.
+ * @param props The DayPicker props, including calendar configuration options.
+ * @param dateLib The date library to use for date manipulation.
+ * @returns The next focusable date.
+ */
+function getFocusableDate(moveBy, moveDir, refDate, navStart, navEnd, props, dateLib) {
+    const { ISOWeek, broadcastCalendar } = props;
+    const { addDays, addMonths, addWeeks, addYears, endOfBroadcastWeek, endOfISOWeek, endOfWeek, max, min, startOfBroadcastWeek, startOfISOWeek, startOfWeek, } = dateLib;
+    const moveFns = {
+        day: addDays,
+        week: addWeeks,
+        month: addMonths,
+        year: addYears,
+        startOfWeek: (date) => broadcastCalendar
+            ? startOfBroadcastWeek(date, dateLib)
+            : ISOWeek
+                ? startOfISOWeek(date)
+                : startOfWeek(date),
+        endOfWeek: (date) => broadcastCalendar
+            ? endOfBroadcastWeek(date)
+            : ISOWeek
+                ? endOfISOWeek(date)
+                : endOfWeek(date),
+    };
+    let focusableDate = moveFns[moveBy](refDate, moveDir === "after" ? 1 : -1);
+    if (moveDir === "before" && navStart) {
+        focusableDate = max([navStart, focusableDate]);
+    }
+    else if (moveDir === "after" && navEnd) {
+        focusableDate = min([navEnd, focusableDate]);
+    }
+    return focusableDate;
+}
+
+export { getFocusableDate };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getFormatters.js

@@ -0,0 +1,24 @@
+import * as index from '../formatters/index.js';
+
+/**
+ * Merges custom formatters from the props with the default formatters.
+ *
+ * @param customFormatters The custom formatters provided in the DayPicker
+ *   props.
+ * @returns The merged formatters object.
+ */
+function getFormatters(customFormatters) {
+    if (customFormatters?.formatMonthCaption && !customFormatters.formatCaption) {
+        customFormatters.formatCaption = customFormatters.formatMonthCaption;
+    }
+    if (customFormatters?.formatYearCaption &&
+        !customFormatters.formatYearDropdown) {
+        customFormatters.formatYearDropdown = customFormatters.formatYearCaption;
+    }
+    return {
+        ...index,
+        ...customFormatters,
+    };
+}
+
+export { getFormatters };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getInitialMonth.js

@@ -0,0 +1,27 @@
+/**
+ * Determines the initial month to display in the calendar based on the provided
+ * props.
+ *
+ * This function calculates the starting month, considering constraints such as
+ * `startMonth`, `endMonth`, and the number of months to display.
+ *
+ * @param props The DayPicker props, including navigation and date constraints.
+ * @param dateLib The date library to use for date manipulation.
+ * @returns The initial month to display.
+ */
+function getInitialMonth(props, navStart, navEnd, dateLib) {
+    const { month, defaultMonth, today = dateLib.today(), numberOfMonths = 1, } = props;
+    let initialMonth = month || defaultMonth || today;
+    const { differenceInCalendarMonths, addMonths, startOfMonth } = dateLib;
+    if (navEnd &&
+        differenceInCalendarMonths(navEnd, initialMonth) < numberOfMonths - 1) {
+        const offset = -1 * (numberOfMonths - 1);
+        initialMonth = addMonths(navEnd, offset);
+    }
+    if (navStart && differenceInCalendarMonths(initialMonth, navStart) < 0) {
+        initialMonth = navStart;
+    }
+    return startOfMonth(initialMonth);
+}
+
+export { getInitialMonth };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getLabels.js

@@ -0,0 +1,53 @@
+import * as index from '../labels/index.js';
+import { labelWeekday } from '../labels/labelWeekday.js';
+import { labelWeekNumberHeader } from '../labels/labelWeekNumberHeader.js';
+import { labelNav } from '../labels/labelNav.js';
+import { labelGridcell } from '../labels/labelGridcell.js';
+import { labelGrid } from '../labels/labelGrid.js';
+import { labelYearDropdown } from '../labels/labelYearDropdown.js';
+import { labelWeekNumber } from '../labels/labelWeekNumber.js';
+import { labelPrevious } from '../labels/labelPrevious.js';
+import { labelNext } from '../labels/labelNext.js';
+import { labelMonthDropdown } from '../labels/labelMonthDropdown.js';
+import { labelDayButton } from '../labels/labelDayButton.js';
+
+const resolveLabel = (defaultLabel, customLabel, localeLabel) => {
+    if (customLabel)
+        return customLabel;
+    if (localeLabel) {
+        return (typeof localeLabel === "function"
+            ? localeLabel
+            : (..._args) => localeLabel);
+    }
+    return defaultLabel;
+};
+/**
+ * Merges custom labels from the props with the default labels.
+ *
+ * When available, uses the locale-provided translation for `labelNext`.
+ *
+ * @param customLabels The custom labels provided in the DayPicker props.
+ * @param options Options from the date library, used to resolve locale
+ *   translations.
+ * @returns The merged labels object with locale-aware defaults.
+ */
+function getLabels(customLabels, options) {
+    const localeLabels = options.locale?.labels ?? {};
+    return {
+        ...index,
+        ...(customLabels ?? {}),
+        labelDayButton: resolveLabel(labelDayButton, customLabels?.labelDayButton, localeLabels.labelDayButton),
+        labelMonthDropdown: resolveLabel(labelMonthDropdown, customLabels?.labelMonthDropdown, localeLabels.labelMonthDropdown),
+        labelNext: resolveLabel(labelNext, customLabels?.labelNext, localeLabels.labelNext),
+        labelPrevious: resolveLabel(labelPrevious, customLabels?.labelPrevious, localeLabels.labelPrevious),
+        labelWeekNumber: resolveLabel(labelWeekNumber, customLabels?.labelWeekNumber, localeLabels.labelWeekNumber),
+        labelYearDropdown: resolveLabel(labelYearDropdown, customLabels?.labelYearDropdown, localeLabels.labelYearDropdown),
+        labelGrid: resolveLabel(labelGrid, customLabels?.labelGrid, localeLabels.labelGrid),
+        labelGridcell: resolveLabel(labelGridcell, customLabels?.labelGridcell, localeLabels.labelGridcell),
+        labelNav: resolveLabel(labelNav, customLabels?.labelNav, localeLabels.labelNav),
+        labelWeekNumberHeader: resolveLabel(labelWeekNumberHeader, customLabels?.labelWeekNumberHeader, localeLabels.labelWeekNumberHeader),
+        labelWeekday: resolveLabel(labelWeekday, customLabels?.labelWeekday, localeLabels.labelWeekday),
+    };
+}
+
+export { getLabels };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getMonthOptions.js

@@ -0,0 +1,33 @@
+/**
+ * Returns the months to show in the dropdown.
+ *
+ * This function generates a list of months for the current year, formatted
+ * using the provided formatter, and determines whether each month should be
+ * disabled based on the navigation range.
+ *
+ * @param displayMonth The currently displayed month.
+ * @param navStart The start date for navigation.
+ * @param navEnd The end date for navigation.
+ * @param formatters The formatters to use for formatting the month labels.
+ * @param dateLib The date library to use for date manipulation.
+ * @returns An array of dropdown options representing the months, or `undefined`
+ *   if no months are available.
+ */
+function getMonthOptions(displayMonth, navStart, navEnd, formatters, dateLib) {
+    const { startOfMonth, startOfYear, endOfYear, eachMonthOfInterval, getMonth, } = dateLib;
+    const months = eachMonthOfInterval({
+        start: startOfYear(displayMonth),
+        end: endOfYear(displayMonth),
+    });
+    const options = months.map((month) => {
+        const label = formatters.formatMonthDropdown(month, dateLib);
+        const value = getMonth(month);
+        const disabled = (navStart && month < startOfMonth(navStart)) ||
+            (navEnd && month > startOfMonth(navEnd)) ||
+            false;
+        return { value, label, disabled };
+    });
+    return options;
+}
+
+export { getMonthOptions };

package/dist/node_modules/react-day-picker/dist/esm/helpers/getMonths.js

@@ -0,0 +1,69 @@
+import { CalendarDay } from '../classes/CalendarDay.js';
+import { CalendarWeek } from '../classes/CalendarWeek.js';
+import { CalendarMonth } from '../classes/CalendarMonth.js';
+
+/**
+ * Returns the months to display in the calendar.
+ *
+ * This function generates `CalendarMonth` objects for each month to be
+ * displayed, including their weeks and days, based on the provided display
+ * months and dates.
+ *
+ * @param displayMonths The months (as dates) to display in the calendar.
+ * @param dates The dates to display in the calendar.
+ * @param props Options from the DayPicker props context.
+ * @param dateLib The date library to use for date manipulation.
+ * @returns An array of `CalendarMonth` objects representing the months to
+ *   display.
+ */
+function getMonths(displayMonths, dates, props, dateLib) {
+    const { addDays, endOfBroadcastWeek, endOfISOWeek, endOfMonth, endOfWeek, getISOWeek, getWeek, startOfBroadcastWeek, startOfISOWeek, startOfWeek, } = dateLib;
+    const dayPickerMonths = displayMonths.reduce((months, month) => {
+        const firstDateOfFirstWeek = props.broadcastCalendar
+            ? startOfBroadcastWeek(month, dateLib)
+            : props.ISOWeek
+                ? startOfISOWeek(month)
+                : startOfWeek(month);
+        const lastDateOfLastWeek = props.broadcastCalendar
+            ? endOfBroadcastWeek(month)
+            : props.ISOWeek
+                ? endOfISOWeek(endOfMonth(month))
+                : endOfWeek(endOfMonth(month));
+        /** The dates to display in the month. */
+        const monthDates = dates.filter((date) => {
+            return date >= firstDateOfFirstWeek && date <= lastDateOfLastWeek;
+        });
+        const nrOfDaysWithFixedWeeks = props.broadcastCalendar ? 35 : 42;
+        if (props.fixedWeeks && monthDates.length < nrOfDaysWithFixedWeeks) {
+            const extraDates = dates.filter((date) => {
+                const daysToAdd = nrOfDaysWithFixedWeeks - monthDates.length;
+                return (date > lastDateOfLastWeek &&
+                    date <= addDays(lastDateOfLastWeek, daysToAdd));
+            });
+            monthDates.push(...extraDates);
+        }
+        const weeks = monthDates.reduce((weeks, date) => {
+            const weekNumber = props.ISOWeek ? getISOWeek(date) : getWeek(date);
+            const week = weeks.find((week) => week.weekNumber === weekNumber);
+            const day = new CalendarDay(date, month, dateLib);
+            if (!week) {
+                weeks.push(new CalendarWeek(weekNumber, [day]));
+            }
+            else {
+                week.days.push(day);
+            }
+            return weeks;
+        }, []);
+        const dayPickerMonth = new CalendarMonth(month, weeks);
+        months.push(dayPickerMonth);
+        return months;
+    }, []);
+    if (!props.reverseMonths) {
+        return dayPickerMonths;
+    }
+    else {
+        return dayPickerMonths.reverse();
+    }
+}
+
+export { getMonths };