@ionic/core 7.6.1-dev.11702048520.13c82dad → 7.6.1-dev.11702322681.17e39348

package/components/data.js

@@ -716,32 +716,82 @@ const validateParts = (parts, minParts, maxParts) => {
  * Returns the closest date to refParts
  * that also meets the constraints of
  * the *Values params.
- * @param refParts The reference date
- * @param monthValues The allowed month values
- * @param dayValues The allowed day (of the month) values
- * @param yearValues The allowed year values
- * @param hourValues The allowed hour values
- * @param minuteValues The allowed minute values
  */
-const getClosestValidDate = (refParts, monthValues, dayValues, yearValues, hourValues, minuteValues) => {
+const getClosestValidDate = ({ refParts, monthValues, dayValues, yearValues, hourValues, minuteValues, minParts, maxParts, }) => {
     const { hour, minute, day, month, year } = refParts;
     const copyParts = Object.assign(Object.assign({}, refParts), { dayOfWeek: undefined });
+    if (yearValues !== undefined) {
+        // Filters out years that are out of the min/max bounds
+        const filteredYears = yearValues.filter((year) => {
+            if (minParts !== undefined && year < minParts.year) {
+                return false;
+            }
+            if (maxParts !== undefined && year > maxParts.year) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.year = findClosestValue(year, filteredYears);
+    }
     if (monthValues !== undefined) {
-        copyParts.month = findClosestValue(month, monthValues);
+        // Filters out months that are out of the min/max bounds
+        const filteredMonths = monthValues.filter((month) => {
+            if (minParts !== undefined && copyParts.year === minParts.year && month < minParts.month) {
+                return false;
+            }
+            if (maxParts !== undefined && copyParts.year === maxParts.year && month > maxParts.month) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.month = findClosestValue(month, filteredMonths);
     }
     // Day is nullable but cannot be undefined
     if (day !== null && dayValues !== undefined) {
-        copyParts.day = findClosestValue(day, dayValues);
-    }
-    if (yearValues !== undefined) {
-        copyParts.year = findClosestValue(year, yearValues);
+        // Filters out days that are out of the min/max bounds
+        const filteredDays = dayValues.filter((day) => {
+            if (minParts !== undefined && isBefore(Object.assign(Object.assign({}, copyParts), { day }), minParts)) {
+                return false;
+            }
+            if (maxParts !== undefined && isAfter(Object.assign(Object.assign({}, copyParts), { day }), maxParts)) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.day = findClosestValue(day, filteredDays);
     }
     if (hour !== undefined && hourValues !== undefined) {
-        copyParts.hour = findClosestValue(hour, hourValues);
+        // Filters out hours that are out of the min/max bounds
+        const filteredHours = hourValues.filter((hour) => {
+            if ((minParts === null || minParts === void 0 ? void 0 : minParts.hour) !== undefined && isSameDay(copyParts, minParts) && hour < minParts.hour) {
+                return false;
+            }
+            if ((maxParts === null || maxParts === void 0 ? void 0 : maxParts.hour) !== undefined && isSameDay(copyParts, maxParts) && hour > maxParts.hour) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.hour = findClosestValue(hour, filteredHours);
         copyParts.ampm = parseAmPm(copyParts.hour);
     }
     if (minute !== undefined && minuteValues !== undefined) {
-        copyParts.minute = findClosestValue(minute, minuteValues);
+        // Filters out minutes that are out of the min/max bounds
+        const filteredMinutes = minuteValues.filter((minute) => {
+            if ((minParts === null || minParts === void 0 ? void 0 : minParts.minute) !== undefined &&
+                isSameDay(copyParts, minParts) &&
+                copyParts.hour === minParts.hour &&
+                minute < minParts.minute) {
+                return false;
+            }
+            if ((maxParts === null || maxParts === void 0 ? void 0 : maxParts.minute) !== undefined &&
+                isSameDay(copyParts, maxParts) &&
+                copyParts.hour === maxParts.hour &&
+                minute > maxParts.minute) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.minute = findClosestValue(minute, filteredMinutes);
     }
     return copyParts;
 };

package/components/ion-datetime.js

@@ -867,14 +867,24 @@ const Datetime = /*@__PURE__*/ proxyCustomElement(class Datetime extends HTMLEle
      * or modal that the datetime was presented in.
      */
     async confirm(closeOverlay = false) {
-        const { isCalendarPicker, activeParts } = this;
+        const { isCalendarPicker, activeParts, preferWheel, workingParts } = this;
         /**
          * We only update the value if the presentation is not a calendar picker.
          */
         if (activeParts !== undefined || !isCalendarPicker) {
             const activePartsIsArray = Array.isArray(activeParts);
             if (activePartsIsArray && activeParts.length === 0) {
-                this.setValue(undefined);
+                if (preferWheel) {
+                    /**
+                     * If the datetime is using a wheel picker, but the
+                     * active parts are empty, then the user has confirmed the
+                     * initial value (working parts) presented to them.
+                     */
+                    this.setValue(convertDataToISO(workingParts));
+                }
+                else {
+                    this.setValue(undefined);
+                }
             }
             else {
                 this.setValue(convertDataToISO(activeParts));
@@ -1078,9 +1088,18 @@ const Datetime = /*@__PURE__*/ proxyCustomElement(class Datetime extends HTMLEle
         const yearValues = (this.parsedYearValues = convertToArrayOfNumbers(this.yearValues));
         const dayValues = (this.parsedDayValues = convertToArrayOfNumbers(this.dayValues));
         const todayParts = (this.todayParts = parseDate(getToday()));
-        this.defaultParts = getClosestValidDate(todayParts, monthValues, dayValues, yearValues, hourValues, minuteValues);
         this.processMinParts();
         this.processMaxParts();
+        this.defaultParts = getClosestValidDate({
+            refParts: todayParts,
+            monthValues,
+            dayValues,
+            yearValues,
+            hourValues,
+            minuteValues,
+            minParts: this.minParts,
+            maxParts: this.maxParts,
+        });
         this.processValue(this.value);
         this.emitStyle();
     }

package/dist/cjs/{data-36b9094e.js → data-a5109f09.js}

@@ -718,32 +718,82 @@ const validateParts = (parts, minParts, maxParts) => {
  * Returns the closest date to refParts
  * that also meets the constraints of
  * the *Values params.
- * @param refParts The reference date
- * @param monthValues The allowed month values
- * @param dayValues The allowed day (of the month) values
- * @param yearValues The allowed year values
- * @param hourValues The allowed hour values
- * @param minuteValues The allowed minute values
  */
-const getClosestValidDate = (refParts, monthValues, dayValues, yearValues, hourValues, minuteValues) => {
+const getClosestValidDate = ({ refParts, monthValues, dayValues, yearValues, hourValues, minuteValues, minParts, maxParts, }) => {
     const { hour, minute, day, month, year } = refParts;
     const copyParts = Object.assign(Object.assign({}, refParts), { dayOfWeek: undefined });
+    if (yearValues !== undefined) {
+        // Filters out years that are out of the min/max bounds
+        const filteredYears = yearValues.filter((year) => {
+            if (minParts !== undefined && year < minParts.year) {
+                return false;
+            }
+            if (maxParts !== undefined && year > maxParts.year) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.year = findClosestValue(year, filteredYears);
+    }
     if (monthValues !== undefined) {
-        copyParts.month = findClosestValue(month, monthValues);
+        // Filters out months that are out of the min/max bounds
+        const filteredMonths = monthValues.filter((month) => {
+            if (minParts !== undefined && copyParts.year === minParts.year && month < minParts.month) {
+                return false;
+            }
+            if (maxParts !== undefined && copyParts.year === maxParts.year && month > maxParts.month) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.month = findClosestValue(month, filteredMonths);
     }
     // Day is nullable but cannot be undefined
     if (day !== null && dayValues !== undefined) {
-        copyParts.day = findClosestValue(day, dayValues);
-    }
-    if (yearValues !== undefined) {
-        copyParts.year = findClosestValue(year, yearValues);
+        // Filters out days that are out of the min/max bounds
+        const filteredDays = dayValues.filter((day) => {
+            if (minParts !== undefined && isBefore(Object.assign(Object.assign({}, copyParts), { day }), minParts)) {
+                return false;
+            }
+            if (maxParts !== undefined && isAfter(Object.assign(Object.assign({}, copyParts), { day }), maxParts)) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.day = findClosestValue(day, filteredDays);
     }
     if (hour !== undefined && hourValues !== undefined) {
-        copyParts.hour = findClosestValue(hour, hourValues);
+        // Filters out hours that are out of the min/max bounds
+        const filteredHours = hourValues.filter((hour) => {
+            if ((minParts === null || minParts === void 0 ? void 0 : minParts.hour) !== undefined && isSameDay(copyParts, minParts) && hour < minParts.hour) {
+                return false;
+            }
+            if ((maxParts === null || maxParts === void 0 ? void 0 : maxParts.hour) !== undefined && isSameDay(copyParts, maxParts) && hour > maxParts.hour) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.hour = findClosestValue(hour, filteredHours);
         copyParts.ampm = parseAmPm(copyParts.hour);
     }
     if (minute !== undefined && minuteValues !== undefined) {
-        copyParts.minute = findClosestValue(minute, minuteValues);
+        // Filters out minutes that are out of the min/max bounds
+        const filteredMinutes = minuteValues.filter((minute) => {
+            if ((minParts === null || minParts === void 0 ? void 0 : minParts.minute) !== undefined &&
+                isSameDay(copyParts, minParts) &&
+                copyParts.hour === minParts.hour &&
+                minute < minParts.minute) {
+                return false;
+            }
+            if ((maxParts === null || maxParts === void 0 ? void 0 : maxParts.minute) !== undefined &&
+                isSameDay(copyParts, maxParts) &&
+                copyParts.hour === maxParts.hour &&
+                minute > maxParts.minute) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.minute = findClosestValue(minute, filteredMinutes);
     }
     return copyParts;
 };

package/dist/cjs/ion-datetime-button.cjs.entry.js

@@ -10,7 +10,7 @@ const helpers = require('./helpers-76bb7efb.js');
 const index$1 = require('./index-5915f9b3.js');
 const theme = require('./theme-d1c573d2.js');
 const ionicGlobal = require('./ionic-global-f4a2093b.js');
-const data = require('./data-36b9094e.js');
+const data = require('./data-a5109f09.js');
 
 const iosDatetimeButtonCss = ":host{display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;-ms-flex-align:center;align-items:center;-ms-flex-pack:center;justify-content:center}:host button{border-radius:8px;-webkit-padding-start:12px;padding-inline-start:12px;-webkit-padding-end:12px;padding-inline-end:12px;padding-top:6px;padding-bottom:6px;-webkit-margin-start:2px;margin-inline-start:2px;-webkit-margin-end:2px;margin-inline-end:2px;margin-top:0px;margin-bottom:0px;position:relative;-webkit-transition:150ms color ease-in-out;transition:150ms color ease-in-out;border:none;background:var(--ion-color-step-300, #edeef0);color:var(--ion-text-color, #000);font-family:inherit;font-size:1rem;cursor:pointer;overflow:hidden;-webkit-appearance:none;-moz-appearance:none;appearance:none}:host(.time-active) #time-button,:host(.date-active) #date-button{color:var(--ion-color-base)}:host(.datetime-button-disabled){pointer-events:none}:host(.datetime-button-disabled) button{opacity:0.4}";
 

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

@@ -13,7 +13,7 @@ const dir = require('./dir-94c21456.js');
 const theme = require('./theme-d1c573d2.js');
 const index$2 = require('./index-09471526.js');
 const ionicGlobal = require('./ionic-global-f4a2093b.js');
-const data = require('./data-36b9094e.js');
+const data = require('./data-a5109f09.js');
 const lockController = require('./lock-controller-6585a42a.js');
 const overlays = require('./overlays-27a6fb16.js');
 const animation = require('./animation-9b401d39.js');
@@ -866,14 +866,24 @@ const Datetime = class {
      * or modal that the datetime was presented in.
      */
     async confirm(closeOverlay = false) {
-        const { isCalendarPicker, activeParts } = this;
+        const { isCalendarPicker, activeParts, preferWheel, workingParts } = this;
         /**
          * We only update the value if the presentation is not a calendar picker.
          */
         if (activeParts !== undefined || !isCalendarPicker) {
             const activePartsIsArray = Array.isArray(activeParts);
             if (activePartsIsArray && activeParts.length === 0) {
-                this.setValue(undefined);
+                if (preferWheel) {
+                    /**
+                     * If the datetime is using a wheel picker, but the
+                     * active parts are empty, then the user has confirmed the
+                     * initial value (working parts) presented to them.
+                     */
+                    this.setValue(data.convertDataToISO(workingParts));
+                }
+                else {
+                    this.setValue(undefined);
+                }
             }
             else {
                 this.setValue(data.convertDataToISO(activeParts));
@@ -1077,9 +1087,18 @@ const Datetime = class {
         const yearValues = (this.parsedYearValues = data.convertToArrayOfNumbers(this.yearValues));
         const dayValues = (this.parsedDayValues = data.convertToArrayOfNumbers(this.dayValues));
         const todayParts = (this.todayParts = data.parseDate(data.getToday()));
-        this.defaultParts = data.getClosestValidDate(todayParts, monthValues, dayValues, yearValues, hourValues, minuteValues);
         this.processMinParts();
         this.processMaxParts();
+        this.defaultParts = data.getClosestValidDate({
+            refParts: todayParts,
+            monthValues,
+            dayValues,
+            yearValues,
+            hourValues,
+            minuteValues,
+            minParts: this.minParts,
+            maxParts: this.maxParts,
+        });
         this.processValue(this.value);
         this.emitStyle();
     }

package/dist/collection/components/datetime/datetime.js

@@ -704,14 +704,24 @@ export class Datetime {
      * or modal that the datetime was presented in.
      */
     async confirm(closeOverlay = false) {
-        const { isCalendarPicker, activeParts } = this;
+        const { isCalendarPicker, activeParts, preferWheel, workingParts } = this;
         /**
          * We only update the value if the presentation is not a calendar picker.
          */
         if (activeParts !== undefined || !isCalendarPicker) {
             const activePartsIsArray = Array.isArray(activeParts);
             if (activePartsIsArray && activeParts.length === 0) {
-                this.setValue(undefined);
+                if (preferWheel) {
+                    /**
+                     * If the datetime is using a wheel picker, but the
+                     * active parts are empty, then the user has confirmed the
+                     * initial value (working parts) presented to them.
+                     */
+                    this.setValue(convertDataToISO(workingParts));
+                }
+                else {
+                    this.setValue(undefined);
+                }
             }
             else {
                 this.setValue(convertDataToISO(activeParts));
@@ -915,9 +925,18 @@ export class Datetime {
         const yearValues = (this.parsedYearValues = convertToArrayOfNumbers(this.yearValues));
         const dayValues = (this.parsedDayValues = convertToArrayOfNumbers(this.dayValues));
         const todayParts = (this.todayParts = parseDate(getToday()));
-        this.defaultParts = getClosestValidDate(todayParts, monthValues, dayValues, yearValues, hourValues, minuteValues);
         this.processMinParts();
         this.processMaxParts();
+        this.defaultParts = getClosestValidDate({
+            refParts: todayParts,
+            monthValues,
+            dayValues,
+            yearValues,
+            hourValues,
+            minuteValues,
+            minParts: this.minParts,
+            maxParts: this.maxParts,
+        });
         this.processValue(this.value);
         this.emitStyle();
     }

package/dist/collection/components/datetime/test/manipulation.spec.js

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { getPreviousYear, getNextYear, getPreviousMonth, getNextMonth, getPreviousDay, getNextDay, getPreviousWeek, getNextWeek, getEndOfWeek, getStartOfWeek, convert12HourTo24Hour, getInternalHourValue, calculateHourFromAMPM, subtractDays, addDays, validateParts, } from "../utils/manipulation";
+import { getPreviousYear, getNextYear, getPreviousMonth, getNextMonth, getPreviousDay, getNextDay, getPreviousWeek, getNextWeek, getEndOfWeek, getStartOfWeek, convert12HourTo24Hour, getInternalHourValue, calculateHourFromAMPM, subtractDays, addDays, validateParts, getClosestValidDate, } from "../utils/manipulation";
 describe('addDays()', () => {
     it('should correctly add days', () => {
         expect(addDays({
@@ -431,3 +431,135 @@ describe('validateParts()', () => {
         })).toEqual({ month: 1, day: 1, year: 2022, hour: 9, minute: 30 });
     });
 });
+describe('getClosestValidDate()', () => {
+    it('should match a date with only month/day/year', () => {
+        // October 10, 2023
+        const refParts = { month: 10, day: 10, year: 2023 };
+        // April 10, 2021
+        const minParts = { month: 4, day: 10, year: 2021 };
+        // September 14, 2021
+        const maxParts = { month: 9, day: 14, year: 2021 };
+        // September 4, 2021
+        const expected = { month: 9, day: 4, year: 2021, dayOfWeek: undefined };
+        expect(getClosestValidDate({
+            refParts,
+            monthValues: [2, 3, 7, 9, 10],
+            dayValues: [4, 15, 25],
+            yearValues: [2020, 2021, 2023],
+            maxParts,
+            minParts,
+        })).toEqual(expected);
+    });
+    it('should match a date when the reference date is before the min', () => {
+        // April 2, 2020 3:20 PM
+        const refParts = { month: 4, day: 2, year: 2020, hour: 15, minute: 20 };
+        // September 10, 2021 10:10 AM
+        const minParts = { month: 9, day: 10, year: 2021, hour: 10, minute: 10 };
+        // September 14, 2021 10:11 AM
+        const maxParts = { month: 9, day: 14, year: 2021, hour: 10, minute: 11 };
+        // September 11, 2021 11:15 AM
+        const expected = {
+            year: 2021,
+            day: 11,
+            month: 9,
+            hour: 11,
+            minute: 15,
+            ampm: 'am',
+            dayOfWeek: undefined,
+        };
+        expect(getClosestValidDate({
+            refParts,
+            monthValues: [4, 9, 11],
+            dayValues: [11, 12, 13, 14],
+            yearValues: [2020, 2021, 2023],
+            hourValues: [9, 10, 11],
+            minuteValues: [11, 12, 13, 14, 15],
+            maxParts,
+            minParts,
+        })).toEqual(expected);
+    });
+    it('should match a date when the reference date is before the min', () => {
+        // April 2, 2020 3:20 PM
+        const refParts = { month: 4, day: 2, year: 2020, hour: 15, minute: 20 };
+        // September 10, 2021 10:10 AM
+        const minParts = { month: 9, day: 10, year: 2021, hour: 10, minute: 10 };
+        // September 10, 2021 10:15 AM
+        const maxParts = { month: 9, day: 10, year: 2021, hour: 10, minute: 15 };
+        // September 10, 2021 10:15 AM
+        const expected = {
+            month: 9,
+            day: 10,
+            year: 2021,
+            hour: 10,
+            minute: 15,
+            ampm: 'am',
+            dayOfWeek: undefined,
+        };
+        expect(getClosestValidDate({
+            refParts,
+            monthValues: [4, 9, 11],
+            dayValues: [10, 12, 13, 14],
+            yearValues: [2020, 2021, 2023],
+            hourValues: [9, 10, 11],
+            minuteValues: [11, 12, 13, 14, 15],
+            minParts,
+            maxParts,
+        })).toEqual(expected);
+    });
+    it('should only clamp minutes if within the same day and hour as min/max', () => {
+        // April 2, 2020 9:16 AM
+        const refParts = { month: 4, day: 2, year: 2020, hour: 9, minute: 16 };
+        // September 10, 2021 10:10 AM
+        const minParts = { month: 9, day: 10, year: 2021, hour: 10, minute: 10 };
+        // September 10, 2021 11:15 AM
+        const maxParts = { month: 9, day: 10, year: 2021, hour: 11, minute: 15 };
+        // September 10, 2021 10:16 AM
+        const expected = {
+            month: 9,
+            day: 10,
+            year: 2021,
+            hour: 10,
+            minute: 16,
+            ampm: 'am',
+            dayOfWeek: undefined,
+        };
+        expect(getClosestValidDate({
+            refParts,
+            monthValues: [4, 9, 11],
+            dayValues: [10, 12, 13, 14],
+            yearValues: [2020, 2021, 2023],
+            hourValues: [9, 10, 11],
+            minuteValues: [10, 15, 16],
+            minParts,
+            maxParts,
+        })).toEqual(expected);
+    });
+    it('should return the closest valid date after adjusting the allowed year', () => {
+        // April 2, 2022 9:16 AM
+        const refParts = { month: 4, day: 2, year: 2022, hour: 9, minute: 16 };
+        // September 10, 2021 10:10 AM
+        const minParts = { month: 9, day: 10, year: 2021, hour: 10, minute: 10 };
+        // September 10, 2023 11:15 AM
+        const maxParts = { month: 9, day: 10, year: 2023, hour: 11, minute: 15 };
+        // April 2, 2022 9:16 AM
+        const expected = {
+            month: 4,
+            day: 2,
+            year: 2022,
+            hour: 9,
+            minute: 16,
+            ampm: 'am',
+            dayOfWeek: undefined,
+        };
+        expect(getClosestValidDate({
+            refParts,
+            monthValues: [4, 9, 11],
+            dayValues: [2, 10, 12, 13, 14],
+            yearValues: [2020, 2021, 2022, 2023],
+            hourValues: [9, 10, 11],
+            minuteValues: [10, 15, 16],
+            minParts,
+            maxParts,
+        })).toEqual(expected);
+    });
+});

package/dist/collection/components/datetime/test/prefer-wheel/datetime.spec.js

@@ -0,0 +1,27 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { newSpecPage } from "@stencil/core/testing";
+import { Datetime } from "../../datetime";
+describe('datetime: preferWheel', () => {
+    beforeEach(() => {
+        const mockIntersectionObserver = jest.fn();
+        mockIntersectionObserver.mockReturnValue({
+            observe: () => null,
+            unobserve: () => null,
+            disconnect: () => null,
+        });
+        global.IntersectionObserver = mockIntersectionObserver;
+    });
+    it('should select the working day when clicking the confirm button', async () => {
+        const page = await newSpecPage({
+            components: [Datetime],
+            html: '<ion-datetime prefer-wheel="true" max="2021" show-default-buttons="true"></ion-datetime>',
+        });
+        const datetime = page.body.querySelector('ion-datetime');
+        const confirmButton = datetime.shadowRoot.querySelector('#confirm-button');
+        confirmButton.click();
+        await page.waitForChanges();
+        expect(datetime.value).toBe('2021-12-31T23:59:00');
+    });
+});

package/dist/collection/components/datetime/utils/manipulation.js

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { isSameDay } from "./comparison";
+import { isAfter, isBefore, isSameDay } from "./comparison";
 import { getNumDaysInMonth } from "./helpers";
 import { clampDate, parseAmPm } from "./parse";
 const twoDigit = (val) => {
@@ -355,32 +355,82 @@ export const validateParts = (parts, minParts, maxParts) => {
  * Returns the closest date to refParts
  * that also meets the constraints of
  * the *Values params.
- * @param refParts The reference date
- * @param monthValues The allowed month values
- * @param dayValues The allowed day (of the month) values
- * @param yearValues The allowed year values
- * @param hourValues The allowed hour values
- * @param minuteValues The allowed minute values
  */
-export const getClosestValidDate = (refParts, monthValues, dayValues, yearValues, hourValues, minuteValues) => {
+export const getClosestValidDate = ({ refParts, monthValues, dayValues, yearValues, hourValues, minuteValues, minParts, maxParts, }) => {
     const { hour, minute, day, month, year } = refParts;
     const copyParts = Object.assign(Object.assign({}, refParts), { dayOfWeek: undefined });
+    if (yearValues !== undefined) {
+        // Filters out years that are out of the min/max bounds
+        const filteredYears = yearValues.filter((year) => {
+            if (minParts !== undefined && year < minParts.year) {
+                return false;
+            }
+            if (maxParts !== undefined && year > maxParts.year) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.year = findClosestValue(year, filteredYears);
+    }
     if (monthValues !== undefined) {
-        copyParts.month = findClosestValue(month, monthValues);
+        // Filters out months that are out of the min/max bounds
+        const filteredMonths = monthValues.filter((month) => {
+            if (minParts !== undefined && copyParts.year === minParts.year && month < minParts.month) {
+                return false;
+            }
+            if (maxParts !== undefined && copyParts.year === maxParts.year && month > maxParts.month) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.month = findClosestValue(month, filteredMonths);
     }
     // Day is nullable but cannot be undefined
     if (day !== null && dayValues !== undefined) {
-        copyParts.day = findClosestValue(day, dayValues);
-    }
-    if (yearValues !== undefined) {
-        copyParts.year = findClosestValue(year, yearValues);
+        // Filters out days that are out of the min/max bounds
+        const filteredDays = dayValues.filter((day) => {
+            if (minParts !== undefined && isBefore(Object.assign(Object.assign({}, copyParts), { day }), minParts)) {
+                return false;
+            }
+            if (maxParts !== undefined && isAfter(Object.assign(Object.assign({}, copyParts), { day }), maxParts)) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.day = findClosestValue(day, filteredDays);
     }
     if (hour !== undefined && hourValues !== undefined) {
-        copyParts.hour = findClosestValue(hour, hourValues);
+        // Filters out hours that are out of the min/max bounds
+        const filteredHours = hourValues.filter((hour) => {
+            if ((minParts === null || minParts === void 0 ? void 0 : minParts.hour) !== undefined && isSameDay(copyParts, minParts) && hour < minParts.hour) {
+                return false;
+            }
+            if ((maxParts === null || maxParts === void 0 ? void 0 : maxParts.hour) !== undefined && isSameDay(copyParts, maxParts) && hour > maxParts.hour) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.hour = findClosestValue(hour, filteredHours);
         copyParts.ampm = parseAmPm(copyParts.hour);
     }
     if (minute !== undefined && minuteValues !== undefined) {
-        copyParts.minute = findClosestValue(minute, minuteValues);
+        // Filters out minutes that are out of the min/max bounds
+        const filteredMinutes = minuteValues.filter((minute) => {
+            if ((minParts === null || minParts === void 0 ? void 0 : minParts.minute) !== undefined &&
+                isSameDay(copyParts, minParts) &&
+                copyParts.hour === minParts.hour &&
+                minute < minParts.minute) {
+                return false;
+            }
+            if ((maxParts === null || maxParts === void 0 ? void 0 : maxParts.minute) !== undefined &&
+                isSameDay(copyParts, maxParts) &&
+                copyParts.hour === maxParts.hour &&
+                minute > maxParts.minute) {
+                return false;
+            }
+            return true;
+        });
+        copyParts.minute = findClosestValue(minute, filteredMinutes);
     }
     return copyParts;
 };

package/dist/docs.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2023-12-08T15:17:06",
+  "timestamp": "2023-12-11T19:26:40",
   "compiler": {
     "name": "@stencil/core",
     "version": "4.8.1",