@ionic/core 8.8.12 → 8.8.13-nightly.20260626

package/dist/cjs/ion-datetime_3.cjs.entry.js

@@ -11,7 +11,7 @@ var dir = require('./dir-Cn0z1rJH.js');
 var theme = require('./theme-CeDs6Hcv.js');
 var index$1 = require('./index-DqmRDbxg.js');
 var ionicGlobal = require('./ionic-global-B-cA6LkY.js');
-var data = require('./data-DLTUw-KF.js');
+var format = require('./format-PxvGiOik.js');
 var lockController = require('./lock-controller-aDB9wrEf.js');
 var animation = require('./animation-BJq0kcy2.js');
 var haptic = require('./haptic-ClPPQ_PS.js');
@@ -21,6 +21,529 @@ require('./framework-delegate-BtICZDHr.js');
 require('./gesture-controller-dtqlP_q4.js');
 require('./capacitor-DmA66EwP.js');
 
+/**
+ * Returns the current date as
+ * an ISO string in the user's
+ * time zone.
+ */
+const getToday = () => {
+    /**
+     * ion-datetime intentionally does not
+     * parse time zones/do automatic time zone
+     * conversion when accepting user input.
+     * However when we get today's date string,
+     * we want it formatted relative to the user's
+     * time zone.
+     *
+     * When calling toISOString(), the browser
+     * will convert the date to UTC time by either adding
+     * or subtracting the time zone offset.
+     * To work around this, we need to either add
+     * or subtract the time zone offset to the Date
+     * object prior to calling toISOString().
+     * This allows us to get an ISO string
+     * that is in the user's time zone.
+     */
+    return format.removeDateTzOffset(new Date()).toISOString();
+};
+const minutes = [
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+];
+// h11 hour system uses 0-11. Midnight starts at 0:00am.
+const hour11 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+// h12 hour system uses 0-12. Midnight starts at 12:00am.
+const hour12 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+// h23 hour system uses 0-23. Midnight starts at 0:00.
+const hour23 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23];
+// h24 hour system uses 1-24. Midnight starts at 24:00.
+const hour24 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 0];
+/**
+ * Given a locale and a mode,
+ * return an array with formatted days
+ * of the week. iOS should display days
+ * such as "Mon" or "Tue".
+ * MD should display days such as "M"
+ * or "T".
+ */
+const getDaysOfWeek = (locale, mode, firstDayOfWeek = 0) => {
+    /**
+     * Nov 1st, 2020 starts on a Sunday.
+     * ion-datetime assumes weeks start on Sunday,
+     * but is configurable via `firstDayOfWeek`.
+     */
+    const weekdayFormat = mode === 'ios' ? 'short' : 'narrow';
+    const intl = new Intl.DateTimeFormat(locale, { weekday: weekdayFormat });
+    const startDate = new Date('11/01/2020');
+    const daysOfWeek = [];
+    /**
+     * For each day of the week,
+     * get the day name.
+     */
+    for (let i = firstDayOfWeek; i < firstDayOfWeek + 7; i++) {
+        const currentDate = new Date(startDate);
+        currentDate.setDate(currentDate.getDate() + i);
+        daysOfWeek.push(intl.format(currentDate));
+    }
+    return daysOfWeek;
+};
+/**
+ * Returns an array containing all of the
+ * days in a month for a given year. Values are
+ * aligned with a week calendar starting on
+ * the firstDayOfWeek value (Sunday by default)
+ * using null values.
+ */
+const getDaysOfMonth = (month, year, firstDayOfWeek, showAdjacentDays = false) => {
+    const numDays = format.getNumDaysInMonth(month, year);
+    let previousNumDays; //previous month number of days
+    if (month === 1) {
+        // If the current month is January, the previous month should be December of the previous year.
+        previousNumDays = format.getNumDaysInMonth(12, year - 1);
+    }
+    else {
+        // Otherwise, the previous month should be the current month - 1 of the same year.
+        previousNumDays = format.getNumDaysInMonth(month - 1, year);
+    }
+    const firstOfMonth = new Date(`${month}/1/${year}`).getDay();
+    /**
+     * To get the first day of the month aligned on the correct
+     * day of the week, we need to determine how many "filler" days
+     * to generate. These filler days as empty/disabled buttons
+     * that fill the space of the days of the week before the first
+     * of the month.
+     *
+     * There are two cases here:
+     *
+     * 1. If firstOfMonth = 4, firstDayOfWeek = 0 then the offset
+     * is (4 - (0 + 1)) = 3. Since the offset loop goes from 0 to 3 inclusive,
+     * this will generate 4 filler days (0, 1, 2, 3), and then day of week 4 will have
+     * the first day of the month.
+     *
+     * 2. If firstOfMonth = 2, firstDayOfWeek = 4 then the offset
+     * is (6 - (4 - 2)) = 4. Since the offset loop goes from 0 to 4 inclusive,
+     * this will generate 5 filler days (0, 1, 2, 3, 4), and then day of week 5 will have
+     * the first day of the month.
+     */
+    const offset = firstOfMonth >= firstDayOfWeek ? firstOfMonth - (firstDayOfWeek + 1) : 6 - (firstDayOfWeek - firstOfMonth);
+    let days = [];
+    for (let i = 1; i <= numDays; i++) {
+        days.push({ day: i, dayOfWeek: (offset + i) % 7, isAdjacentDay: false });
+    }
+    if (showAdjacentDays) {
+        for (let i = 0; i <= offset; i++) {
+            // Using offset create previous month adjacent day, starting from last day
+            days = [{ day: previousNumDays - i, dayOfWeek: (previousNumDays - i) % 7, isAdjacentDay: true }, ...days];
+        }
+        // Calculate positiveOffset
+        // The calendar will display 42 days (6 rows of 7 columns)
+        // Knowing this the offset is 41 (we start at index 0)
+        // minus (the previous offset + the current month days)
+        const positiveOffset = 41 - (numDays + offset);
+        for (let i = 0; i < positiveOffset; i++) {
+            days.push({ day: i + 1, dayOfWeek: (numDays + offset + i) % 7, isAdjacentDay: true });
+        }
+    }
+    else {
+        for (let i = 0; i <= offset; i++) {
+            days = [{ day: null, dayOfWeek: null, isAdjacentDay: false }, ...days];
+        }
+    }
+    return days;
+};
+/**
+ * Returns an array of pre-defined hour
+ * values based on the provided hourCycle.
+ */
+const getHourData = (hourCycle) => {
+    switch (hourCycle) {
+        case 'h11':
+            return hour11;
+        case 'h12':
+            return hour12;
+        case 'h23':
+            return hour23;
+        case 'h24':
+            return hour24;
+        default:
+            throw new Error(`Invalid hour cycle "${hourCycle}"`);
+    }
+};
+/**
+ * Given a local, reference datetime parts and option
+ * max/min bound datetime parts, calculate the acceptable
+ * hour and minute values according to the bounds and locale.
+ */
+const generateTime = (locale, refParts, hourCycle = 'h12', minParts, maxParts, hourValues, minuteValues) => {
+    const computedHourCycle = format.getHourCycle(locale, hourCycle);
+    const use24Hour = format.is24Hour(computedHourCycle);
+    let processedHours = getHourData(computedHourCycle);
+    let processedMinutes = minutes;
+    let isAMAllowed = true;
+    let isPMAllowed = true;
+    if (hourValues) {
+        processedHours = processedHours.filter((hour) => hourValues.includes(hour));
+    }
+    if (minuteValues) {
+        processedMinutes = processedMinutes.filter((minute) => minuteValues.includes(minute));
+    }
+    if (minParts) {
+        /**
+         * If ref day is the same as the
+         * minimum allowed day, filter hour/minute
+         * values according to min hour and minute.
+         */
+        if (format.isSameDay(refParts, minParts)) {
+            /**
+             * Users may not always set the hour/minute for
+             * min value (i.e. 2021-06-02) so we should allow
+             * all hours/minutes in that case.
+             */
+            if (minParts.hour !== undefined) {
+                processedHours = processedHours.filter((hour) => {
+                    const convertedHour = refParts.ampm === 'pm' ? (hour + 12) % 24 : hour;
+                    return (use24Hour ? hour : convertedHour) >= minParts.hour;
+                });
+                isAMAllowed = minParts.hour < 13;
+            }
+            if (minParts.minute !== undefined) {
+                /**
+                 * The minimum minute range should not be enforced when
+                 * the hour is greater than the min hour.
+                 *
+                 * For example with a minimum range of 09:30, users
+                 * should be able to select 10:00-10:29 and beyond.
+                 */
+                let isPastMinHour = false;
+                if (minParts.hour !== undefined && refParts.hour !== undefined) {
+                    if (refParts.hour > minParts.hour) {
+                        isPastMinHour = true;
+                    }
+                }
+                processedMinutes = processedMinutes.filter((minute) => {
+                    if (isPastMinHour) {
+                        return true;
+                    }
+                    return minute >= minParts.minute;
+                });
+            }
+            /**
+             * If ref day is before minimum
+             * day do not render any hours/minute values
+             */
+        }
+        else if (format.isBefore(refParts, minParts)) {
+            processedHours = [];
+            processedMinutes = [];
+            isAMAllowed = isPMAllowed = false;
+        }
+    }
+    if (maxParts) {
+        /**
+         * If ref day is the same as the
+         * maximum allowed day, filter hour/minute
+         * values according to max hour and minute.
+         */
+        if (format.isSameDay(refParts, maxParts)) {
+            /**
+             * Users may not always set the hour/minute for
+             * max value (i.e. 2021-06-02) so we should allow
+             * all hours/minutes in that case.
+             */
+            if (maxParts.hour !== undefined) {
+                processedHours = processedHours.filter((hour) => {
+                    const convertedHour = refParts.ampm === 'pm' ? (hour + 12) % 24 : hour;
+                    return (use24Hour ? hour : convertedHour) <= maxParts.hour;
+                });
+                isPMAllowed = maxParts.hour >= 12;
+            }
+            if (maxParts.minute !== undefined && refParts.hour === maxParts.hour) {
+                // The available minutes should only be filtered when the hour is the same as the max hour.
+                // For example if the max hour is 10:30 and the current hour is 10:00,
+                // users should be able to select 00-30 minutes.
+                // If the current hour is 09:00, users should be able to select 00-60 minutes.
+                processedMinutes = processedMinutes.filter((minute) => minute <= maxParts.minute);
+            }
+            /**
+             * If ref day is after minimum
+             * day do not render any hours/minute values
+             */
+        }
+        else if (format.isAfter(refParts, maxParts)) {
+            processedHours = [];
+            processedMinutes = [];
+            isAMAllowed = isPMAllowed = false;
+        }
+    }
+    return {
+        hours: processedHours,
+        minutes: processedMinutes,
+        am: isAMAllowed,
+        pm: isPMAllowed,
+    };
+};
+/**
+ * Given DatetimeParts, generate the previous,
+ * current, and and next months.
+ */
+const generateMonths = (refParts, forcedDate) => {
+    const current = { month: refParts.month, year: refParts.year, day: refParts.day };
+    /**
+     * If we're forcing a month to appear, and it's different from the current month,
+     * ensure it appears by replacing the next or previous month as appropriate.
+     */
+    if (forcedDate !== undefined && (refParts.month !== forcedDate.month || refParts.year !== forcedDate.year)) {
+        const forced = { month: forcedDate.month, year: forcedDate.year, day: forcedDate.day };
+        const forcedMonthIsBefore = format.isBefore(forced, current);
+        return forcedMonthIsBefore
+            ? [forced, current, format.getNextMonth(refParts)]
+            : [format.getPreviousMonth(refParts), current, forced];
+    }
+    return [format.getPreviousMonth(refParts), current, format.getNextMonth(refParts)];
+};
+const getMonthColumnData = (locale, refParts, minParts, maxParts, monthValues, formatOptions = {
+    month: 'long',
+}) => {
+    const { year } = refParts;
+    const months = [];
+    if (monthValues !== undefined) {
+        let processedMonths = monthValues;
+        if ((maxParts === null || maxParts === void 0 ? void 0 : maxParts.month) !== undefined) {
+            processedMonths = processedMonths.filter((month) => month <= maxParts.month);
+        }
+        if ((minParts === null || minParts === void 0 ? void 0 : minParts.month) !== undefined) {
+            processedMonths = processedMonths.filter((month) => month >= minParts.month);
+        }
+        processedMonths.forEach((processedMonth) => {
+            const date = new Date(`${processedMonth}/1/${year} GMT+0000`);
+            const monthString = new Intl.DateTimeFormat(locale, Object.assign(Object.assign({}, formatOptions), { timeZone: 'UTC' })).format(date);
+            months.push({ text: monthString, value: processedMonth });
+        });
+    }
+    else {
+        const maxMonth = maxParts && maxParts.year === year ? maxParts.month : 12;
+        const minMonth = minParts && minParts.year === year ? minParts.month : 1;
+        for (let i = minMonth; i <= maxMonth; i++) {
+            /**
+             *
+             * There is a bug on iOS 14 where
+             * Intl.DateTimeFormat takes into account
+             * the local timezone offset when formatting dates.
+             *
+             * Forcing the timezone to 'UTC' fixes the issue. However,
+             * we should keep this workaround as it is safer. In the event
+             * this breaks in another browser, we will not be impacted
+             * because all dates will be interpreted in UTC.
+             *
+             * Example:
+             * new Intl.DateTimeFormat('en-US', { month: 'long' }).format(new Date('Sat Apr 01 2006 00:00:00 GMT-0400 (EDT)')) // "March"
+             * new Intl.DateTimeFormat('en-US', { month: 'long', timeZone: 'UTC' }).format(new Date('Sat Apr 01 2006 00:00:00 GMT-0400 (EDT)')) // "April"
+             *
+             * In certain timezones, iOS 14 shows the wrong
+             * date for .toUTCString(). To combat this, we
+             * force all of the timezones to GMT+0000 (UTC).
+             *
+             * Example:
+             * Time Zone: Central European Standard Time
+             * new Date('1/1/1992').toUTCString() // "Tue, 31 Dec 1991 23:00:00 GMT"
+             * new Date('1/1/1992 GMT+0000').toUTCString() // "Wed, 01 Jan 1992 00:00:00 GMT"
+             */
+            const date = new Date(`${i}/1/${year} GMT+0000`);
+            const monthString = new Intl.DateTimeFormat(locale, Object.assign(Object.assign({}, formatOptions), { timeZone: 'UTC' })).format(date);
+            months.push({ text: monthString, value: i });
+        }
+    }
+    return months;
+};
+/**
+ * Returns information regarding
+ * selectable dates (i.e 1st, 2nd, 3rd, etc)
+ * within a reference month.
+ * @param locale The locale to format the date with
+ * @param refParts The reference month/year to generate dates for
+ * @param minParts The minimum bound on the date that can be returned
+ * @param maxParts The maximum bound on the date that can be returned
+ * @param dayValues The allowed date values
+ * @returns Date data to be used in ion-picker-column
+ */
+const getDayColumnData = (locale, refParts, minParts, maxParts, dayValues, formatOptions = {
+    day: 'numeric',
+}) => {
+    const { month, year } = refParts;
+    const days = [];
+    /**
+     * If we have max/min bounds that in the same
+     * month/year as the refParts, we should
+     * use the define day as the max/min day.
+     * Otherwise, fallback to the max/min days in a month.
+     */
+    const numDaysInMonth = format.getNumDaysInMonth(month, year);
+    const maxDay = (maxParts === null || maxParts === void 0 ? void 0 : maxParts.day) !== null && (maxParts === null || maxParts === void 0 ? void 0 : maxParts.day) !== undefined && maxParts.year === year && maxParts.month === month
+        ? maxParts.day
+        : numDaysInMonth;
+    const minDay = (minParts === null || minParts === void 0 ? void 0 : minParts.day) !== null && (minParts === null || minParts === void 0 ? void 0 : minParts.day) !== undefined && minParts.year === year && minParts.month === month
+        ? minParts.day
+        : 1;
+    if (dayValues !== undefined) {
+        let processedDays = dayValues;
+        processedDays = processedDays.filter((day) => day >= minDay && day <= maxDay);
+        processedDays.forEach((processedDay) => {
+            const date = new Date(`${month}/${processedDay}/${year} GMT+0000`);
+            const dayString = new Intl.DateTimeFormat(locale, Object.assign(Object.assign({}, formatOptions), { timeZone: 'UTC' })).format(date);
+            days.push({ text: dayString, value: processedDay });
+        });
+    }
+    else {
+        for (let i = minDay; i <= maxDay; i++) {
+            const date = new Date(`${month}/${i}/${year} GMT+0000`);
+            const dayString = new Intl.DateTimeFormat(locale, Object.assign(Object.assign({}, formatOptions), { timeZone: 'UTC' })).format(date);
+            days.push({ text: dayString, value: i });
+        }
+    }
+    return days;
+};
+const getYearColumnData = (locale, refParts, minParts, maxParts, yearValues) => {
+    var _a, _b;
+    let processedYears = [];
+    if (yearValues !== undefined) {
+        processedYears = yearValues;
+        if ((maxParts === null || maxParts === void 0 ? void 0 : maxParts.year) !== undefined) {
+            processedYears = processedYears.filter((year) => year <= maxParts.year);
+        }
+        if ((minParts === null || minParts === void 0 ? void 0 : minParts.year) !== undefined) {
+            processedYears = processedYears.filter((year) => year >= minParts.year);
+        }
+    }
+    else {
+        const { year } = refParts;
+        const maxYear = (_a = maxParts === null || maxParts === void 0 ? void 0 : maxParts.year) !== null && _a !== void 0 ? _a : year;
+        const minYear = (_b = minParts === null || minParts === void 0 ? void 0 : minParts.year) !== null && _b !== void 0 ? _b : year - 100;
+        for (let i = minYear; i <= maxYear; i++) {
+            processedYears.push(i);
+        }
+    }
+    return processedYears.map((year) => ({
+        text: format.getYear(locale, { year, month: refParts.month, day: refParts.day }),
+        value: year,
+    }));
+};
+/**
+ * Given a starting date and an upper bound,
+ * this functions returns an array of all
+ * month objects in that range.
+ */
+const getAllMonthsInRange = (currentParts, maxParts) => {
+    if (currentParts.month === maxParts.month && currentParts.year === maxParts.year) {
+        return [currentParts];
+    }
+    return [currentParts, ...getAllMonthsInRange(format.getNextMonth(currentParts), maxParts)];
+};
+/**
+ * Creates and returns picker items
+ * that represent the days in a month.
+ * Example: "Thu, Jun 2"
+ */
+const getCombinedDateColumnData = (locale, todayParts, minParts, maxParts, dayValues, monthValues) => {
+    let items = [];
+    let parts = [];
+    /**
+     * Get all month objects from the min date
+     * to the max date. Note: Do not use getMonthColumnData
+     * as that function only generates dates within a
+     * single year.
+     */
+    let months = getAllMonthsInRange(minParts, maxParts);
+    /**
+     * Filter out any disallowed month values.
+     */
+    if (monthValues) {
+        months = months.filter(({ month }) => monthValues.includes(month));
+    }
+    /**
+     * Get all of the days in the month.
+     * From there, generate an array where
+     * each item has the month, date, and day
+     * of work as the text.
+     */
+    months.forEach((monthObject) => {
+        const referenceMonth = { month: monthObject.month, day: null, year: monthObject.year };
+        const monthDays = getDayColumnData(locale, referenceMonth, minParts, maxParts, dayValues, {
+            month: 'short',
+            day: 'numeric',
+            weekday: 'short',
+        });
+        const dateParts = [];
+        const dateColumnItems = [];
+        monthDays.forEach((dayObject) => {
+            const isToday = format.isSameDay(Object.assign(Object.assign({}, referenceMonth), { day: dayObject.value }), todayParts);
+            /**
+             * Today's date should read as "Today" (localized)
+             * not the actual date string
+             */
+            dateColumnItems.push({
+                text: isToday ? format.getTodayLabel(locale) : dayObject.text,
+                value: `${referenceMonth.year}-${referenceMonth.month}-${dayObject.value}`,
+            });
+            /**
+             * When selecting a date in the wheel picker
+             * we need access to the raw datetime parts data.
+             * The picker column only accepts values of
+             * type string or number, so we need to return
+             * two sets of data: A data set to be passed
+             * to the picker column, and a data set to
+             * be used to reference the raw data when
+             * updating the picker column value.
+             */
+            dateParts.push({
+                month: referenceMonth.month,
+                year: referenceMonth.year,
+                day: dayObject.value,
+            });
+        });
+        parts = [...parts, ...dateParts];
+        items = [...items, ...dateColumnItems];
+    });
+    return {
+        parts,
+        items,
+    };
+};
+const getTimeColumnsData = (locale, refParts, hourCycle, minParts, maxParts, allowedHourValues, allowedMinuteValues) => {
+    const computedHourCycle = format.getHourCycle(locale, hourCycle);
+    const use24Hour = format.is24Hour(computedHourCycle);
+    const { hours, minutes, am, pm } = generateTime(locale, refParts, computedHourCycle, minParts, maxParts, allowedHourValues, allowedMinuteValues);
+    const hoursItems = hours.map((hour) => {
+        return {
+            text: format.getFormattedHour(hour, computedHourCycle),
+            value: format.getInternalHourValue(hour, use24Hour, refParts.ampm),
+        };
+    });
+    const minutesItems = minutes.map((minute) => {
+        return {
+            text: format.addTimePadding(minute),
+            value: minute,
+        };
+    });
+    const dayPeriodItems = [];
+    if (am && !use24Hour) {
+        dayPeriodItems.push({
+            text: format.getLocalizedDayPeriod(locale, 'am'),
+            value: 'am',
+        });
+    }
+    if (pm && !use24Hour) {
+        dayPeriodItems.push({
+            text: format.getLocalizedDayPeriod(locale, 'pm'),
+            value: 'pm',
+        });
+    }
+    return {
+        minutesData: minutesItems,
+        hoursData: hoursItems,
+        dayPeriodData: dayPeriodItems,
+    };
+};
+
 const isYearDisabled = (refYear, minParts, maxParts) => {
     if (minParts && minParts.year > refYear) {
         return true;
@@ -62,7 +585,7 @@ const isDayDisabled = (refParts, minParts, maxParts, dayValues) => {
      * current month === min allow month, but the current
      * day < the min allowed day?
      */
-    if (minParts && data.isBefore(refParts, minParts)) {
+    if (minParts && format.isBefore(refParts, minParts)) {
         return true;
     }
     /**
@@ -76,7 +599,7 @@ const isDayDisabled = (refParts, minParts, maxParts, dayValues) => {
      * current month === max allow month, but the current
      * day > the max allowed day?
      */
-    if (maxParts && data.isAfter(refParts, maxParts)) {
+    if (maxParts && format.isAfter(refParts, maxParts)) {
         return true;
     }
     /**
@@ -103,8 +626,8 @@ const getCalendarDayState = (locale, refParts, activeParts, todayParts, minParts
      * The day button is active if it is selected, or in other words, if refParts
      * matches at least one selected date.
      */
-    const isActive = activePartsArray.find((parts) => data.isSameDay(refParts, parts)) !== undefined;
-    const isToday = data.isSameDay(refParts, todayParts);
+    const isActive = activePartsArray.find((parts) => format.isSameDay(refParts, parts)) !== undefined;
+    const isToday = format.isSameDay(refParts, todayParts);
     const disabled = isDayDisabled(refParts, minParts, maxParts, dayValues);
     /**
      * Note that we always return one object regardless of whether activeParts
@@ -115,8 +638,8 @@ const getCalendarDayState = (locale, refParts, activeParts, todayParts, minParts
         isActive,
         isToday,
         ariaSelected: isActive ? 'true' : null,
-        ariaLabel: data.generateDayAriaLabel(locale, isToday, refParts),
-        text: refParts.day != null ? data.getDay(locale, refParts) : null,
+        ariaLabel: format.generateDayAriaLabel(locale, isToday, refParts),
+        text: refParts.day != null ? format.getDay(locale, refParts) : null,
     };
 };
 /**
@@ -130,7 +653,7 @@ const isMonthDisabled = (refParts, { minParts, maxParts, }) => {
     }
     // If the date value is before the min date, then the month is disabled.
     // If the date value is after the max date, then the month is disabled.
-    if ((minParts && data.isBefore(refParts, minParts)) || (maxParts && data.isAfter(refParts, maxParts))) {
+    if ((minParts && format.isBefore(refParts, minParts)) || (maxParts && format.isAfter(refParts, maxParts))) {
         return true;
     }
     return false;
@@ -141,7 +664,7 @@ const isMonthDisabled = (refParts, { minParts, maxParts, }) => {
  * previous navigation button is disabled.
  */
 const isPrevMonthDisabled = (refParts, minParts, maxParts) => {
-    const prevMonth = Object.assign(Object.assign({}, data.getPreviousMonth(refParts)), { day: null });
+    const prevMonth = Object.assign(Object.assign({}, format.getPreviousMonth(refParts)), { day: null });
     return isMonthDisabled(prevMonth, {
         minParts,
         maxParts,
@@ -152,7 +675,7 @@ const isPrevMonthDisabled = (refParts, minParts, maxParts) => {
  * determine if the next navigation button is disabled.
  */
 const isNextMonthDisabled = (refParts, maxParts) => {
-    const nextMonth = Object.assign(Object.assign({}, data.getNextMonth(refParts)), { day: null });
+    const nextMonth = Object.assign(Object.assign({}, format.getNextMonth(refParts)), { day: null });
     return isMonthDisabled(nextMonth, {
         maxParts,
     });
@@ -445,12 +968,12 @@ const Datetime = class {
              * Additionally, we need to update the working parts
              * too in the event that the validated parts are different.
              */
-            const validatedParts = data.validateParts(parts, minParts, maxParts);
+            const validatedParts = format.validateParts(parts, minParts, maxParts);
             this.setWorkingParts(validatedParts);
             if (multiple) {
                 const activePartsArray = Array.isArray(activeParts) ? activeParts : [activeParts];
                 if (removeDate) {
-                    this.activeParts = activePartsArray.filter((p) => !data.isSameDay(p, validatedParts));
+                    this.activeParts = activePartsArray.filter((p) => !format.isSameDay(p, validatedParts));
                 }
                 else {
                     this.activeParts = [...activePartsArray, validatedParts];
@@ -510,40 +1033,40 @@ const Datetime = class {
                 if (!activeElement || !activeElement.classList.contains('calendar-day')) {
                     return;
                 }
-                const parts = data.getPartsFromCalendarDay(activeElement);
+                const parts = format.getPartsFromCalendarDay(activeElement);
                 let partsToFocus;
                 switch (ev.key) {
                     case 'ArrowDown':
                         ev.preventDefault();
-                        partsToFocus = data.getNextWeek(parts);
+                        partsToFocus = format.getNextWeek(parts);
                         break;
                     case 'ArrowUp':
                         ev.preventDefault();
-                        partsToFocus = data.getPreviousWeek(parts);
+                        partsToFocus = format.getPreviousWeek(parts);
                         break;
                     case 'ArrowRight':
                         ev.preventDefault();
-                        partsToFocus = data.getNextDay(parts);
+                        partsToFocus = format.getNextDay(parts);
                         break;
                     case 'ArrowLeft':
                         ev.preventDefault();
-                        partsToFocus = data.getPreviousDay(parts);
+                        partsToFocus = format.getPreviousDay(parts);
                         break;
                     case 'Home':
                         ev.preventDefault();
-                        partsToFocus = data.getStartOfWeek(parts);
+                        partsToFocus = format.getStartOfWeek(parts);
                         break;
                     case 'End':
                         ev.preventDefault();
-                        partsToFocus = data.getEndOfWeek(parts);
+                        partsToFocus = format.getEndOfWeek(parts);
                         break;
                     case 'PageUp':
                         ev.preventDefault();
-                        partsToFocus = ev.shiftKey ? data.getPreviousYear(parts) : data.getPreviousMonth(parts);
+                        partsToFocus = ev.shiftKey ? format.getPreviousYear(parts) : format.getPreviousMonth(parts);
                         break;
                     case 'PageDown':
                         ev.preventDefault();
-                        partsToFocus = ev.shiftKey ? data.getNextYear(parts) : data.getNextMonth(parts);
+                        partsToFocus = ev.shiftKey ? format.getNextYear(parts) : format.getNextMonth(parts);
                         break;
                     /**
                      * Do not preventDefault here
@@ -598,7 +1121,7 @@ const Datetime = class {
                 this.minParts = undefined;
                 return;
             }
-            this.minParts = data.parseMinParts(min, defaultParts);
+            this.minParts = format.parseMinParts(min, defaultParts);
         };
         this.processMaxParts = () => {
             const { max, defaultParts } = this;
@@ -606,7 +1129,7 @@ const Datetime = class {
                 this.maxParts = undefined;
                 return;
             }
-            this.maxParts = data.parseMaxParts(max, defaultParts);
+            this.maxParts = format.parseMaxParts(max, defaultParts);
         };
         this.initializeCalendarListener = () => {
             const calendarBodyRef = this.calendarBodyRef;
@@ -689,10 +1212,10 @@ const Datetime = class {
                      * the scroll callback early.
                      */
                     if (month === startMonth) {
-                        return data.getPreviousMonth(parts);
+                        return format.getPreviousMonth(parts);
                     }
                     else if (month === endMonth) {
-                        return data.getNextMonth(parts);
+                        return format.getNextMonth(parts);
                     }
                     else {
                         return;
@@ -841,7 +1364,7 @@ const Datetime = class {
         };
         this.processValue = (value) => {
             const hasValue = value !== null && value !== undefined && value !== '' && (!Array.isArray(value) || value.length > 0);
-            const valueToProcess = hasValue ? data.parseDate(value) : this.defaultParts;
+            const valueToProcess = hasValue ? format.parseDate(value) : this.defaultParts;
             const { minParts, maxParts, workingParts, el } = this;
             this.warnIfIncorrectValueUsage();
             /**
@@ -860,7 +1383,7 @@ const Datetime = class {
              * not true.
              */
             if (hasValue) {
-                data.warnIfValueOutOfBounds(valueToProcess, minParts, maxParts);
+                format.warnIfValueOutOfBounds(valueToProcess, minParts, maxParts);
             }
             /**
              * If there are multiple values, clamp to the last one.
@@ -868,9 +1391,9 @@ const Datetime = class {
              * has most recently interacted with.
              */
             const singleValue = Array.isArray(valueToProcess) ? valueToProcess[valueToProcess.length - 1] : valueToProcess;
-            const targetValue = data.clampDate(singleValue, minParts, maxParts);
+            const targetValue = format.clampDate(singleValue, minParts, maxParts);
             const { month, day, year, hour, minute } = targetValue;
-            const ampm = data.parseAmPm(hour);
+            const ampm = format.parseAmPm(hour);
             /**
              * Since `activeParts` indicates a value that been explicitly selected
              * either by the user or the app, only update `activeParts` if the
@@ -946,7 +1469,7 @@ const Datetime = class {
              * Animate smoothly to the forced month. This will also update
              * workingParts and correct the surrounding months for us.
              */
-            const targetMonthIsBefore = data.isBefore(targetValue, workingParts);
+            const targetMonthIsBefore = format.isBefore(targetValue, workingParts);
             targetMonthIsBefore ? this.prevMonth() : this.nextMonth();
             await forceDateScrollingPromise;
             this.resolveForceDateScrolling = undefined;
@@ -1021,19 +1544,19 @@ const Datetime = class {
         return hasDatePresentation && !preferWheel;
     }
     yearValuesChanged() {
-        this.parsedYearValues = data.convertToArrayOfNumbers(this.yearValues);
+        this.parsedYearValues = format.convertToArrayOfNumbers(this.yearValues);
     }
     monthValuesChanged() {
-        this.parsedMonthValues = data.convertToArrayOfNumbers(this.monthValues);
+        this.parsedMonthValues = format.convertToArrayOfNumbers(this.monthValues);
     }
     dayValuesChanged() {
-        this.parsedDayValues = data.convertToArrayOfNumbers(this.dayValues);
+        this.parsedDayValues = format.convertToArrayOfNumbers(this.dayValues);
     }
     hourValuesChanged() {
-        this.parsedHourValues = data.convertToArrayOfNumbers(this.hourValues);
+        this.parsedHourValues = format.convertToArrayOfNumbers(this.hourValues);
     }
     minuteValuesChanged() {
-        this.parsedMinuteValues = data.convertToArrayOfNumbers(this.minuteValues);
+        this.parsedMinuteValues = format.convertToArrayOfNumbers(this.minuteValues);
     }
     /**
      * Update the datetime value when the value changes
@@ -1067,14 +1590,14 @@ const Datetime = class {
                      * active parts are empty, then the user has confirmed the
                      * initial value (working parts) presented to them.
                      */
-                    this.setValue(data.convertDataToISO(workingParts));
+                    this.setValue(format.convertDataToISO(workingParts));
                 }
                 else {
                     this.setValue(undefined);
                 }
             }
             else {
-                this.setValue(data.convertDataToISO(activeParts));
+                this.setValue(format.convertDataToISO(activeParts));
             }
         }
         if (closeOverlay) {
@@ -1105,6 +1628,16 @@ const Datetime = class {
             this.closeParentOverlay(CANCEL_ROLE);
         }
     }
+    /**
+     * Returns the default parts the datetime falls back to when no value is set:
+     * today's date and time snapped to the closest value allowed by the
+     * component's constraints (`min`, `max`, and the `*Values` props).
+     *
+     * @internal
+     */
+    async getDefaultPart() {
+        return this.defaultParts;
+    }
     get isCalendarPicker() {
         const { presentation } = this;
         return presentation === 'date' || presentation === 'date-time' || presentation === 'time-date';
@@ -1292,15 +1825,15 @@ const Datetime = class {
             checkForPresentationFormatMismatch(el, presentation, formatOptions);
             warnIfTimeZoneProvided(el, formatOptions);
         }
-        const hourValues = (this.parsedHourValues = data.convertToArrayOfNumbers(this.hourValues));
-        const minuteValues = (this.parsedMinuteValues = data.convertToArrayOfNumbers(this.minuteValues));
-        const monthValues = (this.parsedMonthValues = data.convertToArrayOfNumbers(this.monthValues));
-        const yearValues = (this.parsedYearValues = data.convertToArrayOfNumbers(this.yearValues));
-        const dayValues = (this.parsedDayValues = data.convertToArrayOfNumbers(this.dayValues));
-        const todayParts = (this.todayParts = data.parseDate(data.getToday()));
+        const hourValues = (this.parsedHourValues = format.convertToArrayOfNumbers(this.hourValues));
+        const minuteValues = (this.parsedMinuteValues = format.convertToArrayOfNumbers(this.minuteValues));
+        const monthValues = (this.parsedMonthValues = format.convertToArrayOfNumbers(this.monthValues));
+        const yearValues = (this.parsedYearValues = format.convertToArrayOfNumbers(this.yearValues));
+        const dayValues = (this.parsedDayValues = format.convertToArrayOfNumbers(this.dayValues));
+        const todayParts = (this.todayParts = format.parseDate(getToday()));
         this.processMinParts();
         this.processMaxParts();
-        this.defaultParts = data.getClosestValidDate({
+        this.defaultParts = format.getClosestValidDate({
             refParts: todayParts,
             monthValues,
             dayValues,
@@ -1383,13 +1916,13 @@ const Datetime = class {
          * By default, generate a range of 3 months:
          * Previous month, current month, and next month
          */
-        const monthsToRender = data.generateMonths(workingParts);
+        const monthsToRender = generateMonths(workingParts);
         const lastMonth = monthsToRender[monthsToRender.length - 1];
         /**
          * Ensure that users can select the entire window of dates.
          */
         monthsToRender[0].day = 1;
-        lastMonth.day = data.getNumDaysInMonth(lastMonth.month, lastMonth.year);
+        lastMonth.day = format.getNumDaysInMonth(lastMonth.month, lastMonth.year);
         /**
          * Narrow the dates rendered based on min/max dates (if any).
          * The `min` date is used if the min is after the generated min month.
@@ -1398,9 +1931,9 @@ const Datetime = class {
          * but still allows future dates to be lazily rendered based on any min/max
          * constraints.
          */
-        const min = minParts !== undefined && data.isAfter(minParts, monthsToRender[0]) ? minParts : monthsToRender[0];
-        const max = maxParts !== undefined && data.isBefore(maxParts, lastMonth) ? maxParts : lastMonth;
-        const result = data.getCombinedDateColumnData(locale, todayParts, min, max, this.parsedDayValues, this.parsedMonthValues);
+        const min = minParts !== undefined && format.isAfter(minParts, monthsToRender[0]) ? minParts : monthsToRender[0];
+        const max = maxParts !== undefined && format.isBefore(maxParts, lastMonth) ? maxParts : lastMonth;
+        const result = getCombinedDateColumnData(locale, todayParts, min, max, this.parsedDayValues, this.parsedMonthValues);
         let items = result.items;
         const parts = result.parts;
         if (isDateEnabled) {
@@ -1413,7 +1946,7 @@ const Datetime = class {
                      * to prevent exceptions in the user's function from
                      * interrupting the calendar rendering.
                      */
-                    disabled = !isDateEnabled(data.convertDataToISO(referenceParts));
+                    disabled = !isDateEnabled(format.convertDataToISO(referenceParts));
                 }
                 catch (e) {
                     index.printIonError('[ion-datetime] - Exception thrown from provided `isDateEnabled` function. Please check your function and try again.', e);
@@ -1440,11 +1973,11 @@ const Datetime = class {
         const { workingParts, isDateEnabled } = this;
         const shouldRenderMonths = forcePresentation !== 'year' && forcePresentation !== 'time';
         const months = shouldRenderMonths
-            ? data.getMonthColumnData(this.locale, workingParts, this.minParts, this.maxParts, this.parsedMonthValues)
+            ? getMonthColumnData(this.locale, workingParts, this.minParts, this.maxParts, this.parsedMonthValues)
             : [];
         const shouldRenderDays = forcePresentation === 'date';
         let days = shouldRenderDays
-            ? data.getDayColumnData(this.locale, workingParts, this.minParts, this.maxParts, this.parsedDayValues)
+            ? getDayColumnData(this.locale, workingParts, this.minParts, this.maxParts, this.parsedDayValues)
             : [];
         if (isDateEnabled) {
             days = days.map((dayObject) => {
@@ -1462,7 +1995,7 @@ const Datetime = class {
                      * to prevent exceptions in the user's function from
                      * interrupting the calendar rendering.
                      */
-                    disabled = !isDateEnabled(data.convertDataToISO(referenceParts));
+                    disabled = !isDateEnabled(format.convertDataToISO(referenceParts));
                 }
                 catch (e) {
                     index.printIonError('[ion-datetime] - Exception thrown from provided `isDateEnabled` function. Please check your function and try again.', e);
@@ -1472,12 +2005,12 @@ const Datetime = class {
         }
         const shouldRenderYears = forcePresentation !== 'month' && forcePresentation !== 'time';
         const years = shouldRenderYears
-            ? data.getYearColumnData(this.locale, this.defaultParts, this.minParts, this.maxParts, this.parsedYearValues)
+            ? getYearColumnData(this.locale, this.defaultParts, this.minParts, this.maxParts, this.parsedYearValues)
             : [];
         /**
          * Certain locales show the day before the month.
          */
-        const showMonthFirst = data.isMonthFirstLocale(this.locale, { month: 'numeric', day: 'numeric' });
+        const showMonthFirst = format.isMonthFirstLocale(this.locale, { month: 'numeric', day: 'numeric' });
         let renderArray = [];
         if (showMonthFirst) {
             renderArray = [
@@ -1548,7 +2081,7 @@ const Datetime = class {
          */
         const activePart = this.getActivePart();
         const userHasSelectedDate = activePart !== undefined;
-        const { hoursData, minutesData, dayPeriodData } = data.getTimeColumnsData(this.locale, this.workingParts, this.hourCycle, userHasSelectedDate ? this.minParts : undefined, userHasSelectedDate ? this.maxParts : undefined, this.parsedHourValues, this.parsedMinuteValues);
+        const { hoursData, minutesData, dayPeriodData } = getTimeColumnsData(this.locale, this.workingParts, this.hourCycle, userHasSelectedDate ? this.minParts : undefined, userHasSelectedDate ? this.maxParts : undefined, this.parsedHourValues, this.parsedMinuteValues);
         return [
             this.renderHourPickerColumn(hoursData),
             this.renderMinutePickerColumn(minutesData),
@@ -1583,9 +2116,9 @@ const Datetime = class {
             return [];
         }
         const activePart = this.getActivePartsWithFallback();
-        const isDayPeriodRTL = data.isLocaleDayPeriodRTL(this.locale);
+        const isDayPeriodRTL = format.isLocaleDayPeriodRTL(this.locale);
         return (index.h("ion-picker-column", { part: WHEEL_PART, "aria-label": "Select a day period", style: isDayPeriodRTL ? { order: '-1' } : {}, color: this.color, disabled: disabled, value: activePart.ampm, onIonChange: (ev) => {
-                const hour = data.calculateHourFromAMPM(workingParts, ev.detail.value);
+                const hour = format.calculateHourFromAMPM(workingParts, ev.detail.value);
                 this.setWorkingParts(Object.assign(Object.assign({}, workingParts), { ampm: ev.detail.value, hour }));
                 this.setActiveParts(Object.assign(Object.assign({}, this.getActivePartsWithFallback()), { ampm: ev.detail.value, hour }));
                 ev.stopPropagation();
@@ -1593,7 +2126,7 @@ const Datetime = class {
     }
     renderWheelView(forcePresentation) {
         const { locale } = this;
-        const showMonthFirst = data.isMonthFirstLocale(locale);
+        const showMonthFirst = format.isMonthFirstLocale(locale);
         const columnOrder = showMonthFirst ? 'month-first' : 'year-first';
         return (index.h("div", { class: {
                 [`wheel-order-${columnOrder}`]: true,
@@ -1614,7 +2147,7 @@ const Datetime = class {
                 'calendar-month-year-toggle': true,
                 'ion-activatable': true,
                 'ion-focusable': true,
-            }, part: "month-year-button", disabled: disabled, "aria-label": this.showMonthAndYear ? 'Hide year picker' : 'Show year picker', onClick: () => this.toggleMonthAndYearView() }, index.h("span", { id: "toggle-wrapper" }, data.getMonthAndYear(this.locale, this.workingParts), index.h("ion-icon", { "aria-hidden": "true", icon: this.showMonthAndYear ? expandedIcon : collapsedIcon, lazy: false, flipRtl: true })), mode === 'md' && index.h("ion-ripple-effect", null))), index.h("div", { class: "calendar-next-prev" }, index.h("ion-buttons", null, index.h("ion-button", { "aria-label": "Previous month", disabled: prevMonthDisabled, onClick: () => this.prevMonth(), part: "navigation-button previous-button" }, index.h("ion-icon", { dir: hostDir, "aria-hidden": "true", slot: "icon-only", icon: index$1.chevronBack, lazy: false, flipRtl: true })), index.h("ion-button", { "aria-label": "Next month", disabled: nextMonthDisabled, onClick: () => this.nextMonth(), part: "navigation-button next-button" }, index.h("ion-icon", { dir: hostDir, "aria-hidden": "true", slot: "icon-only", icon: index$1.chevronForward, lazy: false, flipRtl: true }))))), index.h("div", { class: "calendar-days-of-week", "aria-hidden": "true", part: "calendar-days-of-week" }, data.getDaysOfWeek(this.locale, mode, this.firstDayOfWeek % 7).map((d) => {
+            }, part: "month-year-button", disabled: disabled, "aria-label": this.showMonthAndYear ? 'Hide year picker' : 'Show year picker', onClick: () => this.toggleMonthAndYearView() }, index.h("span", { id: "toggle-wrapper" }, format.getMonthAndYear(this.locale, this.workingParts), index.h("ion-icon", { "aria-hidden": "true", icon: this.showMonthAndYear ? expandedIcon : collapsedIcon, lazy: false, flipRtl: true })), mode === 'md' && index.h("ion-ripple-effect", null))), index.h("div", { class: "calendar-next-prev" }, index.h("ion-buttons", null, index.h("ion-button", { "aria-label": "Previous month", disabled: prevMonthDisabled, onClick: () => this.prevMonth(), part: "navigation-button previous-button" }, index.h("ion-icon", { dir: hostDir, "aria-hidden": "true", slot: "icon-only", icon: index$1.chevronBack, lazy: false, flipRtl: true })), index.h("ion-button", { "aria-label": "Next month", disabled: nextMonthDisabled, onClick: () => this.nextMonth(), part: "navigation-button next-button" }, index.h("ion-icon", { dir: hostDir, "aria-hidden": "true", slot: "icon-only", icon: index$1.chevronForward, lazy: false, flipRtl: true }))))), index.h("div", { class: "calendar-days-of-week", "aria-hidden": "true", part: "calendar-days-of-week" }, getDaysOfWeek(this.locale, mode, this.firstDayOfWeek % 7).map((d) => {
             return index.h("div", { class: "day-of-week" }, d);
         }))));
     }
@@ -1645,7 +2178,7 @@ const Datetime = class {
                 'calendar-month': true,
                 // Prevents scroll snap swipe gestures for months outside of the min/max bounds
                 'calendar-month-disabled': !isWorkingMonth && swipeDisabled,
-            } }, index.h("div", { class: "calendar-month-grid" }, data.getDaysOfMonth(month, year, this.firstDayOfWeek % 7, this.showAdjacentDays).map((dateObject, index$1) => {
+            } }, index.h("div", { class: "calendar-month-grid" }, getDaysOfMonth(month, year, this.firstDayOfWeek % 7, this.showAdjacentDays).map((dateObject, index$1) => {
             const { day, dayOfWeek, isAdjacentDay } = dateObject;
             const { el, highlightedDates, isDateEnabled, multiple, showAdjacentDays } = this;
             let _month = month;
@@ -1677,7 +2210,7 @@ const Datetime = class {
             const referenceParts = { month: _month, day, year: _year, isAdjacentDay };
             const isCalendarPadding = day === null;
             const { isActive, isToday, ariaLabel, ariaSelected, disabled: isDayDisabled, text, } = getCalendarDayState(this.locale, referenceParts, this.activeParts, this.todayParts, this.minParts, this.maxParts, this.parsedDayValues);
-            const dateIsoString = data.convertDataToISO(referenceParts);
+            const dateIsoString = format.convertDataToISO(referenceParts);
             let isCalDayDisabled = isCalMonthDisabled || isDayDisabled;
             if (!isCalDayDisabled && isDateEnabled !== undefined) {
                 try {
@@ -1762,7 +2295,7 @@ const Datetime = class {
         }))));
     }
     renderCalendarBody() {
-        return (index.h("div", { class: "calendar-body ion-focusable", ref: (el) => (this.calendarBodyRef = el), tabindex: "0" }, data.generateMonths(this.workingParts, this.forceRenderDate).map(({ month, year }) => {
+        return (index.h("div", { class: "calendar-body ion-focusable", ref: (el) => (this.calendarBodyRef = el), tabindex: "0" }, generateMonths(this.workingParts, this.forceRenderDate).map(({ month, year }) => {
             return this.renderMonth(month, year);
         })));
     }
@@ -1778,7 +2311,7 @@ const Datetime = class {
     }
     renderTimeOverlay() {
         const { disabled, hourCycle, isTimePopoverOpen, locale, formatOptions } = this;
-        const computedHourCycle = data.getHourCycle(locale, hourCycle);
+        const computedHourCycle = format.getHourCycle(locale, hourCycle);
         const activePart = this.getActivePartsWithFallback();
         return [
             index.h("div", { class: "time-header" }, this.renderTimeLabel()),
@@ -1797,7 +2330,7 @@ const Datetime = class {
                         await popoverRef.onWillDismiss();
                         this.isTimePopoverOpen = false;
                     }
-                } }, data.getLocalizedTime(locale, activePart, computedHourCycle, formatOptions === null || formatOptions === void 0 ? void 0 : formatOptions.time)),
+                } }, format.getLocalizedTime(locale, activePart, computedHourCycle, formatOptions === null || formatOptions === void 0 ? void 0 : formatOptions.time)),
             index.h("ion-popover", { alignment: "center", translucent: true, overlayIndex: 1, arrow: false, onWillPresent: (ev) => {
                     /**
                      * Intersection Observers do not consistently fire between Blink and Webkit
@@ -1828,7 +2361,7 @@ const Datetime = class {
             headerText = `${activeParts.length} days`; // default/fallback for multiple selection
             if (titleSelectedDatesFormatter !== undefined) {
                 try {
-                    headerText = titleSelectedDatesFormatter(data.convertDataToISO(activeParts));
+                    headerText = titleSelectedDatesFormatter(format.convertDataToISO(activeParts));
                 }
                 catch (e) {
                     index.printIonError('[ion-datetime] - Exception in provided `titleSelectedDatesFormatter`:', e);
@@ -1837,7 +2370,7 @@ const Datetime = class {
         }
         else {
             // for exactly 1 day selected (multiple set or not), show a formatted version of that
-            headerText = data.getLocalizedDateTime(this.locale, this.getActivePartsWithFallback(), (_a = formatOptions === null || formatOptions === void 0 ? void 0 : formatOptions.date) !== null && _a !== void 0 ? _a : { weekday: 'short', month: 'short', day: 'numeric' });
+            headerText = format.getLocalizedDateTime(this.locale, this.getActivePartsWithFallback(), (_a = formatOptions === null || formatOptions === void 0 ? void 0 : formatOptions.date) !== null && _a !== void 0 ? _a : { weekday: 'short', month: 'short', day: 'numeric' });
         }
         return headerText;
     }
@@ -1925,8 +2458,8 @@ const Datetime = class {
         const monthYearPickerOpen = showMonthAndYear && !isMonthAndYearPresentation;
         const hasDatePresentation = presentation === 'date' || presentation === 'date-time' || presentation === 'time-date';
         const hasWheelVariant = hasDatePresentation && preferWheel;
-        helpers.renderHiddenInput(true, el, name, data.formatValue(value), disabled);
-        return (index.h(index.Host, { key: '323c8c2327088f00934b8c93c3306538cb9b5677', "aria-disabled": disabled ? 'true' : null, onFocus: this.onFocus, onBlur: this.onBlur, class: Object.assign({}, theme.createColorClasses(color, {
+        helpers.renderHiddenInput(true, el, name, format.formatValue(value), disabled);
+        return (index.h(index.Host, { key: '0a7b458dac2de870a81d2495b5fc7ac86989f2b8', "aria-disabled": disabled ? 'true' : null, onFocus: this.onFocus, onBlur: this.onBlur, class: Object.assign({}, theme.createColorClasses(color, {
                 [mode]: true,
                 ['datetime-readonly']: readonly,
                 ['datetime-disabled']: disabled,
@@ -1936,7 +2469,7 @@ const Datetime = class {
                 [`datetime-size-${size}`]: true,
                 [`datetime-prefer-wheel`]: hasWheelVariant,
                 [`datetime-grid`]: isGridStyle,
-            })) }, index.h("div", { key: '1e0855c8909bc3f1e48a21ad68159fa782060691', class: "intersection-tracker", ref: (el) => (this.intersectionTrackerRef = el) }), this.renderDatetime(mode)));
+            })) }, index.h("div", { key: '47e77df9dd5846d46addc210d29287f34bf3cd56', class: "intersection-tracker", ref: (el) => (this.intersectionTrackerRef = el) }), this.renderDatetime(mode)));
     }
     get el() { return index.getElement(this); }
     static get watchers() { return {