@aurodesignsystem/auro-formkit 3.1.0-beta.1 → 3.1.0

package/components/combobox/demo/index.min.js

@@ -164,11 +164,420 @@ let AuroLibraryRuntimeUtils$4 = class AuroLibraryRuntimeUtils {
   }
 };
 
+let DateFormatter$1 = class DateFormatter {
+
+  constructor() {
+
+    /**
+     * @description Parses a date string into its components.
+     * @param {string} dateStr - Date string to parse.
+     * @param {string} format - Date format to parse.
+     * @returns {Object<key["month" | "day" | "year"]: number>|undefined}
+     */
+    this.parseDate = (dateStr, format = 'mm/dd/yyyy') => {
+
+      // Guard Clause: Date string is defined
+      if (!dateStr) {
+        return undefined;
+      }
+
+      // Assume the separator is a "/" a defined in our code base
+      const separator = '/';
+
+      // Get the parts of the date and format
+      const valueParts = dateStr.split(separator);
+      const formatParts = format.split(separator);
+
+      // Check if the value and format have the correct number of parts
+      if (valueParts.length !== formatParts.length) {
+        throw new Error('AuroDatepickerUtilities | parseDate: Date string and format length do not match');
+      }
+
+      // Holds the result to be returned
+      const result = formatParts.reduce((acc, part, index) => {
+        const value = valueParts[index];
+
+        if ((/m/iu).test(part)) {
+          acc.month = value;
+        } else if ((/d/iu).test(part)) {
+          acc.day = value;
+        } else if ((/y/iu).test(part)) {
+          acc.year = value;
+        }
+
+        return acc;
+      }, {});
+
+      // If we found all the parts, return the result
+      if (result.month && result.year) {
+        return result;
+      }
+
+      // Throw an error to let the dev know we were unable to parse the date string
+      throw new Error('AuroDatepickerUtilities | parseDate: Unable to parse date string');
+    };
+
+    /**
+     * Convert a date object to string format.
+     * @param {Object} date - Date to convert to string.
+     * @returns {Object} Returns the date as a string.
+     */
+    this.getDateAsString = (date) => date.toLocaleDateString(undefined, {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+    });
+
+    /**
+     * Converts a date string to a North American date format.
+     * @param {String} dateStr - Date to validate.
+     * @param {String} format - Date format to validate against.
+     * @returns {Boolean}
+     */
+    this.toNorthAmericanFormat = (dateStr, format) => {
+
+      if (format === 'mm/dd/yyyy') {
+        return dateStr;
+      }
+
+      const parsedDate = this.parseDate(dateStr, format);
+
+      if (!parsedDate) {
+        throw new Error('AuroDatepickerUtilities | toNorthAmericanFormat: Unable to parse date string');
+      }
+
+      const { month, day, year } = parsedDate;
+
+      const dateParts = [];
+      if (month) {
+        dateParts.push(month);
+      }
+
+      if (day) {
+        dateParts.push(day);
+      }
+
+      if (year) {
+        dateParts.push(year);
+      }
+
+      return dateParts.join('/');
+    };
+  }
+};
+const dateFormatter$1 = new DateFormatter$1();
+
+// filepath: dateConstraints.mjs
+const DATE_UTIL_CONSTRAINTS$1 = {
+  maxDay: 31,
+  maxMonth: 12,
+  maxYear: 2400,
+  minDay: 1,
+  minMonth: 1,
+  minYear: 1900,
+};
+
+let AuroDateUtilitiesBase$1 = class AuroDateUtilitiesBase {
+
+  /**
+   * @description The maximum day value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get maxDay() {
+    return DATE_UTIL_CONSTRAINTS$1.maxDay;
+  }
+
+  /**
+   * @description The maximum month value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get maxMonth() {
+    return DATE_UTIL_CONSTRAINTS$1.maxMonth;
+  }
+
+  /**
+   * @description The maximum year value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get maxYear() {
+    return DATE_UTIL_CONSTRAINTS$1.maxYear;
+  }
+
+  /**
+   * @description The minimum day value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get minDay() {
+    return DATE_UTIL_CONSTRAINTS$1.minDay;
+  }
+
+  /**
+   * @description The minimum month value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get minMonth() {
+    return DATE_UTIL_CONSTRAINTS$1.minMonth;
+  }
+
+  /**
+   * @description The minimum year value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get minYear() {
+    return DATE_UTIL_CONSTRAINTS$1.minYear;
+  }
+};
+
+/* eslint-disable no-magic-numbers */
+
+let AuroDateUtilities$1 = class AuroDateUtilities extends AuroDateUtilitiesBase$1 {
+
+  /**
+   * Returns the current century.
+   * @returns {String} The current century.
+   */
+  getCentury () {
+    return String(new Date().getFullYear()).slice(0, 2);
+  }
+
+  /**
+   * Returns a four digit year.
+   * @param {String} year - The year to convert to four digits.
+   * @returns {String} The four digit year.
+   */
+  getFourDigitYear (year) {
+
+    const strYear = String(year).trim();
+    return strYear.length <= 2 ? this.getCentury() + strYear : strYear;
+  }
+
+  constructor() {
+
+    super();
+
+    /**
+     * Compares two dates to see if they match.
+     * @param {Object} date1 - First date to compare.
+     * @param {Object} date2 - Second date to compare.
+     * @returns {Boolean} Returns true if the dates match.
+     */
+    this.datesMatch = (date1, date2) => new Date(date1).getTime() === new Date(date2).getTime();
+
+    /**
+     * Returns true if value passed in is a valid date.
+     * @param {String} date - Date to validate.
+     * @param {String} format - Date format to validate against.
+     * @returns {Boolean}
+     */
+    this.validDateStr = (date, format) => {
+
+      // The length we expect the date string to be
+      const dateStrLength = format.length;
+
+      // Guard Clause: Date and format are defined
+      if (typeof date === "undefined" || typeof format === "undefined") {
+        throw new Error('AuroDatepickerUtilities | validateDateStr: Date and format are required');
+      }
+
+      // Guard Clause: Date should be of type string
+      if (typeof date !== "string") {
+        throw new Error('AuroDatepickerUtilities | validateDateStr: Date must be a string');
+      }
+
+      // Guard Clause: Format should be of type string
+      if (typeof format !== "string") {
+        throw new Error('AuroDatepickerUtilities | validateDateStr: Format must be a string');
+      }
+
+      // Guard Clause: Length is what we expect it to be
+      if (date.length !== dateStrLength) {
+        return false;
+      }
+      // Get a formatted date string and parse it
+      const dateParts = dateFormatter$1.parseDate(date, format);
+
+      // Guard Clause: Date parse succeeded
+      if (!dateParts) {
+        return false;
+      }
+
+      // Create the expected date string based on the date parts
+      const expectedDateStr = `${dateParts.month}/${dateParts.day || "01"}/${this.getFourDigitYear(dateParts.year)}`;
+
+      // Generate a date object that we will extract a string date from to compare to the passed in date string
+      const dateObj = new Date(this.getFourDigitYear(dateParts.year), dateParts.month - 1, dateParts.day || 1);
+
+      // Get the date string of the date object we created from the string date
+      const actualDateStr = dateFormatter$1.getDateAsString(dateObj);
+
+      // Guard Clause: Generated date matches date string input
+      if (expectedDateStr !== actualDateStr) {
+        return false;
+      }
+
+      // If we passed all other checks, we can assume the date is valid
+      return true;
+    };
+
+    /**
+     * Determines if a string date value matches the format provided.
+     * @param {string} value = The date string value.
+     * @param { string} format = The date format to match against.
+     * @returns {boolean}
+     */
+    this.dateAndFormatMatch = (value, format) => {
+
+      // Ensure we have both values we need to do the comparison
+      if (!value || !format) {
+        throw new Error('AuroFormValidation | dateFormatMatch: value and format are required');
+      }
+
+      // If the lengths are different, they cannot match
+      if (value.length !== format.length) {
+        return false;
+      }
+
+      // Get the parts of the date
+      const dateParts = dateFormatter$1.parseDate(value, format);
+
+      // Validator for day
+      const dayValueIsValid = (day) => {
+
+        // Guard clause: if there is no day in the dateParts, we can ignore this check.
+        if (!dateParts.day) {
+          return true;
+        }
+
+        // Guard clause: ensure day exists.
+        if (!day) {
+          return false;
+        }
+
+        // Convert day to number
+        const numDay = Number.parseInt(day, 10);
+
+        // Guard clause: ensure day is a valid integer
+        if (Number.isNaN(numDay)) {
+          throw new Error('AuroDatepickerUtilities | dayValueIsValid: Unable to parse day value integer');
+        }
+
+        // Guard clause: ensure day is within the valid range
+        if (numDay < this.minDay || numDay > this.maxDay) {
+          return false;
+        }
+
+        // Default return
+        return true;
+      };
+
+      // Validator for month
+      const monthValueIsValid = (month) => {
+
+        // Guard clause: ensure month exists.
+        if (!month) {
+          return false;
+        }
+
+        // Convert month to number
+        const numMonth = Number.parseInt(month, 10);
+
+        // Guard clause: ensure month is a valid integer
+        if (Number.isNaN(numMonth)) {
+          throw new Error('AuroDatepickerUtilities | monthValueIsValid: Unable to parse month value integer');
+        }
+
+        // Guard clause: ensure month is within the valid range
+        if (numMonth < this.minMonth || numMonth > this.maxMonth) {
+          return false;
+        }
+
+        // Default return
+        return true;
+      };
+
+      // Validator for year
+      const yearIsValid = (_year) => {
+
+        // Guard clause: ensure year exists.
+        if (!_year) {
+          return false;
+        }
+
+        // Get the full year
+        const year = this.getFourDigitYear(_year);
+
+        // Convert year to number
+        const numYear = Number.parseInt(year, 10);
+
+        // Guard clause: ensure year is a valid integer
+        if (Number.isNaN(numYear)) {
+          throw new Error('AuroDatepickerUtilities | yearValueIsValid: Unable to parse year value integer');
+        }
+
+        // Guard clause: ensure year is within the valid range
+        if (numYear < this.minYear || numYear > this.maxYear) {
+          return false;
+        }
+
+        // Default return
+        return true;
+      };
+
+      // Self-contained checks for month, day, and year
+      const checks = [
+        monthValueIsValid(dateParts.month),
+        dayValueIsValid(dateParts.day),
+        yearIsValid(dateParts.year)
+      ];
+
+      // If any of the checks failed, the date format does not match and the result is invalid
+      const isValid = checks.every((check) => check === true);
+
+      //  If the check is invalid, return false
+      if (!isValid) {
+        return false;
+      }
+
+      // Default case
+      return true;
+    };
+  }
+};
+
+// Export a class instance
+const dateUtilities$1 = new AuroDateUtilities$1();
+
+// Export the class instance methods individually
+const {
+  datesMatch: datesMatch$1,
+  validDateStr: validDateStr$1,
+  dateAndFormatMatch: dateAndFormatMatch$1,
+  minDay: minDay$1,
+  minMonth: minMonth$1,
+  minYear: minYear$1,
+  maxDay: maxDay$1,
+  maxMonth: maxMonth$1,
+  maxYear: maxYear$1
+} = dateUtilities$1;
+
+const {
+  toNorthAmericanFormat: toNorthAmericanFormat$1,
+  parseDate: parseDate$1,
+  getDateAsString: getDateAsString$1
+} = dateFormatter$1;
+
 // Copyright (c) Alaska Air. All right reserved. Licensed under the Apache-2.0 license
 // See LICENSE in the project root for license information.
 
 
 let AuroFormValidation$1 = class AuroFormValidation {
+
   constructor() {
     this.runtimeUtils = new AuroLibraryRuntimeUtils$4();
   }
@@ -260,17 +669,17 @@ let AuroFormValidation$1 = class AuroFormValidation {
         ]
       }
     };
-  
+
     let elementType;
     if (this.runtimeUtils.elementMatch(elem, 'auro-input')) {
       elementType = 'input';
     } else if (this.runtimeUtils.elementMatch(elem, 'auro-counter') || this.runtimeUtils.elementMatch(elem, 'auro-counter-group')) {
       elementType = 'counter';
     }
-    
+
     if (elementType) {
       const rules = validationRules[elementType];
-    
+
       if (rules) {
         Object.values(rules).flat().forEach(rule => {
           if (rule.check(elem)) {
@@ -296,48 +705,82 @@ let AuroFormValidation$1 = class AuroFormValidation {
         if (!elem.value.match(emailRegex)) {
           elem.validity = 'patternMismatch';
           elem.errorMessage = elem.setCustomValidityForType || elem.setCustomValidity || '';
+          return;
         }
       } else if (elem.type === 'credit-card') {
         if (elem.value.length > 0 && elem.value.length < elem.validationCCLength) {
           elem.validity = 'tooShort';
           elem.errorMessage = elem.setCustomValidityForType || elem.setCustomValidity || '';
+          return;
         }
       } else if (elem.type === 'number') {
         if (elem.max !== undefined && Number(elem.max) < Number(elem.value)) {
           elem.validity = 'rangeOverflow';
           elem.errorMessage = elem.setCustomValidityRangeOverflow || elem.setCustomValidity || '';
+          return;
         }
 
         if (elem.min !== undefined && elem.value?.length > 0 && Number(elem.min) > Number(elem.value)) {
           elem.validity = 'rangeUnderflow';
           elem.errorMessage = elem.setCustomValidityRangeUnderflow || elem.setCustomValidity || '';
+          return;
         }
-      } else if (elem.type === 'date') {
-        if (elem.value?.length > 0 && elem.value?.length < elem.lengthForType) {
+      } else if (elem.type === 'date' && elem.value?.length > 0) {
+
+        // Guard Clause: if the value is too short
+        if (elem.value.length < elem.lengthForType) {
+          
           elem.validity = 'tooShort';
           elem.errorMessage = elem.setCustomValidityForType || elem.setCustomValidity || '';
-        } else if (elem.value?.length === elem.lengthForType && elem.util.toNorthAmericanFormat(elem.value, elem.format)) {
-          const formattedValue = elem.util.toNorthAmericanFormat(elem.value, elem.format);
-          const valueDate = new Date(formattedValue.dateForComparison);
+          return;
+        } 
+        
+        // Guard Clause: If the value is too long for the type
+        if (elem.value?.length > elem.lengthForType) {
+
+          elem.validity = 'tooLong';
+          elem.errorMessage = elem.setCustomValidityForType || elem.setCustomValidity || '';
+          return;
+        }
+        
+        // Validate that the date passed was the correct format
+        if (!dateAndFormatMatch$1(elem.value, elem.format)) {
+          elem.validity = 'patternMismatch';
+          elem.errorMessage = elem.setCustomValidityForType || elem.setCustomValidity || 'Invalid Date Format Entered';
+          return;
+        }
+        
+        // Validate that the date passed was a valid date
+        if (!validDateStr$1(elem.value, elem.format)) {
+          elem.validity = 'invalidDate';
+          elem.errorMessage = elem.setCustomValidityInvalidDate || elem.setCustomValidity || 'Invalid Date Entered';
+          return;
+        }
 
-          // validate max
-          if (elem.max?.length === elem.lengthForType) {
-            const maxDate = new Date(elem.util.toNorthAmericanFormat(elem.max, elem.format).dateForComparison);
+        // Perform the rest of the validation
+        const formattedValue = toNorthAmericanFormat$1(elem.value, elem.format);
+        const valueDate = new Date(formattedValue);
 
-            if (valueDate > maxDate) {
-              elem.validity = 'rangeOverflow';
-              elem.errorMessage = elem.setCustomValidityRangeOverflow || elem.setCustomValidity || '';
-            }
+        // // Validate max date
+        if (elem.max?.length === elem.lengthForType) {
+
+          const maxDate = new Date(toNorthAmericanFormat$1(elem.max, elem.format));
+
+          if (valueDate > maxDate) {
+            elem.validity = 'rangeOverflow';
+            elem.errorMessage = elem.setCustomValidityRangeOverflow || elem.setCustomValidity || '';
+            return;
           }
+        }
 
-          // validate min
-          if (elem.min?.length === elem.lengthForType) {
-            const minDate = new Date(elem.util.toNorthAmericanFormat(elem.min, elem.format).dateForComparison);
+        // Validate min date
+        if (elem.min?.length === elem.lengthForType) {
+          const minDate = new Date(toNorthAmericanFormat$1(elem.min, elem.format));
 
-            if (valueDate < minDate) {
-              elem.validity = 'rangeUnderflow';
-              elem.errorMessage = elem.setCustomValidityRangeUnderflow || elem.setCustomValidity || '';
-            }
+          if (valueDate < minDate) {
+            elem.validity = 'rangeUnderflow';
+            elem.errorMessage = elem.setCustomValidityRangeUnderflow || elem.setCustomValidity || '';
+            return;
           }
         }
       }
@@ -456,7 +899,7 @@ let AuroFormValidation$1 = class AuroFormValidation {
         if (input.validationMessage.length > 0) {
           elem.errorMessage = input.validationMessage;
         }
-      } else if (this.inputElements?.length > 0  && elem.errorMessage === '') {
+      } else if (this.inputElements?.length > 0 && elem.errorMessage === '') {
         const firstInput = this.inputElements[0];
 
         if (firstInput.validationMessage.length > 0) {
@@ -2337,7 +2780,7 @@ class AuroFloatingUI {
   /**
    * @private
    * getting called on 'blur' in trigger or `focusin` in document
-   *  
+   *
    * Hides the bib if focus moves outside of the trigger or bib, unless a 'noHideOnThisFocusLoss' flag is set.
    * This method checks if the currently active element is still within the trigger or bib.
    * If not, and if the bib isn't in fullscreen mode with focus lost, it hides the bib.
@@ -2453,7 +2896,7 @@ class AuroFloatingUI {
     // Close any other dropdown that is already open
     const existedVisibleFloatingUI = document.expandedAuroFormkitDropdown || document.expandedAuroFloater;
     if (existedVisibleFloatingUI && existedVisibleFloatingUI !== this &&
-      existedVisibleFloatingUI.isPopoverVisible &&
+      existedVisibleFloatingUI.element.isPopoverVisible &&
       document.expandedAuroFloater.eventPrefix === this.eventPrefix) {
       document.expandedAuroFloater.hideBib();
     }
@@ -2629,7 +3072,7 @@ class AuroFloatingUI {
       this.id = window.crypto.randomUUID();
       this.element.setAttribute('id', this.id);
     }
-    
+
     this.element.bib.setAttribute("id", `${this.id}-floater-bib`);
   }
 
@@ -2682,7 +3125,7 @@ class AuroFloatingUI {
       if (this.element.bib) {
         this.element.shadowRoot.append(this.element.bib);
       }
-  
+
       // Remove event & keyboard listeners
       if (this.element?.trigger) {
         this.element.trigger.removeEventListener('keydown', this.handleEvent);
@@ -3072,7 +3515,6 @@ var tokensCss$1$2 = i$5`:host{--ds-auro-dropdown-label-text-color: var(--ds-basi
 
 const DESIGN_TOKEN_BREAKPOINT_PREFIX = '--ds-grid-breakpoint-';
 const DESIGN_TOKEN_BREAKPOINT_OPTIONS = [
-  'xl',
   'lg',
   'md',
   'sm',
@@ -3144,7 +3586,6 @@ class AuroDropdownBib extends r$1 {
 
   set mobileFullscreenBreakpoint(value) {
     // verify the defined breakpoint is valid and exit out if not
-    // 'disabled' is a design token breakpoint so it acts as our "undefined" value
     const validatedValue = DESIGN_TOKEN_BREAKPOINT_OPTIONS.includes(value) ? value : undefined;
     if (!validatedValue) {
       this._mobileBreakpointValue = undefined;
@@ -3413,6 +3854,7 @@ var helpTextVersion$1 = '1.0.0';
  * @csspart helpText - The helpText content container.
  * @event auroDropdown-triggerClick - Notifies that the trigger has been clicked.
  * @event auroDropdown-toggled - Notifies that the visibility of the dropdown bib has changed.
+ * @event auroDropdown-idAdded - Notifies consumers that the unique ID for the dropdown bib has been generated.
  */
 class AuroDropdown extends r$1 {
   constructor() {
@@ -3458,7 +3900,9 @@ class AuroDropdown extends r$1 {
     this.rounded = false;
     this.tabIndex = 0;
     this.noToggle = false;
+    this.a11yAutocomplete = 'none';
     this.labeled = true;
+    this.a11yRole = 'combobox';
     this.onDark = false;
 
     // floaterConfig
@@ -3594,6 +4038,16 @@ class AuroDropdown extends r$1 {
         type: Number
       },
 
+      /**
+       * The unique ID for the dropdown bib element.
+       * @private
+       */
+      dropdownId: {
+        type: String,
+        reflect: false,
+        attribute: false
+      },
+
       /**
        * If declared in combination with `bordered` property or `helpText` slot content, will apply red color to both.
        */
@@ -3657,12 +4111,7 @@ class AuroDropdown extends r$1 {
       },
 
       /**
-       * Defines the screen size breakpoint (`xs`, `sm`, `md`, `lg`, `xl`, `disabled`)
-       * at which the dropdown switches to fullscreen mode on mobile. `disabled` indicates a dropdown should _never_ enter fullscreen.
-       *
-       * When expanded, the dropdown will automatically display in fullscreen mode
-       * if the screen size is equal to or smaller than the selected breakpoint.
-       * @default sm
+       * Defines the screen size breakpoint (`lg`, `md`, `sm`, or `xs`) at which the dropdown switches to fullscreen mode on mobile. When expanded, the dropdown will automatically display in fullscreen mode if the screen size is equal to or smaller than the selected breakpoint.
        */
       fullscreenBreakpoint: {
         type: String,
@@ -3761,6 +4210,23 @@ class AuroDropdown extends r$1 {
        */
       tabIndex: {
         type: Number
+      },
+
+      /**
+       * The value for the role attribute of the trigger element.
+       */
+      a11yRole: {
+        type: String || undefined,
+        attribute: false,
+        reflect: false
+      },
+
+      /**
+       * The value for the aria-autocomplete attribute of the trigger element.
+       */
+      a11yAutocomplete: {
+        type: String,
+        attribute: false,
       }
     };
   }
@@ -3785,15 +4251,6 @@ class AuroDropdown extends r$1 {
     AuroLibraryRuntimeUtils$1$2.prototype.registerComponent(name, AuroDropdown);
   }
 
-  /**
-   * Accessor for reusing the focusable entity query string.
-   * @private
-   * @returns {string}
-   */
-  get focusableEntityQuery () {
-    return 'auro-input, [auro-input], auro-button, [auro-button], button, input';
-  }
-
   connectedCallback() {
     super.connectedCallback();
   }
@@ -3807,8 +4264,6 @@ class AuroDropdown extends r$1 {
   updated(changedProperties) {
     this.floater.handleUpdate(changedProperties);
 
-    // Note: `disabled` is not a breakpoint (it is not a screen size),
-    // so it looks like we never consume this - however, dropdownBib handles this in the setter as "undefined"
     if (changedProperties.has('fullscreenBreakpoint')) {
       this.bibContent.mobileFullscreenBreakpoint = this.fullscreenBreakpoint;
     }
@@ -3822,7 +4277,22 @@ class AuroDropdown extends r$1 {
   }
 
   firstUpdated() {
+
+    // Configure the floater to, this will generate the ID for the bib
     this.floater.configure(this, 'auroDropdown');
+
+    /**
+     * @description Let subscribers know that the dropdown ID ha been generated and added.
+     * @event auroDropdown-idAdded
+     * @type {Object<key: 'id', value: string>} - The ID of the dropdown bib element.
+     */
+    this.dispatchEvent(new CustomEvent('auroDropdown-idAdded', {detail: {id: this.floater.element.id}}));
+
+    // Set the bib ID locally if the user hasn't provided a focusable trigger
+    if (!this.triggerContentFocusable) {
+      this.dropdownId = this.floater.element.id;
+    }
+
     this.bibContent = this.floater.element.bib;
 
     // Add the tag name as an attribute if it is different than the component name
@@ -3944,7 +4414,7 @@ class AuroDropdown extends r$1 {
 
     this.triggerContentSlot.forEach((node) => {
       if (node.querySelectorAll) {
-        const auroElements = node.querySelectorAll(this.focusableEntityQuery);
+        const auroElements = node.querySelectorAll('auro-input, [auro-input], auro-button, [auro-button], button, input');
         auroElements.forEach((auroEl) => {
           auroEl.addEventListener('focus', this.bindFocusEventToTrigger);
           auroEl.addEventListener('blur', this.bindFocusEventToTrigger);
@@ -3965,7 +4435,7 @@ class AuroDropdown extends r$1 {
 
     this.triggerContentSlot.forEach((node) => {
       if (node.querySelectorAll) {
-        const auroElements = node.querySelectorAll(this.focusableEntityQuery);
+        const auroElements = node.querySelectorAll('auro-input, [auro-input], auro-button, [auro-button], button, input');
         auroElements.forEach((auroEl) => {
           auroEl.removeEventListener('focus', this.bindFocusEventToTrigger);
           auroEl.removeEventListener('blur', this.bindFocusEventToTrigger);
@@ -3974,6 +4444,30 @@ class AuroDropdown extends r$1 {
     });
   }
 
+  /*
+   * Sets aria attributes for the trigger element if a custom one is passed in.
+   * @private
+   * @method setTriggerAriaAttributes
+   * @param { HTMLElement } triggerElement - The custom trigger element.
+   */
+  clearTriggerA11yAttributes(triggerElement) {
+
+    if (!triggerElement || !triggerElement.removeAttribute) {
+      return;
+    }
+
+    // Reset appropriate attributes for a11y
+    triggerElement.removeAttribute('aria-labelledby');
+    if (triggerElement.getAttribute('id') === `${this.id}-trigger-element`) {
+      triggerElement.removeAttribute('id');
+    }
+    triggerElement.removeAttribute('role');
+    triggerElement.removeAttribute('aria-expanded');
+
+    triggerElement.removeAttribute('aria-controls');
+    triggerElement.removeAttribute('aria-autocomplete');
+  }
+
   /**
    * Handles changes to the trigger content slot and updates related properties.
    *
@@ -3987,32 +4481,41 @@ class AuroDropdown extends r$1 {
    * @returns {void}
    */
   handleTriggerContentSlotChange(event) {
+
     this.floater.handleTriggerTabIndex();
 
+    // Get the trigger
+    const trigger = this.shadowRoot.querySelector('#trigger');
+
+    // Get the trigger slot
     const triggerSlot = this.shadowRoot.querySelector('.triggerContent slot');
 
+    // If there's a trigger slot
     if (triggerSlot) {
 
+      // Get the content nodes to see if there are any children
       const triggerContentNodes = triggerSlot.assignedNodes();
 
+      // If there are children
       if (triggerContentNodes) {
 
-        triggerContentNodes.forEach((node) => {
-          if (!this.triggerContentFocusable) {
-            this.triggerContentFocusable = this.containsFocusableElement(node);
-          }
-        });
-      }
-    }
+        // See if any of them are focusable elemeents
+        this.triggerContentFocusable = triggerContentNodes.some((node) => this.containsFocusableElement(node));
 
-    const trigger = this.shadowRoot.querySelector('#trigger');
+        // If any of them are focusable elements
+        if (this.triggerContentFocusable) {
 
-    if (!this.triggerContentFocusable) {
-      trigger.setAttribute('tabindex', '0');
-      trigger.setAttribute('role', 'button');
-    } else {
-      trigger.removeAttribute('tabindex');
-      trigger.removeAttribute('role');
+          // Assume the consumer will be providing their own a11y in whatever they passed in
+          this.clearTriggerA11yAttributes(trigger);
+
+          // Remove the tabindex from the trigger so it doesn't interrupt focus flow
+          trigger.removeAttribute('tabindex');
+        } else {
+
+          // Add the tabindex to the trigger so that it's in the focus flow
+          trigger.setAttribute('tabindex', '0');
+        }
+      }
     }
 
     if (event) {
@@ -4022,6 +4525,7 @@ class AuroDropdown extends r$1 {
 
     if (this.triggerContentSlot) {
       this.setupTriggerFocusEventBinding();
+
       this.hasTriggerContent = this.triggerContentSlot.some((slot) => {
         if (slot.textContent.trim()) {
           return true;
@@ -4089,10 +4593,13 @@ class AuroDropdown extends r$1 {
           id="trigger"
           class="trigger"
           part="trigger"
-          aria-labelledby="triggerLabel"
           tabindex="${this.tabIndex}"
           ?showBorder="${this.showTriggerBorders}"
-          >
+          role="${o(this.triggerContentFocusable ? undefined : this.a11yRole)}"
+          aria-expanded="${o(this.triggerContentFocusable ? undefined : this.isPopoverVisible)}"
+          aria-controls="${o(this.triggerContentFocusable ? undefined : this.dropdownId)}"
+          aria-labelledby="${o(this.triggerContentFocusable ? undefined : 'triggerLabel')}"
+        >
           <div class="triggerContentWrapper">
             <label class="label" id="triggerLabel" hasTrigger=${this.hasTriggerContent}>
               <slot name="label" @slotchange="${this.handleLabelSlotChange}"></slot>
@@ -4126,12 +4633,12 @@ class AuroDropdown extends r$1 {
         <div id="bibSizer" part="size"></div>
         <${this.dropdownBibTag}
           id="bib"
-          role="tooltip"
           ?data-show="${this.isPopoverVisible}"
           ?isfullscreen="${this.isBibFullscreen}"
           ?common="${this.common}"
           ?rounded="${this.common || this.rounded}"
-          ?inset="${this.common || this.inset}">
+          ?inset="${this.common || this.inset}"
+        >
         </${this.dropdownBibTag}>
       </div>
     `;
@@ -7953,175 +8460,583 @@ class AuroInputUtilities {
           blocks.dd = { mask: IMask.MaskedRange, from: 1, to: 31 };
         }
 
-        return {
-          mask: Date,
-          pattern: dateFormat,
-          blocks,
-          format(date) {
-            if (!date) {
-              return '';
-            }
+        return {
+          mask: Date,
+          pattern: dateFormat,
+          blocks,
+          format(date) {
+            if (!date) {
+              return '';
+            }
+
+            const day = date.getDate()
+              .toString()
+              .padStart(2, '0');
+            const month = (date.getMonth() + 1)
+              .toString()
+              .padStart(2, '0');
+            const year = date
+              .getFullYear()
+              .toString();
+            const shortYear = year.slice(-2);
+
+            let formattedDate = this.mask;
+
+            if (formattedDate.includes('dd')) {
+              formattedDate = formattedDate.replace('dd', day);
+            }
+
+            if (formattedDate.includes('mm')) {
+              formattedDate = formattedDate.replace('mm', month);
+            }
+
+            if (formattedDate.includes('yyyy')) {
+              formattedDate = formattedDate.replace('yyyy', year);
+            }
+
+            if (formattedDate.includes('yy')) {
+              formattedDate = formattedDate.replace('yy', shortYear);
+            }
+
+            return formattedDate;
+          },
+          parse(str) {
+            if (!str) {
+              return null;
+            }
+
+            const parts = str.split('/');
+            const formatParts = this.mask.split('/');
+
+            let day = 1, month, year = new Date().getFullYear();
+
+            formatParts.forEach((part, index) => {
+              if (part === 'dd') {
+                day = parseInt(parts[index]) || 1;
+              }
+
+              if (part === 'mm') {
+                month = parseInt(parts[index]) - 1;
+              }
+
+              if (part === 'yyyy') {
+                year = parseInt(parts[index]);
+              }
+
+              if (part === 'yy') {
+                year = parseInt(parts[index]);
+                year = year <= 25 ? 2000 + year : 1900 + year;
+              }
+            });
+
+            if (isNaN(month) || isNaN(year)) {
+              return null;
+            }
+            return new Date(year, month, day);
+          },
+          lazy: true,
+          placeholderChar: ''
+        };
+      }
+    }
+
+    if (format) {
+      return {
+        mask: format,
+        placeholderChar: '',
+        lazy: true
+      };
+    }
+
+    return {};
+  }
+
+  /**
+   * @private
+   * @param {string} dateStr - Date string to format.
+   * @param {string} format - Date format to use.
+   * @returns {void}
+   */
+  toNorthAmericanFormat(dateStr, format) {
+    const parsedDate = this.parseDate(dateStr, format);
+
+    if (!parsedDate) {
+      return parsedDate;
+    }
+
+    const { month, day, year } = parsedDate;
+    const fullYear = (year && year.length === 2) ? `20${year}` : year;
+    const currentYear = new Date().getFullYear();
+
+    const dateParts = [];
+    if (month) {
+      dateParts.push(month);
+    }
+
+    if (day) {
+      dateParts.push(day);
+    }
+
+    if (year) {
+      dateParts.push(year);
+    }
+
+    const comparisonParts = [
+      month || '01',
+      day || '01',
+      fullYear || currentYear
+    ];
+
+    return {
+      formattedDate: dateParts.join('/'),
+      dateForComparison: comparisonParts.join('/')
+    };
+  }
+
+  /**
+   * @private
+   * @param {string} dateStr - Date string to parse.
+   * @param {string} format - Date format to parse.
+   * @returns {void}
+   */
+  parseDate(dateStr, format) {
+    const dateFormat = format || "mm/dd/yyyy";
+
+    // Define mappings for date components with named capture groups
+    const formatPatterns = {
+      'yyyy': '(?<year>\\d{4})',
+      'yy': '(?<year>\\d{2})',
+      'mm': '(?<month>\\d{2})',
+      'dd': '(?<day>\\d{2})'
+    };
+
+    // Escape slashes and replace format components with regex patterns
+    let regexPattern = dateFormat.replace(/(?:yyyy|yy|mm|dd)/gu, (match) => formatPatterns[match]);
+    regexPattern = `^${regexPattern}$`;
+
+    const regex = new RegExp(regexPattern, 'u');
+    const match = dateStr.match(regex);
+
+    if (match && match.groups) {
+      return {
+        year: match.groups.year,
+        month: match.groups.month,
+        day: match.groups.day
+      };
+    }
+
+    return undefined;
+  }
+}
+
+class DateFormatter {
+
+  constructor() {
+
+    /**
+     * @description Parses a date string into its components.
+     * @param {string} dateStr - Date string to parse.
+     * @param {string} format - Date format to parse.
+     * @returns {Object<key["month" | "day" | "year"]: number>|undefined}
+     */
+    this.parseDate = (dateStr, format = 'mm/dd/yyyy') => {
+
+      // Guard Clause: Date string is defined
+      if (!dateStr) {
+        return undefined;
+      }
+
+      // Assume the separator is a "/" a defined in our code base
+      const separator = '/';
+
+      // Get the parts of the date and format
+      const valueParts = dateStr.split(separator);
+      const formatParts = format.split(separator);
+
+      // Check if the value and format have the correct number of parts
+      if (valueParts.length !== formatParts.length) {
+        throw new Error('AuroDatepickerUtilities | parseDate: Date string and format length do not match');
+      }
+
+      // Holds the result to be returned
+      const result = formatParts.reduce((acc, part, index) => {
+        const value = valueParts[index];
+
+        if ((/m/iu).test(part)) {
+          acc.month = value;
+        } else if ((/d/iu).test(part)) {
+          acc.day = value;
+        } else if ((/y/iu).test(part)) {
+          acc.year = value;
+        }
+
+        return acc;
+      }, {});
+
+      // If we found all the parts, return the result
+      if (result.month && result.year) {
+        return result;
+      }
+
+      // Throw an error to let the dev know we were unable to parse the date string
+      throw new Error('AuroDatepickerUtilities | parseDate: Unable to parse date string');
+    };
+
+    /**
+     * Convert a date object to string format.
+     * @param {Object} date - Date to convert to string.
+     * @returns {Object} Returns the date as a string.
+     */
+    this.getDateAsString = (date) => date.toLocaleDateString(undefined, {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+    });
+
+    /**
+     * Converts a date string to a North American date format.
+     * @param {String} dateStr - Date to validate.
+     * @param {String} format - Date format to validate against.
+     * @returns {Boolean}
+     */
+    this.toNorthAmericanFormat = (dateStr, format) => {
+
+      if (format === 'mm/dd/yyyy') {
+        return dateStr;
+      }
+
+      const parsedDate = this.parseDate(dateStr, format);
+
+      if (!parsedDate) {
+        throw new Error('AuroDatepickerUtilities | toNorthAmericanFormat: Unable to parse date string');
+      }
+
+      const { month, day, year } = parsedDate;
+
+      const dateParts = [];
+      if (month) {
+        dateParts.push(month);
+      }
+
+      if (day) {
+        dateParts.push(day);
+      }
+
+      if (year) {
+        dateParts.push(year);
+      }
+
+      return dateParts.join('/');
+    };
+  }
+}
+const dateFormatter = new DateFormatter();
+
+// filepath: dateConstraints.mjs
+const DATE_UTIL_CONSTRAINTS = {
+  maxDay: 31,
+  maxMonth: 12,
+  maxYear: 2400,
+  minDay: 1,
+  minMonth: 1,
+  minYear: 1900,
+};
+
+class AuroDateUtilitiesBase {
+
+  /**
+   * @description The maximum day value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get maxDay() {
+    return DATE_UTIL_CONSTRAINTS.maxDay;
+  }
+
+  /**
+   * @description The maximum month value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get maxMonth() {
+    return DATE_UTIL_CONSTRAINTS.maxMonth;
+  }
+
+  /**
+   * @description The maximum year value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get maxYear() {
+    return DATE_UTIL_CONSTRAINTS.maxYear;
+  }
+
+  /**
+   * @description The minimum day value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get minDay() {
+    return DATE_UTIL_CONSTRAINTS.minDay;
+  }
+
+  /**
+   * @description The minimum month value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get minMonth() {
+    return DATE_UTIL_CONSTRAINTS.minMonth;
+  }
+
+  /**
+   * @description The minimum year value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get minYear() {
+    return DATE_UTIL_CONSTRAINTS.minYear;
+  }
+}
+
+/* eslint-disable no-magic-numbers */
+
+class AuroDateUtilities extends AuroDateUtilitiesBase {
+
+  /**
+   * Returns the current century.
+   * @returns {String} The current century.
+   */
+  getCentury () {
+    return String(new Date().getFullYear()).slice(0, 2);
+  }
+
+  /**
+   * Returns a four digit year.
+   * @param {String} year - The year to convert to four digits.
+   * @returns {String} The four digit year.
+   */
+  getFourDigitYear (year) {
+
+    const strYear = String(year).trim();
+    return strYear.length <= 2 ? this.getCentury() + strYear : strYear;
+  }
+
+  constructor() {
+
+    super();
+
+    /**
+     * Compares two dates to see if they match.
+     * @param {Object} date1 - First date to compare.
+     * @param {Object} date2 - Second date to compare.
+     * @returns {Boolean} Returns true if the dates match.
+     */
+    this.datesMatch = (date1, date2) => new Date(date1).getTime() === new Date(date2).getTime();
+
+    /**
+     * Returns true if value passed in is a valid date.
+     * @param {String} date - Date to validate.
+     * @param {String} format - Date format to validate against.
+     * @returns {Boolean}
+     */
+    this.validDateStr = (date, format) => {
+
+      // The length we expect the date string to be
+      const dateStrLength = format.length;
+
+      // Guard Clause: Date and format are defined
+      if (typeof date === "undefined" || typeof format === "undefined") {
+        throw new Error('AuroDatepickerUtilities | validateDateStr: Date and format are required');
+      }
+
+      // Guard Clause: Date should be of type string
+      if (typeof date !== "string") {
+        throw new Error('AuroDatepickerUtilities | validateDateStr: Date must be a string');
+      }
+
+      // Guard Clause: Format should be of type string
+      if (typeof format !== "string") {
+        throw new Error('AuroDatepickerUtilities | validateDateStr: Format must be a string');
+      }
+
+      // Guard Clause: Length is what we expect it to be
+      if (date.length !== dateStrLength) {
+        return false;
+      }
+      // Get a formatted date string and parse it
+      const dateParts = dateFormatter.parseDate(date, format);
+
+      // Guard Clause: Date parse succeeded
+      if (!dateParts) {
+        return false;
+      }
 
-            const day = date.getDate()
-              .toString()
-              .padStart(2, '0');
-            const month = (date.getMonth() + 1)
-              .toString()
-              .padStart(2, '0');
-            const year = date
-              .getFullYear()
-              .toString();
-            const shortYear = year.slice(-2);
+      // Create the expected date string based on the date parts
+      const expectedDateStr = `${dateParts.month}/${dateParts.day || "01"}/${this.getFourDigitYear(dateParts.year)}`;
 
-            let formattedDate = this.mask;
+      // Generate a date object that we will extract a string date from to compare to the passed in date string
+      const dateObj = new Date(this.getFourDigitYear(dateParts.year), dateParts.month - 1, dateParts.day || 1);
 
-            if (formattedDate.includes('dd')) {
-              formattedDate = formattedDate.replace('dd', day);
-            }
+      // Get the date string of the date object we created from the string date
+      const actualDateStr = dateFormatter.getDateAsString(dateObj);
 
-            if (formattedDate.includes('mm')) {
-              formattedDate = formattedDate.replace('mm', month);
-            }
+      // Guard Clause: Generated date matches date string input
+      if (expectedDateStr !== actualDateStr) {
+        return false;
+      }
 
-            if (formattedDate.includes('yyyy')) {
-              formattedDate = formattedDate.replace('yyyy', year);
-            }
+      // If we passed all other checks, we can assume the date is valid
+      return true;
+    };
 
-            if (formattedDate.includes('yy')) {
-              formattedDate = formattedDate.replace('yy', shortYear);
-            }
+    /**
+     * Determines if a string date value matches the format provided.
+     * @param {string} value = The date string value.
+     * @param { string} format = The date format to match against.
+     * @returns {boolean}
+     */
+    this.dateAndFormatMatch = (value, format) => {
 
-            return formattedDate;
-          },
-          parse(str) {
-            if (!str) {
-              return null;
-            }
+      // Ensure we have both values we need to do the comparison
+      if (!value || !format) {
+        throw new Error('AuroFormValidation | dateFormatMatch: value and format are required');
+      }
 
-            const parts = str.split('/');
-            const formatParts = this.mask.split('/');
+      // If the lengths are different, they cannot match
+      if (value.length !== format.length) {
+        return false;
+      }
 
-            let day = 1, month, year = new Date().getFullYear();
+      // Get the parts of the date
+      const dateParts = dateFormatter.parseDate(value, format);
 
-            formatParts.forEach((part, index) => {
-              if (part === 'dd') {
-                day = parseInt(parts[index]) || 1;
-              }
+      // Validator for day
+      const dayValueIsValid = (day) => {
 
-              if (part === 'mm') {
-                month = parseInt(parts[index]) - 1;
-              }
+        // Guard clause: if there is no day in the dateParts, we can ignore this check.
+        if (!dateParts.day) {
+          return true;
+        }
 
-              if (part === 'yyyy') {
-                year = parseInt(parts[index]);
-              }
+        // Guard clause: ensure day exists.
+        if (!day) {
+          return false;
+        }
 
-              if (part === 'yy') {
-                year = parseInt(parts[index]);
-                year = year <= 25 ? 2000 + year : 1900 + year;
-              }
-            });
+        // Convert day to number
+        const numDay = Number.parseInt(day, 10);
 
-            if (isNaN(month) || isNaN(year)) {
-              return null;
-            }
-            return new Date(year, month, day);
-          },
-          lazy: true,
-          placeholderChar: ''
-        };
-      }
-    }
+        // Guard clause: ensure day is a valid integer
+        if (Number.isNaN(numDay)) {
+          throw new Error('AuroDatepickerUtilities | dayValueIsValid: Unable to parse day value integer');
+        }
 
-    if (format) {
-      return {
-        mask: format,
-        placeholderChar: '',
-        lazy: true
-      };
-    }
+        // Guard clause: ensure day is within the valid range
+        if (numDay < this.minDay || numDay > this.maxDay) {
+          return false;
+        }
 
-    return {};
-  }
+        // Default return
+        return true;
+      };
 
-  /**
-   * @private
-   * @param {string} dateStr - Date string to format.
-   * @param {string} format - Date format to use.
-   * @returns {void}
-   */
-  toNorthAmericanFormat(dateStr, format) {
-    const parsedDate = this.parseDate(dateStr, format);
+      // Validator for month
+      const monthValueIsValid = (month) => {
 
-    if (!parsedDate) {
-      return parsedDate;
-    }
+        // Guard clause: ensure month exists.
+        if (!month) {
+          return false;
+        }
 
-    const { month, day, year } = parsedDate;
-    const fullYear = (year && year.length === 2) ? `20${year}` : year;
-    const currentYear = new Date().getFullYear();
+        // Convert month to number
+        const numMonth = Number.parseInt(month, 10);
 
-    const dateParts = [];
-    if (month) {
-      dateParts.push(month);
-    }
+        // Guard clause: ensure month is a valid integer
+        if (Number.isNaN(numMonth)) {
+          throw new Error('AuroDatepickerUtilities | monthValueIsValid: Unable to parse month value integer');
+        }
 
-    if (day) {
-      dateParts.push(day);
-    }
+        // Guard clause: ensure month is within the valid range
+        if (numMonth < this.minMonth || numMonth > this.maxMonth) {
+          return false;
+        }
 
-    if (year) {
-      dateParts.push(year);
-    }
+        // Default return
+        return true;
+      };
 
-    const comparisonParts = [
-      month || '01',
-      day || '01',
-      fullYear || currentYear
-    ];
+      // Validator for year
+      const yearIsValid = (_year) => {
 
-    return {
-      formattedDate: dateParts.join('/'),
-      dateForComparison: comparisonParts.join('/')
-    };
-  }
+        // Guard clause: ensure year exists.
+        if (!_year) {
+          return false;
+        }
 
-  /**
-   * @private
-   * @param {string} dateStr - Date string to parse.
-   * @param {string} format - Date format to parse.
-   * @returns {void}
-   */
-  parseDate(dateStr, format) {
-    const dateFormat = format || "mm/dd/yyyy";
+        // Get the full year
+        const year = this.getFourDigitYear(_year);
 
-    // Define mappings for date components with named capture groups
-    const formatPatterns = {
-      'yyyy': '(?<year>\\d{4})',
-      'yy': '(?<year>\\d{2})',
-      'mm': '(?<month>\\d{2})',
-      'dd': '(?<day>\\d{2})'
-    };
+        // Convert year to number
+        const numYear = Number.parseInt(year, 10);
 
-    // Escape slashes and replace format components with regex patterns
-    let regexPattern = dateFormat.replace(/(?:yyyy|yy|mm|dd)/gu, (match) => formatPatterns[match]);
-    regexPattern = `^${regexPattern}$`;
+        // Guard clause: ensure year is a valid integer
+        if (Number.isNaN(numYear)) {
+          throw new Error('AuroDatepickerUtilities | yearValueIsValid: Unable to parse year value integer');
+        }
 
-    const regex = new RegExp(regexPattern, 'u');
-    const match = dateStr.match(regex);
+        // Guard clause: ensure year is within the valid range
+        if (numYear < this.minYear || numYear > this.maxYear) {
+          return false;
+        }
 
-    if (match && match.groups) {
-      return {
-        year: match.groups.year,
-        month: match.groups.month,
-        day: match.groups.day
+        // Default return
+        return true;
       };
-    }
 
-    return undefined;
+      // Self-contained checks for month, day, and year
+      const checks = [
+        monthValueIsValid(dateParts.month),
+        dayValueIsValid(dateParts.day),
+        yearIsValid(dateParts.year)
+      ];
+
+      // If any of the checks failed, the date format does not match and the result is invalid
+      const isValid = checks.every((check) => check === true);
+
+      //  If the check is invalid, return false
+      if (!isValid) {
+        return false;
+      }
+
+      // Default case
+      return true;
+    };
   }
 }
 
+// Export a class instance
+const dateUtilities = new AuroDateUtilities();
+
+// Export the class instance methods individually
+const {
+  datesMatch,
+  validDateStr,
+  dateAndFormatMatch,
+  minDay,
+  minMonth,
+  minYear,
+  maxDay,
+  maxMonth,
+  maxYear
+} = dateUtilities;
+
+const {
+  toNorthAmericanFormat,
+  parseDate,
+  getDateAsString
+} = dateFormatter;
+
 // Copyright (c) Alaska Air. All right reserved. Licensed under the Apache-2.0 license
 // See LICENSE in the project root for license information.
 
@@ -8197,6 +9112,7 @@ let AuroLibraryRuntimeUtils$1$1 = class AuroLibraryRuntimeUtils {
 
 
 class AuroFormValidation {
+
   constructor() {
     this.runtimeUtils = new AuroLibraryRuntimeUtils$1$1();
   }
@@ -8288,17 +9204,17 @@ class AuroFormValidation {
         ]
       }
     };
-  
+
     let elementType;
     if (this.runtimeUtils.elementMatch(elem, 'auro-input')) {
       elementType = 'input';
     } else if (this.runtimeUtils.elementMatch(elem, 'auro-counter') || this.runtimeUtils.elementMatch(elem, 'auro-counter-group')) {
       elementType = 'counter';
     }
-    
+
     if (elementType) {
       const rules = validationRules[elementType];
-    
+
       if (rules) {
         Object.values(rules).flat().forEach(rule => {
           if (rule.check(elem)) {
@@ -8324,48 +9240,82 @@ class AuroFormValidation {
         if (!elem.value.match(emailRegex)) {
           elem.validity = 'patternMismatch';
           elem.errorMessage = elem.setCustomValidityForType || elem.setCustomValidity || '';
+          return;
         }
       } else if (elem.type === 'credit-card') {
         if (elem.value.length > 0 && elem.value.length < elem.validationCCLength) {
           elem.validity = 'tooShort';
           elem.errorMessage = elem.setCustomValidityForType || elem.setCustomValidity || '';
+          return;
         }
       } else if (elem.type === 'number') {
         if (elem.max !== undefined && Number(elem.max) < Number(elem.value)) {
           elem.validity = 'rangeOverflow';
           elem.errorMessage = elem.setCustomValidityRangeOverflow || elem.setCustomValidity || '';
+          return;
         }
 
         if (elem.min !== undefined && elem.value?.length > 0 && Number(elem.min) > Number(elem.value)) {
           elem.validity = 'rangeUnderflow';
           elem.errorMessage = elem.setCustomValidityRangeUnderflow || elem.setCustomValidity || '';
+          return;
         }
-      } else if (elem.type === 'date') {
-        if (elem.value?.length > 0 && elem.value?.length < elem.lengthForType) {
+      } else if (elem.type === 'date' && elem.value?.length > 0) {
+
+        // Guard Clause: if the value is too short
+        if (elem.value.length < elem.lengthForType) {
+          
           elem.validity = 'tooShort';
           elem.errorMessage = elem.setCustomValidityForType || elem.setCustomValidity || '';
-        } else if (elem.value?.length === elem.lengthForType && elem.util.toNorthAmericanFormat(elem.value, elem.format)) {
-          const formattedValue = elem.util.toNorthAmericanFormat(elem.value, elem.format);
-          const valueDate = new Date(formattedValue.dateForComparison);
+          return;
+        } 
+        
+        // Guard Clause: If the value is too long for the type
+        if (elem.value?.length > elem.lengthForType) {
+
+          elem.validity = 'tooLong';
+          elem.errorMessage = elem.setCustomValidityForType || elem.setCustomValidity || '';
+          return;
+        }
+        
+        // Validate that the date passed was the correct format
+        if (!dateAndFormatMatch(elem.value, elem.format)) {
+          elem.validity = 'patternMismatch';
+          elem.errorMessage = elem.setCustomValidityForType || elem.setCustomValidity || 'Invalid Date Format Entered';
+          return;
+        }
+        
+        // Validate that the date passed was a valid date
+        if (!validDateStr(elem.value, elem.format)) {
+          elem.validity = 'invalidDate';
+          elem.errorMessage = elem.setCustomValidityInvalidDate || elem.setCustomValidity || 'Invalid Date Entered';
+          return;
+        }
 
-          // validate max
-          if (elem.max?.length === elem.lengthForType) {
-            const maxDate = new Date(elem.util.toNorthAmericanFormat(elem.max, elem.format).dateForComparison);
+        // Perform the rest of the validation
+        const formattedValue = toNorthAmericanFormat(elem.value, elem.format);
+        const valueDate = new Date(formattedValue);
 
-            if (valueDate > maxDate) {
-              elem.validity = 'rangeOverflow';
-              elem.errorMessage = elem.setCustomValidityRangeOverflow || elem.setCustomValidity || '';
-            }
+        // // Validate max date
+        if (elem.max?.length === elem.lengthForType) {
+
+          const maxDate = new Date(toNorthAmericanFormat(elem.max, elem.format));
+
+          if (valueDate > maxDate) {
+            elem.validity = 'rangeOverflow';
+            elem.errorMessage = elem.setCustomValidityRangeOverflow || elem.setCustomValidity || '';
+            return;
           }
+        }
 
-          // validate min
-          if (elem.min?.length === elem.lengthForType) {
-            const minDate = new Date(elem.util.toNorthAmericanFormat(elem.min, elem.format).dateForComparison);
+        // Validate min date
+        if (elem.min?.length === elem.lengthForType) {
+          const minDate = new Date(toNorthAmericanFormat(elem.min, elem.format));
 
-            if (valueDate < minDate) {
-              elem.validity = 'rangeUnderflow';
-              elem.errorMessage = elem.setCustomValidityRangeUnderflow || elem.setCustomValidity || '';
-            }
+          if (valueDate < minDate) {
+            elem.validity = 'rangeUnderflow';
+            elem.errorMessage = elem.setCustomValidityRangeUnderflow || elem.setCustomValidity || '';
+            return;
           }
         }
       }
@@ -8484,7 +9434,7 @@ class AuroFormValidation {
         if (input.validationMessage.length > 0) {
           elem.errorMessage = input.validationMessage;
         }
-      } else if (this.inputElements?.length > 0  && elem.errorMessage === '') {
+      } else if (this.inputElements?.length > 0 && elem.errorMessage === '') {
         const firstInput = this.inputElements[0];
 
         if (firstInput.validationMessage.length > 0) {
@@ -8606,6 +9556,33 @@ class BaseInput extends r$1 {
   static get properties() {
     return {
 
+      /**
+       * The value for the role attribute.
+       */
+      a11yRole: {
+        type: String,
+        attribute: true,
+        reflect: true
+      },
+
+      /**
+       * The value for the aria-expanded attribute.
+       */
+      a11yExpanded: {
+        type: Boolean,
+        attribute: true,
+        reflect: true
+      },
+
+      /**
+       * The value for the aria-controls attribute.
+       */
+      a11yControls: {
+        type: String,
+        attribute: true,
+        reflect: true
+      },
+
       /**
        * If set, the label will remain fixed in the active position.
        */
@@ -9247,6 +10224,10 @@ class BaseInput extends r$1 {
     } else if (this.type === 'number') {
       this.inputMode = 'numeric';
     }
+
+    if (this.type === "date" && !this.format) {
+      this.format = 'mm/dd/yyyy';
+    }
   }
 
   /**
@@ -10490,6 +11471,7 @@ var helpTextVersion = '1.0.0';
 
 // build the component class
 class AuroInput extends BaseInput {
+
   constructor() {
     super();
 
@@ -10602,7 +11584,7 @@ class AuroInput extends BaseInput {
             ?required="${this.required}"
             ?disabled="${this.disabled}"
             aria-describedby="${this.uniqueId}"
-            aria-invalid="${this.validity !== 'valid'}"
+            ?aria-invalid="${this.validity !== 'valid'}"
             placeholder=${this.getPlaceholder()}
             lang="${o(this.lang)}"
             ?activeLabel="${this.activeLabel}"
@@ -10611,7 +11593,10 @@ class AuroInput extends BaseInput {
             autocapitalize="${o(this.autocapitalize ? this.autocapitalize : undefined)}"
             autocomplete="${o(this.autocomplete ? this.autocomplete : undefined)}"
             part="input"
-            />
+            role="${o(this.a11yRole)}"
+            aria-expanded="${o(this.a11yExpanded)}"
+            aria-controls="${o(this.a11yControls)}"
+          />
         </div>
         <div
           class="notificationIcons"
@@ -11603,6 +12588,7 @@ var styleCss$3 = i$5`.util_displayInline{display:inline}.util_displayInlineBlock
 
 // build the component class
 class AuroCombobox extends r$1 {
+
   constructor() {
     super();
 
@@ -11614,6 +12600,8 @@ class AuroCombobox extends r$1 {
    * @returns {void} Internal defaults.
    */
   privateDefaults() {
+    this.dropdownOpen = false;
+    this.dropdownId = undefined;
     this.onDark = false;
 
     this.noFilter = false;
@@ -11693,6 +12681,26 @@ class AuroCombobox extends r$1 {
         reflect: true
       },
 
+      /**
+       * ID for the dropdown
+       * @private
+       */
+      dropdownId: {
+        type: String,
+        reflect: false,
+        attribute: false
+      },
+
+      /**
+       * Whether or not the dropdown is open
+       * @private
+       */
+      dropdownOpen: {
+        type: Boolean,
+        reflect: false,
+        attribute: false
+      },
+
       /**
        * When defined, sets persistent validity to `customError` and sets the validation message to the attribute value.
        */
@@ -11838,11 +12846,8 @@ class AuroCombobox extends r$1 {
       },
 
       /**
-       * Defines the screen size breakpoint (`xs`, `sm`, `md`, `lg`, `xl`, `disabled`)
-       * at which the dropdown switches to fullscreen mode on mobile. `disabled` indicates a dropdown should _never_ enter fullscreen.
-       *
-       * When expanded, the dropdown will automatically display in fullscreen mode
-       * if the screen size is equal to or smaller than the selected breakpoint.
+       * Defines the screen size breakpoint (`lg`, `md`, `sm`, or `xs`) at which the dropdown switches to fullscreen mode on mobile.
+       * When expanded, the dropdown will automatically display in fullscreen mode if the screen size is equal to or smaller than the selected breakpoint.
        * @default sm
        */
       fullscreenBreakpoint: {
@@ -11854,8 +12859,19 @@ class AuroCombobox extends r$1 {
        * @private
        */
       isDropdownFullscreen: {
-        type: Boolean
-      }
+        type: Boolean,
+        reflect: false
+      },
+
+      /**
+       * @private
+       * specifies the currently active option
+       */
+      optionActive: {
+        type: Object,
+        reflect: false,
+        attribute: false
+      },
     };
   }
 
@@ -12007,6 +13023,18 @@ class AuroCombobox extends r$1 {
    * @returns {void}
    */
   configureDropdown() {
+
+    // Listen for the ID to be added to the dropdown so we can capture it and use it for accessibility.
+    this.dropdown.addEventListener('auroDropdown-idAdded', (event) => {
+      this.dropdownId = event.detail.id;
+    });
+
+    // Listen for the dropdown to be shown or hidden
+    this.dropdown.addEventListener("auroDropdown-toggled", (ev) => {
+      this.dropdownOpen = ev.detail.expanded;
+    });
+
+    // this.dropdown.addEventListener('auroDropdown-show', () => {
     this.menuWrapper = this.dropdown.querySelector('.menuWrapper');
     this.menuWrapper.append(this.menu);
 
@@ -12020,7 +13048,6 @@ class AuroCombobox extends r$1 {
     this.hideBib = this.hideBib.bind(this);
     this.bibtemplate.addEventListener('close-click', this.hideBib);
 
-    this.dropdown.setAttribute('role', 'combobox');
     this.dropdown.addEventListener('auroDropdown-triggerClick', () => {
       this.showBib();
     });
@@ -12036,7 +13063,6 @@ class AuroCombobox extends r$1 {
       this.isDropdownFullscreen = event.detail.strategy === 'fullscreen';
       setTimeout(this.transportInput);
     });
-
   }
 
   /**
@@ -12530,6 +13556,10 @@ class AuroCombobox extends r$1 {
           ?noFlip="${this.noFlip}"
           disableEventShow>
           <${this.inputTag}
+            .a11yRole="${"combobox"}"
+            .a11yExpanded="${this.dropdownOpen}"
+            .a11yControls="${this.dropdownId}"
+            id="${this.id || 'auro-combobox-input'}"
             slot="trigger"
             bordered
             ?onDark="${this.onDark}"