@aurodesignsystem/auro-formkit 3.0.1 → 3.1.0

package/components/counter/dist/index.js

@@ -915,11 +915,420 @@ let AuroIcon$2 = class AuroIcon extends BaseIcon$2 {
 
 var iconVersion$2 = '8.0.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 = 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;
+      }
+
+      // 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.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.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 = 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.
 
 
 class AuroFormValidation {
+
   constructor() {
     this.runtimeUtils = new AuroLibraryRuntimeUtils$3();
   }
@@ -1011,17 +1420,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)) {
@@ -1047,48 +1456,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) {
 
-          // validate max
-          if (elem.max?.length === elem.lengthForType) {
-            const maxDate = new Date(elem.util.toNorthAmericanFormat(elem.max, elem.format).dateForComparison);
+          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;
+        }
 
-            if (valueDate > maxDate) {
-              elem.validity = 'rangeOverflow';
-              elem.errorMessage = elem.setCustomValidityRangeOverflow || elem.setCustomValidity || '';
-            }
+        // Perform the rest of the validation
+        const formattedValue = toNorthAmericanFormat(elem.value, elem.format);
+        const valueDate = new Date(formattedValue);
+
+        // // 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;
           }
         }
       }
@@ -1207,7 +1650,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) {
@@ -3435,7 +3878,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.
@@ -3551,7 +3994,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();
     }
@@ -3727,7 +4170,7 @@ class AuroFloatingUI {
       this.id = window.crypto.randomUUID();
       this.element.setAttribute('id', this.id);
     }
-    
+
     this.element.bib.setAttribute("id", `${this.id}-floater-bib`);
   }
 
@@ -3780,7 +4223,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);
@@ -4509,6 +4952,7 @@ var helpTextVersion = '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 LitElement {
   constructor() {
@@ -4554,7 +4998,9 @@ class AuroDropdown extends LitElement {
     this.rounded = false;
     this.tabIndex = 0;
     this.noToggle = false;
+    this.a11yAutocomplete = 'none';
     this.labeled = true;
+    this.a11yRole = 'combobox';
     this.onDark = false;
 
     // floaterConfig
@@ -4690,6 +5136,16 @@ class AuroDropdown extends LitElement {
         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.
        */
@@ -4852,6 +5308,23 @@ class AuroDropdown extends LitElement {
        */
       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,
       }
     };
   }
@@ -4902,7 +5375,22 @@ class AuroDropdown extends LitElement {
   }
 
   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
@@ -5054,6 +5542,30 @@ class AuroDropdown extends LitElement {
     });
   }
 
+  /*
+   * 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.
    *
@@ -5067,32 +5579,41 @@ class AuroDropdown extends LitElement {
    * @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) {
@@ -5102,6 +5623,7 @@ class AuroDropdown extends LitElement {
 
     if (this.triggerContentSlot) {
       this.setupTriggerFocusEventBinding();
+
       this.hasTriggerContent = this.triggerContentSlot.some((slot) => {
         if (slot.textContent.trim()) {
           return true;
@@ -5169,10 +5691,13 @@ class AuroDropdown extends LitElement {
           id="trigger"
           class="trigger"
           part="trigger"
-          aria-labelledby="triggerLabel"
           tabindex="${this.tabIndex}"
           ?showBorder="${this.showTriggerBorders}"
-          >
+          role="${ifDefined(this.triggerContentFocusable ? undefined : this.a11yRole)}"
+          aria-expanded="${ifDefined(this.triggerContentFocusable ? undefined : this.isPopoverVisible)}"
+          aria-controls="${ifDefined(this.triggerContentFocusable ? undefined : this.dropdownId)}"
+          aria-labelledby="${ifDefined(this.triggerContentFocusable ? undefined : 'triggerLabel')}"
+        >
           <div class="triggerContentWrapper">
             <label class="label" id="triggerLabel" hasTrigger=${this.hasTriggerContent}>
               <slot name="label" @slotchange="${this.handleLabelSlotChange}"></slot>
@@ -5206,12 +5731,12 @@ class AuroDropdown extends LitElement {
         <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>
     `;