@aurodesignsystem/auro-formkit 6.0.2 → 6.0.3

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

@@ -172,6 +172,7 @@ export class AuroMenu extends AuroElement {
      * @public
      */
     public selectByValue(value: string | string[] | undefined | null): void;
+    _selectedKey: any;
     firstUpdated(): void;
     loadingSlots: NodeListOf<Element> | undefined;
     /**
@@ -181,6 +182,7 @@ export class AuroMenu extends AuroElement {
      */
     private setTagAttribute;
     updated(changedProperties: any): void;
+    _valueChangeFromSelection: boolean | undefined;
     _index: number | undefined;
     /**
      * Updates the UI state and appearance of menu items based on changed properties.
@@ -199,6 +201,19 @@ export class AuroMenu extends AuroElement {
      */
     private initItems;
     items: Element[] | undefined;
+    /**
+     * Assigns a private, auto-generated unique key (`_optionKey`) to each menu
+     * option that does not already have one. Keys are internal state on the
+     * element instance — never reflected as an attribute or exposed publicly —
+     * and let selection tracking distinguish options that share the same `value`.
+     *
+     * The `_optionKey === undefined` guard makes this idempotent: options keep the
+     * key they were first assigned across re-renders and slot changes, and if a
+     * nested menu's lifecycle runs a pass before the root, options simply wait for
+     * the root to key them (or keep whatever key they already hold).
+     * @private
+     */
+    private _assignOptionKeys;
     /**
      * Updates menu state when an option is selected.
      * @private
@@ -216,6 +231,14 @@ export class AuroMenu extends AuroElement {
      * @private
      */
     private clearSelection;
+    /**
+     * Re-sorts the multi-select selection into DOM order and rebuilds the derived
+     * `_selectedKey` and `value` from `optionSelected`. Selection is always stored
+     * and serialized in the order options appear in the menu, never in click
+     * order — so selecting C then A yields `[A, C]`.
+     * @private
+     */
+    private _sortSelectedByDomOrder;
     /**
      * Resets the menu to its initial state.
      * This is the only way to return value to undefined.

package/components/menu/dist/index.js

@@ -279,6 +279,116 @@ function isSelectableByValue(option) {
          !option.hasAttribute('static');
 }
 
+/* eslint-disable no-underscore-dangle */
+/**
+ * Resolves the single selected option for a given `value`, preferring the
+ * option tracked by `selectedKey` (a user-initiated selection) over a
+ * first-by-value match. When multiple options share the same `value`, matching
+ * by `value` alone cannot distinguish which one the user picked; the key
+ * disambiguates it.
+ *
+ * The key is trusted only when it still resolves to an option whose `value`
+ * matches the requested `value`. If the key is stale (option removed) or the
+ * value was changed programmatically, resolution falls back to value matching —
+ * preserving backward-compatible behavior for preselection and `selectByValue`.
+ * @private
+ * @param {Array<HTMLElement>} items - The menu's flat option list.
+ * @param {string} value - The value to resolve.
+ * @param {string|undefined} selectedKey - The `_optionKey` of the user-selected option, if any.
+ * @returns {HTMLElement|undefined} The resolved option, or undefined when none match.
+ */
+function resolveSelectedOption(items, value, selectedKey) {
+  if (!items) {
+    return undefined;
+  }
+
+  if (selectedKey !== undefined) {
+    const keyed = items.find((item) => item._optionKey === selectedKey);
+    if (keyed && isSelectableByValue(keyed) && keyed.value === value) {
+      return keyed;
+    }
+    // Key exists but the option is gone or its value no longer matches — fall
+    // through to value-based matching.
+  }
+
+  return items.find((item) => isSelectableByValue(item) && item.value === value);
+}
+
+/**
+ * Resolves the selected options for a multi-select `value` array, preferring
+ * options tracked by `selectedKeys` (user-initiated selections) and falling
+ * back to value matching for any values not resolved by key. The result is
+ * always sorted into DOM order regardless of selection sequence.
+ * @private
+ * @param {Array<HTMLElement>} items - The menu's flat option list.
+ * @param {Array<string>} valueArray - The selected values.
+ * @param {Array<string>|undefined} selectedKeys - The `_optionKey`s of the user-selected options, if any.
+ * @returns {Array<HTMLElement>} The resolved options in DOM order.
+ */
+function resolveSelectedOptions(items, valueArray, selectedKeys) {
+  if (!items) {
+    return [];
+  }
+
+  const resolved = [];
+  // Mirror `resolved` as a Set for O(1) membership checks below, matching the
+  // indexMap optimization used for the sort rather than scanning `resolved`
+  // on every candidate.
+  const resolvedSet = new Set();
+
+  // Track how many of each value are still available to resolve. A value that
+  // appears N times in `valueArray` may be satisfied at most N times total across
+  // the key pass and the value fallback below — matching by count, not presence,
+  // on BOTH passes. This stops a duplicate value from being over-resolved: e.g.
+  // two keyed options that both carry `SEA` cannot both match a single requested
+  // `SEA` (which happens when `value` is set directly without clearing
+  // `_selectedKey`, so more keys survive than the value set now asks for).
+  const remaining = new Map();
+  valueArray.forEach((val) => remaining.set(val, (remaining.get(val) || 0) + 1));
+
+  // Resolve by key first: trust a key only when its option is still selectable
+  // and there is still an unmatched occurrence of its value in the request set.
+  if (Array.isArray(selectedKeys)) {
+    selectedKeys.forEach((key) => {
+      const keyed = items.find((item) => item._optionKey === key);
+      if (keyed && isSelectableByValue(keyed) && (remaining.get(keyed.value) || 0) > 0 && !resolvedSet.has(keyed)) {
+        resolved.push(keyed);
+        resolvedSet.add(keyed);
+        remaining.set(keyed.value, remaining.get(keyed.value) - 1);
+      }
+    });
+  }
+
+  // Fall back to value matching for the occurrences not resolved by key. Iterate
+  // the leftover per-value counts so a value that appears twice but was only
+  // resolved once by key still matches its remaining occurrence(s).
+  remaining.forEach((count, val) => {
+    for (let occurrence = 0; occurrence < count; occurrence += 1) {
+      const option = items.find((item) => isSelectableByValue(item) && item.value === val && !resolvedSet.has(item));
+      if (option) {
+        resolved.push(option);
+        resolvedSet.add(option);
+      }
+    }
+  });
+
+  // Always return in DOM order so display is consistent regardless of the order
+  // keys/values were selected. Every resolved option came from `items`, so an
+  // O(1) index lookup mirrors `_sortSelectedByDomOrder` and avoids the O(n)
+  // `items.indexOf` per comparison for large combobox option sets. Any element
+  // not in `items` (a stale snapshot from a future caller) sorts to the END via
+  // `?? items.length`, matching `_sortSelectedByDomOrder` and avoiding NaN
+  // comparisons.
+  const indexMap = new Map(items.map((item, index) => [
+    item,
+    index
+  ]));
+  resolved.sort((optionA, optionB) => (indexMap.get(optionA) ?? items.length) - (indexMap.get(optionB) ?? items.length));
+
+  return resolved;
+}
+/* eslint-enable no-underscore-dangle */
+
 /**
  * Helper method to dispatch custom events.
  * @param {HTMLElement} element - Element to dispatch event from.
@@ -304,6 +414,14 @@ function dispatchMenuEvent(element, eventName, detail = null) {
 // See LICENSE in the project root for license information.
 
 
+/**
+ * Monotonically increasing counter used to give each menu instance a unique
+ * `_menuInstanceId` prefix. Auto-generating the id (rather than using a random
+ * string) keeps option keys deterministic and collision-free across menus.
+ * @private
+ */
+let menuInstanceIdCounter = 0;
+
 
 /**
  * The `auro-menu` element provides users a way to select from a list of options.
@@ -375,9 +493,8 @@ class AuroMenu extends AuroElement {
 
     // Instance properties (non-reactive)
 
-    /**
-     * @private
-     */
+    menuInstanceIdCounter += 1;
+
     Object.assign(this, {
       // Root-level menu (true) or a nested submenu (false)
       rootMenu: true,
@@ -387,6 +504,21 @@ class AuroMenu extends AuroElement {
       nestingSpacer: '<span class="nestingSpacer"></span>',
       // Loading indicator for slot elements
       loadingSlots: null,
+      // Unique id for this menu instance; prefixes every auto-generated option
+      // key so keys never collide across menus in the same document.
+      _menuInstanceId: `menu-${menuInstanceIdCounter}`,
+      // Monotonically increasing counter for option key generation. Never
+      // resets, so a key is never reused within this instance's lifetime.
+      _optionKeyCounter: 0,
+      // Key(s) of the option(s) the user has actively selected. A single string
+      // in single-select, an array in multi-select, undefined when nothing is
+      // user-selected. Used to disambiguate options that share a `value`.
+      _selectedKey: undefined,
+      // True only for the one updated() cycle following a user selection, so
+      // reconciliation trusts `_selectedKey`. A `value` change from a consumer's
+      // direct property assignment leaves this false, dropping the stale key so
+      // reconciliation falls back to first-by-value (see updated()).
+      _valueChangeFromSelection: false,
     });
   }
 
@@ -606,6 +738,13 @@ class AuroMenu extends AuroElement {
       return;
     }
 
+    // A programmatic value set carries no positional intent, so drop any
+    // `_selectedKey` left over from a prior user click. This makes reconciliation
+    // in updated() fall back to first-by-value (single) / value-in-DOM-order
+    // (multi), matching the documented contract for programmatic selection even
+    // when a stale key would still resolve to a duplicate-value option.
+    this._selectedKey = undefined;
+
     // `value` is a String property; stringify arrays so attribute reflection and `formattedValue` parsing stay correct.
     this.value = Array.isArray(value) ? JSON.stringify(value) : value;
   }
@@ -653,6 +792,17 @@ class AuroMenu extends AuroElement {
   updated(changedProperties) {
     super.updated(changedProperties);
 
+    // Consume the selection-driven flag for THIS cycle up front. Clearing it
+    // unconditionally — not only inside the `value` branch below — prevents it
+    // from lingering `true` when a selection produces a serialized `value`
+    // byte-identical to the current one, in which case Lit schedules no
+    // `value`-change cycle to consume it. A lingering flag would misclassify a
+    // later consumer's programmatic `value` set as selection-driven and keep a
+    // stale `_selectedKey`. The reconcile path below re-sets the instance flag
+    // after this point, so its intentional cross-cycle hand-off still works.
+    const valueChangeFromSelection = this._valueChangeFromSelection;
+    this._valueChangeFromSelection = false;
+
     // Single source of truth for 'auroMenu-selectedOption'. Selection handlers
     // mutate optionSelected and let Lit's update cycle dispatch here; the prior
     // .value comparison missed multi-select array changes and combined with the
@@ -676,6 +826,17 @@ class AuroMenu extends AuroElement {
         this.initItems();
       }
 
+      // Distinguish a selection-driven `value` change (a user click, which set
+      // the flag in handleSelectState / _sortSelectedByDomOrder) from a
+      // programmatic assignment by a consumer. A programmatic set carries no
+      // positional intent, so drop any leftover `_selectedKey` and let
+      // reconciliation fall back to first-by-value (single) / value-in-DOM-order
+      // (multi) — the same contract selectByValue() guarantees, even when a
+      // stale key would otherwise still resolve to a duplicate-value option.
+      if (!valueChangeFromSelection) {
+        this._selectedKey = undefined;
+      }
+
       // Set when reconciliation reassigns `value` below. That reassignment schedules a
       // second updated() cycle, so the `event`-attribute dispatch is deferred to that
       // cycle to avoid firing option custom events twice on the same selection.
@@ -693,19 +854,55 @@ class AuroMenu extends AuroElement {
           // Defensive default: `formattedValue` can be undefined for unexpected value types,
           // and calling `.includes` on undefined would throw during reconciliation.
           const valueArray = this.formattedValue || [];
-          const matchingOptions = this.items ? this.items.filter((item) => isSelectableByValue(item) && valueArray.includes(item.value)) : [];
+          // Resolve by key first (the user's exact picks), then fall back to
+          // value matching for any values not resolved by key — so pre-selection
+          // and programmatic value sets keep working. Result is DOM-ordered.
+          const matchingOptions = resolveSelectedOptions(this.items, valueArray, this._selectedKey);
           newSelected = matchingOptions.length > 0 ? matchingOptions : undefined;
 
-          // Reconcile `value` with the selectable set. Drop only entries whose option is
-          // loaded but non-selectable (disabled/static) — leaving them would desync `value`
-          // from `optionSelected`, and the toggle handlers rebuild `value` from `formattedValue`,
-          // so the rejected entry would resurface on the next select/deselect. Entries with no
-          // matching item yet are preserved so async preselection still works once options render.
-          const rejectedValues = this.items
-            ? this.items.filter((item) => !isSelectableByValue(item) && valueArray.includes(item.value)).map((item) => item.value)
-            : [];
-          if (rejectedValues.length > 0) {
-            const reconciled = valueArray.filter((val) => !rejectedValues.includes(val));
+          // Reconcile `value` with the selectable set. An occurrence is dropped
+          // only when it is loaded but no selectable option can satisfy it —
+          // every loaded item sharing that value is non-selectable, or the value
+          // recurs more often than it has selectable options (a duplicate value
+          // whose extra siblings are disabled/static). This is count-based, not
+          // presence-based, so an enabled option is kept even when a disabled
+          // sibling shares its value — mirroring how `resolveSelectedOptions`
+          // resolves the same set. Entries with no matching item yet are
+          // preserved so async preselection still works, and the toggle handlers
+          // rebuild `value` from `formattedValue`, so a rejected entry cannot
+          // resurface on the next select/deselect.
+          const selectableByValue = new Map();
+          const loadedValues = new Set();
+          if (this.items) {
+            this.items.forEach((item) => {
+              loadedValues.add(item.value);
+              if (isSelectableByValue(item)) {
+                selectableByValue.set(item.value, (selectableByValue.get(item.value) || 0) + 1);
+              }
+            });
+          }
+
+          const reconciled = valueArray.filter((val) => {
+            // Not loaded yet (async preselection) — keep for a later cycle.
+            if (!loadedValues.has(val)) {
+              return true;
+            }
+            // Consume one selectable option per occurrence; drop once exhausted.
+            const remaining = selectableByValue.get(val) || 0;
+            if (remaining > 0) {
+              selectableByValue.set(val, remaining - 1);
+              return true;
+            }
+            return false;
+          });
+
+          if (reconciled.length !== valueArray.length) {
+            // This is an internal correction, not a consumer's programmatic set,
+            // so preserve the selection-driven flag through the re-entrant
+            // updated() cycle it schedules. Otherwise that cycle would treat the
+            // reassignment as programmatic and drop `_selectedKey` mid-cascade,
+            // flipping resolution and looping.
+            this._valueChangeFromSelection = true;
             this.value = serializeMultiSelectValue(reconciled);
             valueReconciled = true;
           }
@@ -717,7 +914,11 @@ class AuroMenu extends AuroElement {
           // `hidden` is intentionally NOT excluded: the combobox toggles
           // `hidden` as its type-ahead filter, so a filtered-out option is
           // still a valid programmatic selection.
-          const matchingOption = this.items ? this.items.find((item) => isSelectableByValue(item) && item.value === this.value) : undefined;
+          // Prefer the option the user actually selected (tracked by
+          // `_selectedKey`) so a click on the second of two options sharing a
+          // `value` resolves back to that exact element instead of the first
+          // value match. Falls back to first-by-value for programmatic sets.
+          const matchingOption = resolveSelectedOption(this.items, this.value, this._selectedKey);
 
           if (matchingOption) {
             newSelected = matchingOption;
@@ -945,6 +1146,14 @@ class AuroMenu extends AuroElement {
       }
     });
 
+    // Assign private keys once items are populated. Only the root menu assigns
+    // keys: its `items` is a deep query that already includes nested submenu
+    // options, so a single pass keys the entire tree. Nested menus skip this
+    // and inherit keys from the root.
+    if (this.rootMenu) {
+      this._assignOptionKeys();
+    }
+
     if (this.noCheckmark) {
       this.updateItemsState(new Map([
         [
@@ -961,6 +1170,31 @@ class AuroMenu extends AuroElement {
     }));
   }
 
+  /**
+   * Assigns a private, auto-generated unique key (`_optionKey`) to each menu
+   * option that does not already have one. Keys are internal state on the
+   * element instance — never reflected as an attribute or exposed publicly —
+   * and let selection tracking distinguish options that share the same `value`.
+   *
+   * The `_optionKey === undefined` guard makes this idempotent: options keep the
+   * key they were first assigned across re-renders and slot changes, and if a
+   * nested menu's lifecycle runs a pass before the root, options simply wait for
+   * the root to key them (or keep whatever key they already hold).
+   * @private
+   */
+  _assignOptionKeys() {
+    if (!this.items) {
+      return;
+    }
+
+    this.items.forEach((option) => {
+      if (option._optionKey === undefined) {
+        this._optionKeyCounter += 1;
+        option._optionKey = `${this._menuInstanceId}-${this._optionKeyCounter}`;
+      }
+    });
+  }
+
   // Logic Methods
 
   /**
@@ -970,24 +1204,28 @@ class AuroMenu extends AuroElement {
    */
   handleSelectState(option) {
     if (this.multiSelect) {
-      const currentValue = this.formattedValue || [];
       const currentSelected = this.optionSelected || [];
 
-      if (!currentValue.includes(option.value)) {
-        this.value = serializeMultiSelectValue([
-          ...currentValue,
-          option.value
-        ]);
-      }
       if (!currentSelected.includes(option)) {
         this.optionSelected = [
           ...currentSelected,
           option
         ];
       }
+
+      // Re-sort by DOM order and rebuild `_selectedKey`/`value` from the
+      // selected set so display order stays consistent with the menu, not with
+      // click order.
+      this._sortSelectedByDomOrder();
     } else {
       this.value = option.value;
       this.optionSelected = option;
+      // Track the specific option the user selected so the value→option
+      // reconciliation in updated() resolves back to this exact element even
+      // when another option shares the same `value`.
+      this._selectedKey = option._optionKey;
+      // Mark this `value` change as selection-driven so updated() trusts the key.
+      this._valueChangeFromSelection = true;
     }
 
     this._index = this.items.indexOf(option);
@@ -1000,18 +1238,22 @@ class AuroMenu extends AuroElement {
    */
   handleDeselectState(option) {
     if (this.multiSelect) {
-      // Remove this option from array; an empty result collapses `value` to undefined.
-      const newFormattedValue = (this.formattedValue || []).filter((val) => val !== option.value);
-      this.value = serializeMultiSelectValue(newFormattedValue);
-
-      this.optionSelected = this.optionSelected.filter((val) => val !== option);
+      // Remove this exact element from the selection (identity, not value — two
+      // options can share a `value`), then rebuild `value`/`_selectedKey` from
+      // the remaining set in DOM order. An empty result collapses to undefined.
+      this.optionSelected = this.optionSelected.filter((selected) => selected !== option);
       if (this.optionSelected.length === 0) {
         this.optionSelected = undefined;
+        this._selectedKey = undefined;
+        this.value = undefined;
+      } else {
+        this._sortSelectedByDomOrder();
       }
     } else {
       // For single-select: Back to undefined when deselected
       this.value = undefined;
       this.optionSelected = undefined;
+      this._selectedKey = undefined;
     }
 
     // Update the index tracking
@@ -1035,9 +1277,46 @@ class AuroMenu extends AuroElement {
   clearSelection() {
     this.optionSelected = undefined;
     this.value = undefined;
+    this._selectedKey = undefined;
     this._index = -1;
   }
 
+  /**
+   * Re-sorts the multi-select selection into DOM order and rebuilds the derived
+   * `_selectedKey` and `value` from `optionSelected`. Selection is always stored
+   * and serialized in the order options appear in the menu, never in click
+   * order — so selecting C then A yields `[A, C]`.
+   * @private
+   */
+  _sortSelectedByDomOrder() {
+    if (!this.multiSelect || !Array.isArray(this.optionSelected) || !this.items) {
+      return;
+    }
+
+    const indexMap = new Map(this.items.map((item, index) => [
+      item,
+      index
+    ]));
+
+    // Sorting in place mutates `optionSelected` without a new array reference,
+    // which Lit's `===` change-detection cannot see on its own — but that is
+    // intentional and safe: both callers (handleSelectState / handleDeselectState)
+    // assign a fresh `optionSelected` array immediately before calling, so Lit
+    // already has a changed reference to react to, and the `value` write below
+    // schedules the updated() cycle that re-derives `optionSelected` in DOM order
+    // via resolveSelectedOptions. Do not "fix" this into a new-array assignment.
+    //
+    // Sort any element no longer in `items` (a stale selection left over from a
+    // dynamic rebuild that the consumer has not cleared) to the END rather than
+    // the front, so it never displaces a live option to the head of the
+    // serialized order. Value reconciliation drops it on the next updated() cycle.
+    this.optionSelected.sort((optionA, optionB) => (indexMap.get(optionA) ?? this.items.length) - (indexMap.get(optionB) ?? this.items.length));
+    this._selectedKey = this.optionSelected.map((option) => option._optionKey);
+    this.value = serializeMultiSelectValue(this.optionSelected.map((option) => option.value));
+    // Mark this `value` change as selection-driven so updated() trusts the keys.
+    this._valueChangeFromSelection = true;
+  }
+
   /**
    * Resets the menu to its initial state.
    * This is the only way to return value to undefined.
@@ -1047,6 +1326,7 @@ class AuroMenu extends AuroElement {
     // Reset to undefined - initial state
     this.value = undefined;
     this.optionSelected = undefined;
+    this._selectedKey = undefined;
     this._index = -1;
 
     // Clear active option state so a follow-up open/navigation starts fresh
@@ -1108,6 +1388,21 @@ class AuroMenu extends AuroElement {
       this.initItems();
     }
 
+    // Recover `_index` from the highlighted option when it has been reset to -1.
+    // The updated() reconciliation resets `_index = -1` whenever the value
+    // collapses to undefined while `optionActive` still points at the highlighted
+    // option — e.g. deselecting the last remaining option in multi-select, or a
+    // programmatic clearSelection() in single-select while keyboard focus is on an
+    // option. Without this, reading `items[-1]` returns undefined and the re-select
+    // no-ops until the highlight is moved away and back. Mirrors auro-combobox's
+    // reconcileMenuIndex.
+    if (this._index < 0 && this.optionActive && this.items) {
+      const activeIndex = this.items.indexOf(this.optionActive);
+      if (activeIndex >= 0) {
+        this._index = activeIndex;
+      }
+    }
+
     // Get currently selected menu option based on index
     const option = this.items ? this.items[this._index] : undefined;