@aurodesignsystem-dev/auro-formkit 0.0.0-pr1503.3 → 0.0.0-pr1503.5

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

@@ -2322,12 +2322,40 @@ class AuroFloatingUI {
       return;
     }
 
+    // Chrome-specific: during popover top-layer promotion after a click on a
+    // slotted focusable, :focus-within can briefly evaluate false while the
+    // active element is still structurally inside the trigger/bib. Fall back
+    // to a shadow-piercing ancestry walk from the deep active element before
+    // treating this as a real focus loss.
+    try {
+      let active = document.activeElement;
+      while (active && active.shadowRoot && active.shadowRoot.activeElement) {
+        active = active.shadowRoot.activeElement;
+      }
+      const targets = [element, element.trigger, element.bib].filter(Boolean);
+      let node = active;
+      while (node) {
+        if (targets.includes(node)) {
+          return;
+        }
+        node =
+          node.parentElement ||
+          (node.getRootNode && node.getRootNode().host) ||
+          null;
+      }
+    } catch (e) {
+      // Defensive: fall through to the existing close path if traversal fails.
+    }
+
     // if fullscreen bib is in fullscreen mode, do not close
     if (element.bib.hasAttribute("isfullscreen")) {
       return;
     }
 
-    this.hideBib("keydown");
+    // eventType "focusloss" distinguishes a Tab/click-driven close from an
+    // Escape keydown close. Consumers use this to decide whether to restore
+    // focus to the trigger (Escape) or let it advance naturally (Tab).
+    this.hideBib("focusloss");
   }
 
   setupHideHandlers() {
@@ -2997,199 +3025,6 @@ function getFocusableElements(container) {
   return tabIndexedUniqueElements;
 }
 
-/**
- * FocusTrap manages keyboard focus within a specified container element, ensuring that focus does not leave the container when tabbing.
- * It is commonly used for modal dialogs or overlays to improve accessibility by trapping focus within interactive UI components.
- */
-class FocusTrap {
-  /**
-   * Creates a new FocusTrap instance for the given container element.
-   * Initializes event listeners and prepares the container for focus management.
-   *
-   * @param {HTMLElement} container The DOM element to trap focus within.
-   * @param {boolean} [controlTabOrder=false] If true enables manual control of the tab order by the FocusTrap.
-   * @throws {Error} If the provided container is not a valid HTMLElement.
-   */
-  constructor(container, controlTabOrder = false) {
-    if (!container || !(container instanceof HTMLElement)) {
-      throw new Error("FocusTrap requires a valid HTMLElement.");
-    }
-
-    this.container = container;
-    this.tabDirection = "forward"; // or 'backward';
-    this.controlTabOrder = controlTabOrder;
-
-    this._init();
-  }
-
-  /**
-   * Initializes the focus trap by setting up event listeners and attributes on the container.
-   * Prepares the container for focus management, including support for shadow DOM and inert attributes.
-   *
-   * @private
-   */
-  _init() {
-    // Add inert attribute to prevent focusing programmatically as well (if supported)
-    if ("inert" in HTMLElement.prototype) {
-      this.container.inert = false; // Ensure the container isn't inert
-      this.container.setAttribute("data-focus-trap-container", true); // Mark for identification
-    }
-
-    // Track tab direction
-    this.container.addEventListener("keydown", this._onKeydown);
-  }
-
-  /**
-   * Gets an array of currently active (focused) elements in the document and shadow DOM.
-   * @returns {Array<HTMLElement>} An array of focusable elements within the container.
-   * @private
-   */
-  _getActiveElements() {
-    // Get the active element(s) in the document and shadow root
-    // This will include the active element in the shadow DOM if it exists
-    // Active element may be inside the shadow DOM depending on delegatesFocus, so we need to check both
-    let { activeElement } = document;
-    const actives = [activeElement];
-    while (activeElement?.shadowRoot?.activeElement) {
-      actives.push(activeElement.shadowRoot.activeElement);
-      activeElement = activeElement.shadowRoot.activeElement;
-    }
-    return actives;
-  }
-
-  /**
-   * Gets the next focus index based on the current index and focusable elements.
-   * @param {number} currentIndex The current index of the focused element.
-   * @param {Array<HTMLElement>} focusables The array of focusable elements.
-   * @returns {number|null} The next focus index or null if not determined.
-   */
-  _getNextFocusIndex(currentIndex, focusables, actives) {
-    if (this.controlTabOrder) {
-      // Calculate the new index based on the current index and tab direction
-      let newFocusIndex =
-        currentIndex + (this.tabDirection === "forward" ? 1 : -1);
-
-      // Wrap-around logic
-      if (newFocusIndex < 0) newFocusIndex = focusables.length - 1;
-      if (newFocusIndex >= focusables.length) newFocusIndex = 0;
-
-      // Early return with the new index
-      return newFocusIndex;
-    }
-
-    // Determine if we need to wrap
-    const atFirst =
-      actives.includes(focusables[0]) || actives.includes(this.container);
-    const atLast = actives.includes(focusables[focusables.length - 1]);
-
-    // Only wrap if at the ends
-    if (this.tabDirection === "backward" && atFirst) {
-      return focusables.length - 1;
-    }
-
-    if (this.tabDirection === "forward" && atLast) {
-      return 0;
-    }
-
-    // No wrap, so don't change focus, return early
-    return null;
-  }
-
-  /**
-   * Handles the Tab key press event to manage focus within the container.
-   * @param {KeyboardEvent} e The keyboard event triggered by the user.
-   * @returns {void}
-   */
-  _handleTabKey(e) {
-    // Update the focusable elements
-    const focusables = this._getFocusableElements();
-
-    // If there are no focusable elements, exit
-    if (!focusables.length) return;
-
-    // Set the tab direction based on the key pressed
-    this.tabDirection = e.shiftKey ? "backward" : "forward";
-
-    // Get the active elements that are currently focused
-    const actives = this._getActiveElements();
-
-    // If we're at either end of the focusable elements, wrap around to the other end
-    let focusIndex = focusables.findIndex((el) => actives.includes(el));
-
-    // Fallback if we have no focused element
-    if (focusIndex === -1) focusIndex = 0;
-
-    // Get the next focus index based on the current focus index, tab direction, and controlTabOrder setting
-    // Is null if no new focus index is determined
-    const newFocusIndex = this._getNextFocusIndex(
-      focusIndex,
-      focusables,
-      actives,
-    );
-
-    // If we have a new focus index, set focus to that element
-    if (newFocusIndex !== null) {
-      e.preventDefault();
-      focusables[newFocusIndex].focus();
-    }
-  }
-
-  /**
-   * Catches the keydown event
-   * @param {KeyboardEvent} e The keyboard event triggered by user interaction.
-   * @private
-   */
-  _onKeydown = (e) => {
-    // Handle tab
-    if (e.key === "Tab") this._handleTabKey(e);
-  };
-
-  /**
-   * Retrieves all focusable elements within the container in DOM order, including those in shadow DOM and slots.
-   * Returns a unique, ordered array of elements that can receive focus.
-   *
-   * @returns {Array<HTMLElement>} An array of focusable elements within the container.
-   * @private
-   */
-  _getFocusableElements() {
-    // Use the imported utility function to get focusable elements
-    const elements = getFocusableElements(this.container);
-
-    // Return the elements found
-    return elements;
-  }
-
-  /**
-   * Moves focus to the first focusable element within the container.
-   * Useful for setting initial focus when activating the focus trap.
-   */
-  focusFirstElement() {
-    const focusables = this._getFocusableElements();
-    if (focusables.length) focusables[0].focus();
-  }
-
-  /**
-   * Moves focus to the last focusable element within the container.
-   * Useful for setting focus when deactivating or cycling focus in reverse.
-   */
-  focusLastElement() {
-    const focusables = this._getFocusableElements();
-    if (focusables.length) focusables[focusables.length - 1].focus();
-  }
-
-  /**
-   * Removes event listeners and attributes added by the focus trap.
-   * Call this method to clean up when the focus trap is no longer needed.
-   */
-  disconnect() {
-    if (this.container.hasAttribute("data-focus-trap-container")) {
-      this.container.removeAttribute("data-focus-trap-container");
-    }
-
-    this.container.removeEventListener("keydown", this._onKeydown);
-  }
-}
-
 // Copyright (c) Alaska Air. All right reserved. Licensed under the Apache-2.0 license
 // See LICENSE in the project root for license information.
 
@@ -3721,7 +3556,7 @@ class AuroDropdownBib extends i {
     classes[`shape-${this.shape}`] = true;
 
     return u$2`
-      <dialog class="${e$4(classes)}" part="bibContainer" role="${o(this.dialogRole)}" aria-labelledby="${o(this.dialogLabel ? 'dialogLabel' : undefined)}">
+      <dialog tabindex="-1" class="${e$4(classes)}" part="bibContainer" role="${o(this.dialogRole)}" aria-labelledby="${o(this.dialogLabel ? 'dialogLabel' : undefined)}">
         ${this.dialogLabel ? u$2`<span id="dialogLabel" class="util_displayHiddenVisually">${this.dialogLabel}</span>` : ''}
         <slot></slot>
         <span id="srAnnouncement" class="util_displayHiddenVisually" aria-live="polite" role="status"></span>
@@ -3972,7 +3807,7 @@ class AuroHelpText extends i {
   }
 }
 
-var formkitVersion = '202606191810';
+var formkitVersion = '202607221815';
 
 class AuroElement extends i {
   static get properties() {
@@ -4101,7 +3936,6 @@ class AuroDropdown extends AuroElement {
   static get shadowRootOptions() {
     return {
       ...AuroElement.shadowRootOptions,
-      delegatesFocus: true,
     };
   }
 
@@ -4113,6 +3947,15 @@ class AuroDropdown extends AuroElement {
     this.matchWidth = false;
     this.noHideOnThisFocusLoss = false;
 
+    /**
+     * When true, the dropdown skips its generic focus restoration on close.
+     * Set by consumers (e.g. combobox) that manage their own focus routing
+     * via setClearBtnFocus / setInputFocus / keyboard strategy.
+     * Separate from noHideOnThisFocusLoss (which controls auto-close behavior).
+     * @private
+     */
+    this.noFocusRestoreOnClose = false;
+
     this.errorMessage = undefined; // TODO - check with Doug if there is still more to do here
 
     // Layout Config
@@ -4268,7 +4111,49 @@ class AuroDropdown extends AuroElement {
         focusables[0].focus();
       }
     } else {
+      this.focusTrigger();
+    }
+  }
+
+  /**
+   * Focus the trigger content. When the trigger wrapper itself is focusable
+   * (has tabindex), focus it directly. Otherwise, focus the first focusable
+   * element slotted into the trigger slot (e.g. the auro-input).
+   * @private
+   */
+  focusTrigger() {
+    if (this.trigger.hasAttribute('tabindex')) {
       this.trigger.focus();
+    } else {
+      // Slotted content isn't a DOM child of the trigger div, so
+      // getFocusableElements can't find it. Query assigned nodes directly.
+      const slot = this.trigger.querySelector('slot[name="trigger"]');
+      if (slot) {
+        const assigned = slot.assignedElements();
+        for (const el of assigned) {
+          if (el.hasAttribute('disabled')) {
+            continue; // eslint-disable-line no-continue
+          }
+          // Try finding a focusable descendant first (handles non-focusable
+          // wrappers like <div> containing a <button>). If none found, try
+          // focusing the element directly (works for custom elements like
+          // auro-input that have delegatesFocus or a custom focus() method).
+          const descendants = getFocusableElements(el);
+          if (descendants.length > 0) {
+            descendants[0].focus();
+            return;
+          }
+          el.focus();
+          if (document.activeElement === el) {
+            return;
+          }
+        }
+      }
+      // Fallback: try DOM children (non-slotted content)
+      const focusables = getFocusableElements(this.trigger);
+      if (focusables.length > 0) {
+        focusables[0].focus();
+      }
     }
   }
 
@@ -4644,10 +4529,17 @@ class AuroDropdown extends AuroElement {
     this.clearTriggerFocusEventBinding();
   }
 
+  // eslint-disable-next-line complexity
   updated(changedProperties) {
     super.updated(changedProperties);
     this.floater.handleUpdate(changedProperties);
 
+    // Close the dropdown if the disabled property is set to true
+    if (changedProperties.has('disabled') && this.disabled && this.isPopoverVisible) {
+      this.hide();
+      this.isPopoverVisible = false;
+    }
+
     // 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')) {
@@ -4721,8 +4613,30 @@ class AuroDropdown extends AuroElement {
     }
 
     const eventType = event.detail.eventType || "unknown";
-    if (!this.isPopoverVisible && this.hasFocus && eventType === "keydown") {
-      this.trigger.focus();
+    if (!this.isPopoverVisible && this.hasFocus && eventType === "keydown" && !this.noFocusRestoreOnClose) {
+      this.focusTrigger();
+    }
+
+
+    // On Tab-driven close (eventType "focusloss"), let focus advance naturally
+    // — restoring to the trigger would trap the user on this dropdown, forcing
+    // an extra Tab to move on. Escape and outside-click still restore.
+    // When noFocusRestoreOnClose is true, the consumer (e.g. combobox) manages
+    // its own focus restoration — skip the generic trigger focus to avoid races.
+    if (!this.isPopoverVisible && eventType !== "focusloss" && !this.noFocusRestoreOnClose) {
+      // wait til the bib gets fully closed and rendered
+      setTimeout(() => {
+        // Skip if the bib re-opened, or if focus moved intentionally outside the dropdown (not to body).
+        // Restore focus to trigger when focus is still inside the bib (:focus-within) or fell to body.
+        if (this.isPopoverVisible ||
+          // eslint-disable-next-line no-extra-parens
+          (!this.bibContent?.matches(':focus-within') &&
+            document.activeElement !== document.body)) {
+          return;
+        }
+        // Restore focus to the trigger.
+        this.focusTrigger();
+      });
     }
   }
 
@@ -4923,6 +4837,14 @@ class AuroDropdown extends AuroElement {
           };
           this.addEventListener('keydown', this._bibTabHandler);
 
+          // Suppress AuroFloatingUI's auto-hide-on-focus-loss while the
+          // desktopModal trap owns focus management. Without this, the very
+          // first focus move into the bib (from the RAF below) triggers
+          // handleFocusLoss → hideBib, tearing down the trap before the
+          // user can press Tab.
+          this._priorNoHideOnFocusLoss = this.noHideOnThisFocusLoss;
+          this.noHideOnThisFocusLoss = true;
+
           // Move initial focus into the bib content, matching FocusTrap behavior
           requestAnimationFrame(() => {
             const focusables = getFocusableElements(this.bibContent);
@@ -4931,15 +4853,16 @@ class AuroDropdown extends AuroElement {
             }
           });
         } else {
-          // Normal desktop: use FocusTrap on the bib element.
-          // Defer focusFirstElement to the next frame because the popover
-          // is positioned asynchronously by Floating UI — calling focus()
-          // synchronously here would target elements with zero dimensions
-          // and the focus call would be silently ignored.
-          this.focusTrap = new FocusTrap(this.bibContent);
+          // Normal desktop (non-modal): move initial focus into the bib but
+          // don't trap Tab. Tab should exit the bib and let the floater's
+          // handleFocusLoss close it, matching native <select>/<details>
+          // behavior. Deferred one frame because Floating UI positions the
+          // popover asynchronously — a synchronous focus() would target
+          // zero-dimension elements and be silently ignored.
           requestAnimationFrame(() => {
-            if (this.focusTrap) {
-              this.focusTrap.focusFirstElement();
+            const focusables = getFocusableElements(this.bibContent);
+            if (focusables.length) {
+              focusables[0].focus();
             }
           });
         }
@@ -5236,6 +5159,7 @@ class AuroDropdown extends AuroElement {
           role="${o(this.triggerContentFocusable ? undefined : this.a11yRole)}"
           aria-expanded="${o(this.a11yRole === 'button' || this.triggerContentFocusable ? undefined : this.isPopoverVisible)}"
           aria-controls="${o(this.a11yRole === 'button' || this.triggerContentFocusable ? undefined : this.dropdownId)}"
+          aria-haspopup="${o(this.a11yRole === 'combobox' && !this.triggerContentFocusable ? 'listbox' : undefined)}"
           aria-labelledby="${o(this.triggerContentFocusable ? undefined : 'triggerLabel')}"
           aria-disabled="${o(this.disabled ? 'true' : undefined)}"
           @focusin="${this.handleFocusin}"

package/components/dropdown/dist/auro-dropdown.d.ts

@@ -15,9 +15,9 @@
  */
 export class AuroDropdown extends AuroElement {
     static get shadowRootOptions(): {
-        delegatesFocus: boolean;
         clonable?: boolean;
         customElementRegistry?: CustomElementRegistry | null;
+        delegatesFocus?: boolean;
         mode: ShadowRootMode;
         serializable?: boolean;
         slotAssignment?: SlotAssignmentMode;
@@ -267,6 +267,14 @@ export class AuroDropdown extends AuroElement {
     isBibFullscreen: boolean;
     matchWidth: boolean;
     noHideOnThisFocusLoss: boolean;
+    /**
+     * When true, the dropdown skips its generic focus restoration on close.
+     * Set by consumers (e.g. combobox) that manage their own focus routing
+     * via setClearBtnFocus / setInputFocus / keyboard strategy.
+     * Separate from noHideOnThisFocusLoss (which controls auto-close behavior).
+     * @private
+     */
+    private noFocusRestoreOnClose;
     errorMessage: any;
     layout: any;
     shape: any;
@@ -366,6 +374,13 @@ export class AuroDropdown extends AuroElement {
      * If not, trigger element will get focus.
      */
     focus(): void;
+    /**
+     * Focus the trigger content. When the trigger wrapper itself is focusable
+     * (has tabindex), focus it directly. Otherwise, focus the first focusable
+     * element slotted into the trigger slot (e.g. the auro-input).
+     * @private
+     */
+    private focusTrigger;
     /**
      * Sets the active descendant element for accessibility.
      * Uses ariaActiveDescendantElement to cross shadow DOM boundaries.
@@ -412,6 +427,7 @@ export class AuroDropdown extends AuroElement {
     private updateFocusTrap;
     _noHideOverridden: boolean | undefined;
     _priorNoHide: any;
+    _priorNoHideOnFocusLoss: boolean | undefined;
     /**
      * Returns the chain of active (focused) elements through shadow roots.
      * @private