@aurodesignsystem-dev/auro-formkit 0.0.0-pr1600.3 → 0.0.0-pr1602.0

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

@@ -1127,7 +1127,7 @@ let AuroHelpText$1 = class AuroHelpText extends i$2 {
   }
 };
 
-var formkitVersion$1 = '202609011635';
+var formkitVersion$1 = '202609021726';
 
 // Copyright (c) 2026 Alaska Airlines. All rights reserved. Licensed under the Apache-2.0 license
 // See LICENSE in the project root for license information.
@@ -1485,6 +1485,17 @@ class AuroCounter extends i$2 {
     this.validation.validate(this, force);
   }
 
+  /**
+   * Resets the counter to its default state, clearing validity/touched state and returning
+   * the value to `min` — matching the clear-on-reset behavior of the other Auro form elements.
+   * @returns {void}
+   */
+  reset() {
+    // validation.reset() clears validity/touched and sets value to undefined; initValue() then restores the min floor.
+    this.validation.reset(this);
+    this.initValue();
+  }
+
   firstUpdated() {
     this.initValue();
     this.setTagAttribute("auro-counter");
@@ -4473,7 +4484,7 @@ class AuroFloatingUI {
 }
 
 // Selectors for focusable elements
-const FOCUSABLE_SELECTORS = [
+const FOCUSABLE_SELECTORS$1 = [
   "a[href]",
   "button:not([disabled])",
   "textarea:not([disabled])",
@@ -4487,7 +4498,7 @@ const FOCUSABLE_SELECTORS = [
 ];
 
 // List of custom components that are known to be focusable
-const FOCUSABLE_COMPONENTS = [
+const FOCUSABLE_COMPONENTS$1 = [
   "auro-checkbox",
   "auro-radio",
   "auro-dropdown",
@@ -4509,12 +4520,12 @@ const FOCUSABLE_COMPONENTS = [
  * @param {HTMLElement} element The element to check for focusability.
  * @returns {boolean} True if the element is a focusable custom component, false otherwise.
  */
-function isFocusableComponent(element) {
+function isFocusableComponent$1(element) {
   const componentName = element.tagName.toLowerCase();
 
   // Guard Clause: Element is a focusable component
   if (
-    !FOCUSABLE_COMPONENTS.some(
+    !FOCUSABLE_COMPONENTS$1.some(
       (name) => element.hasAttribute(name) || componentName === name,
     )
   )
@@ -4538,7 +4549,7 @@ function isFocusableComponent(element) {
  * @param {HTMLElement} element The element whose tabindex to read.
  * @returns {?number} The numeric tabindex or null if missing/invalid.
  */
-function getNumericTabIndex(element) {
+function getNumericTabIndex$1(element) {
   const raw = element.getAttribute("tabindex");
   if (raw == null) return null;
 
@@ -4554,7 +4565,7 @@ function getNumericTabIndex(element) {
  * @param {HTMLElement} container The container to search within
  * @returns {Array<HTMLElement>} An array of focusable elements within the container.
  */
-function getFocusableElements(container) {
+function getFocusableElements$1(container) {
   // Get elements in DOM order by walking the tree
   const orderedFocusableElements = [];
 
@@ -4563,7 +4574,7 @@ function getFocusableElements(container) {
     // Check if current element is focusable
     if (root.nodeType === Node.ELEMENT_NODE) {
       // Check if this is a custom component that is focusable
-      const isComponentFocusable = isFocusableComponent(root);
+      const isComponentFocusable = isFocusableComponent$1(root);
 
       if (isComponentFocusable) {
         // Add the component itself as a focusable element and don't traverse its shadow DOM
@@ -4572,7 +4583,7 @@ function getFocusableElements(container) {
       }
 
       // Check if the element itself matches any selector
-      for (const selector of FOCUSABLE_SELECTORS) {
+      for (const selector of FOCUSABLE_SELECTORS$1) {
         if (root.matches?.(selector)) {
           orderedFocusableElements.push(root);
           break; // Once we know it's focusable, no need to check other selectors
@@ -4626,20 +4637,20 @@ function getFocusableElements(container) {
 
   // First extract elements with valid positive tabindex
   const elementsWithTabindex = uniqueElements.filter((el) => {
-    const tabindex = getNumericTabIndex(el);
+    const tabindex = getNumericTabIndex$1(el);
     return tabindex !== null && tabindex > 0;
   });
 
   // Sort these elements by their tabindex value
   elementsWithTabindex.sort((a, b) => {
-    const aIndex = getNumericTabIndex(a) ?? 0;
-    const bIndex = getNumericTabIndex(b) ?? 0;
+    const aIndex = getNumericTabIndex$1(a) ?? 0;
+    const bIndex = getNumericTabIndex$1(b) ?? 0;
     return aIndex - bIndex;
   });
 
   // Elements without tabindex (preserving their original order)
   const elementsWithoutTabindex = uniqueElements.filter((el) => {
-    const tabindex = getNumericTabIndex(el);
+    const tabindex = getNumericTabIndex$1(el);
 
     // Elements without tabindex or with tabindex of 0 stay in DOM order
     return tabindex === null || tabindex === 0;
@@ -5434,7 +5445,7 @@ class AuroHelpText extends i$2 {
   }
 }
 
-var formkitVersion = '202609011635';
+var formkitVersion = '202609021726';
 
 /**
  * AuroElement is the shared base class for layout-aware Auro form components.
@@ -5734,7 +5745,7 @@ class AuroDropdown extends AuroElement$1 {
    */
   focus() {
     if (this.isPopoverVisible && this.bibContent) {
-      const focusables = getFocusableElements(this.bibContent);
+      const focusables = getFocusableElements$1(this.bibContent);
       if (focusables.length > 0) {
         focusables[0].focus();
       }
@@ -5766,7 +5777,7 @@ class AuroDropdown extends AuroElement$1 {
           // 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);
+          const descendants = getFocusableElements$1(el);
           if (descendants.length > 0) {
             descendants[0].focus();
             return;
@@ -5778,7 +5789,7 @@ class AuroDropdown extends AuroElement$1 {
         }
       }
       // Fallback: try DOM children (non-slotted content)
-      const focusables = getFocusableElements(this.trigger);
+      const focusables = getFocusableElements$1(this.trigger);
       if (focusables.length > 0) {
         focusables[0].focus();
       }
@@ -6457,7 +6468,7 @@ class AuroDropdown extends AuroElement$1 {
             }
 
             // Collect focusable elements from the bib content.
-            const focusables = getFocusableElements(this.bibContent);
+            const focusables = getFocusableElements$1(this.bibContent);
 
             // Fallback: try from slotted content directly
             if (!focusables.length) {
@@ -6466,7 +6477,7 @@ class AuroDropdown extends AuroElement$1 {
 
               for (const node of assignedNodes) {
                 if (node.nodeType === Node.ELEMENT_NODE) {
-                  focusables.push(...getFocusableElements(node));
+                  focusables.push(...getFocusableElements$1(node));
                 }
               }
             }
@@ -6526,7 +6537,7 @@ class AuroDropdown extends AuroElement$1 {
 
           // Move initial focus into the bib content, matching FocusTrap behavior
           requestAnimationFrame(() => {
-            const focusables = getFocusableElements(this.bibContent);
+            const focusables = getFocusableElements$1(this.bibContent);
             if (focusables.length) {
               focusables[0].focus();
             }
@@ -6539,7 +6550,7 @@ class AuroDropdown extends AuroElement$1 {
           // popover asynchronously — a synchronous focus() would target
           // zero-dimension elements and be silently ignored.
           requestAnimationFrame(() => {
-            const focusables = getFocusableElements(this.bibContent);
+            const focusables = getFocusableElements$1(this.bibContent);
             if (focusables.length) {
               focusables[0].focus();
             }
@@ -6757,7 +6768,7 @@ class AuroDropdown extends AuroElement$1 {
       if (triggerContentNodes) {
 
         // See if any of them are focusable elements
-        this.triggerContentFocusable = triggerContentNodes.some((node) => getFocusableElements(node).length > 0);
+        this.triggerContentFocusable = triggerContentNodes.some((node) => getFocusableElements$1(node).length > 0);
 
         // If any of them are focusable elements
         if (this.triggerContentFocusable) {
@@ -7519,9 +7530,241 @@ class AuroElement extends i$2 {
   }
 }
 
+// Selectors for focusable elements
+const FOCUSABLE_SELECTORS = [
+  "a[href]",
+  "button:not([disabled])",
+  "textarea:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  '[role="tab"]:not([disabled])',
+  '[role="link"]:not([disabled])',
+  '[role="button"]:not([disabled])',
+  '[tabindex]:not([tabindex="-1"])',
+  '[contenteditable]:not([contenteditable="false"])',
+];
+
+// List of custom components that are known to be focusable
+const FOCUSABLE_COMPONENTS = [
+  "auro-checkbox",
+  "auro-radio",
+  "auro-dropdown",
+  "auro-button",
+  "auro-combobox",
+  "auro-input",
+  "auro-counter",
+  // 'auro-menu', // Auro menu is not focusable by default, it uses a different interaction model
+  "auro-select",
+  "auro-datepicker",
+  "auro-hyperlink",
+  "auro-accordion",
+];
+
+/**
+ * Determines if a given element is a custom focusable component.
+ * Returns true if the element matches a known focusable component and is not disabled.
+ *
+ * @param {HTMLElement} element The element to check for focusability.
+ * @returns {boolean} True if the element is a focusable custom component, false otherwise.
+ */
+function isFocusableComponent(element) {
+  const componentName = element.tagName.toLowerCase();
+
+  // Guard Clause: Element is a focusable component
+  if (
+    !FOCUSABLE_COMPONENTS.some(
+      (name) => element.hasAttribute(name) || componentName === name,
+    )
+  )
+    return false;
+
+  // Guard Clause: Element is not disabled
+  if (element.hasAttribute("disabled")) return false;
+
+  // Guard Clause: The element is a hyperlink and has no href attribute
+  if (componentName.match("hyperlink") && !element.hasAttribute("href"))
+    return false;
+
+  // If all guard clauses pass, the element is a focusable component
+  return true;
+}
+
+/**
+ * Safely get a numeric tabindex for an element.
+ * Returns a number if the tabindex is a valid integer, otherwise null.
+ *
+ * @param {HTMLElement} element The element whose tabindex to read.
+ * @returns {?number} The numeric tabindex or null if missing/invalid.
+ */
+function getNumericTabIndex(element) {
+  const raw = element.getAttribute("tabindex");
+  if (raw == null) return null;
+
+  const value = Number.parseInt(raw, 10);
+  return Number.isNaN(value) ? null : value;
+}
+
+/**
+ * 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.
+ * Also sorts elements with tabindex first, preserving their order.
+ *
+ * @param {HTMLElement} container The container to search within
+ * @returns {Array<HTMLElement>} An array of focusable elements within the container.
+ */
+function getFocusableElements(container) {
+  // Get elements in DOM order by walking the tree
+  const orderedFocusableElements = [];
+
+  // Define a recursive function to collect focusable elements in DOM order
+  const collectFocusableElements = (root) => {
+    // Check if current element is focusable
+    if (root.nodeType === Node.ELEMENT_NODE) {
+      // Check if this is a custom component that is focusable
+      const isComponentFocusable = isFocusableComponent(root);
+
+      if (isComponentFocusable) {
+        // Add the component itself as a focusable element and don't traverse its shadow DOM
+        orderedFocusableElements.push(root);
+        return; // Skip traversing inside this component
+      }
+
+      // Check if the element itself matches any selector
+      for (const selector of FOCUSABLE_SELECTORS) {
+        if (root.matches?.(selector)) {
+          orderedFocusableElements.push(root);
+          break; // Once we know it's focusable, no need to check other selectors
+        }
+      }
+
+      // Process shadow DOM only for non-Auro components
+      if (root.shadowRoot) {
+        // Process shadow DOM children in order
+        if (root.shadowRoot.children) {
+          Array.from(root.shadowRoot.children).forEach((child) => {
+            collectFocusableElements(child);
+          });
+        }
+      }
+
+      // Process slots and their assigned nodes in order
+      if (root.tagName === "SLOT") {
+        const assignedNodes = root.assignedNodes({ flatten: true });
+        for (const node of assignedNodes) {
+          collectFocusableElements(node);
+        }
+      } else {
+        // Process light DOM children in order
+        if (root.children) {
+          Array.from(root.children).forEach((child) => {
+            collectFocusableElements(child);
+          });
+        }
+      }
+    }
+  };
+
+  // Start the traversal from the container
+  collectFocusableElements(container);
+
+  // Remove duplicates that might have been collected through different paths
+  // while preserving order
+  const uniqueElements = [];
+  const seen = new Set();
+
+  for (const element of orderedFocusableElements) {
+    if (!seen.has(element)) {
+      seen.add(element);
+      uniqueElements.push(element);
+    }
+  }
+
+  // Move tab-indexed elements to the front while preserving their order
+  // This ensures that elements with tabindex are prioritized in the focus order
+
+  // First extract elements with valid positive tabindex
+  const elementsWithTabindex = uniqueElements.filter((el) => {
+    const tabindex = getNumericTabIndex(el);
+    return tabindex !== null && tabindex > 0;
+  });
+
+  // Sort these elements by their tabindex value
+  elementsWithTabindex.sort((a, b) => {
+    const aIndex = getNumericTabIndex(a) ?? 0;
+    const bIndex = getNumericTabIndex(b) ?? 0;
+    return aIndex - bIndex;
+  });
+
+  // Elements without tabindex (preserving their original order)
+  const elementsWithoutTabindex = uniqueElements.filter((el) => {
+    const tabindex = getNumericTabIndex(el);
+
+    // Elements without tabindex or with tabindex of 0 stay in DOM order
+    return tabindex === null || tabindex === 0;
+  });
+
+  // Combine both arrays with tabindex elements first
+  const tabIndexedUniqueElements = [
+    ...elementsWithTabindex,
+    ...elementsWithoutTabindex,
+  ];
+
+  return tabIndexedUniqueElements;
+}
+
 // Copyright (c) 2026 Alaska Airlines. All rights reserved. Licensed under the Apache-2.0 license
 // See LICENSE in the project root for license information.
 
+
+/**
+ * Whether `el` is currently visible enough to receive focus. Prefers the
+ * browser's `checkVisibility()`; otherwise combines a display/visibility check
+ * with an ancestor-hidden probe that keeps position:fixed elements visible.
+ * @param {Element} el - The element to test.
+ * @returns {boolean}
+ */
+function isVisibleForFocus(el) {
+  if (typeof el.checkVisibility === 'function') {
+    return el.checkVisibility();
+  }
+  const style = el.ownerDocument.defaultView.getComputedStyle(el);
+  if (style.display === 'none' || style.visibility === 'hidden') {
+    return false;
+  }
+  return el.offsetParent !== null || style.position === 'fixed';
+}
+
+/**
+ * Return the tab stop that comes before the counter-group in page tab order,
+ * skipping any hidden entries the walker doesn't filter itself. The group host
+ * itself is not a tab stop; its focusables (the internal dropdown and the
+ * counters) are, so anchor the search on the group's earliest focusable.
+ * @param {Element} component - The auro-counter-group host element.
+ * @returns {Element|null}
+ */
+function getPreviousTabStop(component) {
+  const tabStops = getFocusableElements(component.ownerDocument.body);
+  const counters = component.counters || [];
+  const owned = [
+    component,
+    component.dropdown,
+    ...counters
+  ].filter(Boolean);
+  let groupStart = tabStops.length;
+  owned.forEach((node) => {
+    const index = tabStops.indexOf(node);
+    if (index >= 0 && index < groupStart) {
+      groupStart = index;
+    }
+  });
+  for (let index = groupStart - 1; index >= 0; index -= 1) {
+    if (isVisibleForFocus(tabStops[index])) {
+      return tabStops[index];
+    }
+  }
+  return null;
+}
+
 const counterGroupKeyboardStrategy = {
   Escape(component, evt) {
     if (!component.dropdown || !component.dropdown.isPopoverVisible) {
@@ -7535,6 +7778,48 @@ const counterGroupKeyboardStrategy = {
 
     component.dropdown.hide();
   },
+
+  Tab(component, evt, ctx) {
+    // Forward Tab already exits past the bib content and the focusout handler
+    // closes the bib. Fullscreen relies on the dialog's native focus trapping.
+    if (!ctx.isExpanded || ctx.isModal || !evt.shiftKey) {
+      return;
+    }
+
+    // The trigger precedes the bib content in the flattened tab order, so a
+    // native Shift+Tab off the first counter lands back on the trigger and
+    // leaves the bib open. Only intercept when focus is on the first focusable
+    // in the bib; otherwise let the browser move to the previous counter.
+    // `composedPath()` reports the real event origin through every shadow
+    // boundary, unlike `document.activeElement`, which retargets to the first
+    // slotted counter and cannot tell the counters apart.
+    const focusables = getFocusableElements(component.dropdown.bibContent);
+    if (!focusables.length) {
+      return;
+    }
+
+    const path = evt.composedPath();
+    const activeIndex = focusables.findIndex((el) => path.includes(el));
+    if (activeIndex !== 0) {
+      return;
+    }
+
+    const previousTabStop = getPreviousTabStop(component);
+
+    // Always suppress the native Shift+Tab. Otherwise it fires against the bib
+    // as it is torn down and lands focus on the trigger (which precedes the
+    // first counter), re-opening the exact loop this handler prevents. When
+    // nothing precedes the group, focus falls to the body instead of the
+    // trigger, which reads as exiting the group backward.
+    evt.preventDefault();
+    component.hideBib();
+
+    if (!previousTabStop) {
+      return;
+    }
+
+    doubleRaf(() => previousTabStop.focus());
+  },
 };
 
 /* eslint-disable lit/no-invalid-html, lit/binding-positions, max-lines, no-underscore-dangle, arrow-parens, no-confusing-arrow, curly, dot-location, no-inline-comments, line-comment-position,
@@ -8162,6 +8447,19 @@ class AuroCounterGroup extends AuroElement {
     this.validation.validate(this, force);
   }
 
+  /**
+   * Resets the counter group to its initial state by resetting each child counter and clearing validity.
+   * Each child reset dispatches an `input` event, which triggers `updateValue()` to recompute `value`/`total`.
+   * @returns {void}
+   */
+  reset() {
+    if (this.counters) {
+      this.counters.forEach((counter) => counter.reset());
+    }
+
+    this.validation.reset(this);
+  }
+
   updated(changedProperties) {
     if (changedProperties.has("value")) {
       this.validate();

package/components/counter/dist/auro-counter-group.d.ts

@@ -346,6 +346,12 @@ export class AuroCounterGroup extends AuroElement {
      * @param {boolean} [force=false] - Whether to force validation.
      */
     validate(force?: boolean): void;
+    /**
+     * Resets the counter group to its initial state by resetting each child counter and clearing validity.
+     * Each child reset dispatches an `input` event, which triggers `updateValue()` to recompute `value`/`total`.
+     * @returns {void}
+     */
+    reset(): void;
     updated(changedProperties: any): void;
     firstUpdated(): void;
     /**

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

@@ -129,6 +129,12 @@ export class AuroCounter extends LitElement {
      * @param {boolean} [force=false] - Whether to force validation.
      */
     validate(force?: boolean): void;
+    /**
+     * Resets the counter to its default state, clearing validity/touched state and returning
+     * the value to `min` — matching the clear-on-reset behavior of the other Auro form elements.
+     * @returns {void}
+     */
+    reset(): void;
     firstUpdated(): void;
     /**
      * Sets an attribute that matches the default tag name if the tag name is not the default.

package/components/counter/dist/counterGroupKeyboardStrategy.d.ts

@@ -1,3 +1,4 @@
 export namespace counterGroupKeyboardStrategy {
     function Escape(component: any, evt: any): void;
+    function Tab(component: any, evt: any, ctx: any): void;
 }