@aurodesignsystem-dev/auro-formkit 0.0.0-pr1551.0 → 0.0.0-pr1552.0

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

@@ -1114,7 +1114,7 @@ let AuroHelpText$1 = class AuroHelpText extends i$2 {
   }
 };
 
-var formkitVersion$1 = '202607100029';
+var formkitVersion$1 = '202607092329';
 
 // Copyright (c) 2026 Alaska Airlines. All rights reserved. Licensed under the Apache-2.0 license
 // See LICENSE in the project root for license information.
@@ -3844,40 +3844,12 @@ 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;
     }
 
-    // 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");
+    this.hideBib("keydown");
   }
 
   setupHideHandlers() {
@@ -4547,6 +4519,199 @@ 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.
 
@@ -5044,7 +5209,7 @@ class AuroDropdownBib extends i$2 {
     classes[`shape-${this.shape}`] = true;
 
     return u$5`
-      <dialog tabindex="-1" class="${e$2(classes)}" part="bibContainer" role="${o$2(this.dialogRole)}" aria-labelledby="${o$2(this.dialogLabel ? 'dialogLabel' : undefined)}">
+      <dialog class="${e$2(classes)}" part="bibContainer" role="${o$2(this.dialogRole)}" aria-labelledby="${o$2(this.dialogLabel ? 'dialogLabel' : undefined)}">
         ${this.dialogLabel ? u$5`<span id="dialogLabel" class="util_displayHiddenVisually">${this.dialogLabel}</span>` : ''}
         <slot></slot>
         <span id="srAnnouncement" class="util_displayHiddenVisually" aria-live="polite" role="status"></span>
@@ -5295,7 +5460,7 @@ class AuroHelpText extends i$2 {
   }
 }
 
-var formkitVersion = '202607100029';
+var formkitVersion = '202607092329';
 
 let AuroElement$1 = class AuroElement extends i$2 {
   static get properties() {
@@ -6049,10 +6214,7 @@ class AuroDropdown extends AuroElement$1 {
     }
 
 
-    // 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.
-    if (!this.isPopoverVisible && eventType !== "focusloss") {
+    if (!this.isPopoverVisible) {
       // 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).
@@ -6282,16 +6444,15 @@ class AuroDropdown extends AuroElement$1 {
             }
           });
         } else {
-          // 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.
+          // 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);
           requestAnimationFrame(() => {
-            const focusables = getFocusableElements(this.bibContent);
-            if (focusables.length) {
-              focusables[0].focus();
+            if (this.focusTrap) {
+              this.focusTrap.focusFirstElement();
             }
           });
         }

package/components/counter/dist/index.js

@@ -1064,7 +1064,7 @@ let AuroHelpText$1 = class AuroHelpText extends LitElement {
   }
 };
 
-var formkitVersion$1 = '202607100029';
+var formkitVersion$1 = '202607092329';
 
 // Copyright (c) 2026 Alaska Airlines. All rights reserved. Licensed under the Apache-2.0 license
 // See LICENSE in the project root for license information.
@@ -3776,40 +3776,12 @@ 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;
     }
 
-    // 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");
+    this.hideBib("keydown");
   }
 
   setupHideHandlers() {
@@ -4479,6 +4451,199 @@ 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.
 
@@ -4976,7 +5141,7 @@ class AuroDropdownBib extends LitElement {
     classes[`shape-${this.shape}`] = true;
 
     return html`
-      <dialog tabindex="-1" class="${classMap(classes)}" part="bibContainer" role="${ifDefined(this.dialogRole)}" aria-labelledby="${ifDefined(this.dialogLabel ? 'dialogLabel' : undefined)}">
+      <dialog class="${classMap(classes)}" part="bibContainer" role="${ifDefined(this.dialogRole)}" aria-labelledby="${ifDefined(this.dialogLabel ? 'dialogLabel' : undefined)}">
         ${this.dialogLabel ? html`<span id="dialogLabel" class="util_displayHiddenVisually">${this.dialogLabel}</span>` : ''}
         <slot></slot>
         <span id="srAnnouncement" class="util_displayHiddenVisually" aria-live="polite" role="status"></span>
@@ -5227,7 +5392,7 @@ class AuroHelpText extends LitElement {
   }
 }
 
-var formkitVersion = '202607100029';
+var formkitVersion = '202607092329';
 
 let AuroElement$1 = class AuroElement extends LitElement {
   static get properties() {
@@ -5981,10 +6146,7 @@ class AuroDropdown extends AuroElement$1 {
     }
 
 
-    // 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.
-    if (!this.isPopoverVisible && eventType !== "focusloss") {
+    if (!this.isPopoverVisible) {
       // 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).
@@ -6214,16 +6376,15 @@ class AuroDropdown extends AuroElement$1 {
             }
           });
         } else {
-          // 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.
+          // 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);
           requestAnimationFrame(() => {
-            const focusables = getFocusableElements(this.bibContent);
-            if (focusables.length) {
-              focusables[0].focus();
+            if (this.focusTrap) {
+              this.focusTrap.focusFirstElement();
             }
           });
         }