@aurodesignsystem-dev/auro-formkit 0.0.0-pr1574.0 → 0.0.0-pr1576.1

package/components/menu/dist/index.js

@@ -279,6 +279,107 @@ 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 = [];
+
+  // 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 && !resolved.includes(keyed)) {
+        resolved.push(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 && !resolved.includes(item));
+      if (option) {
+        resolved.push(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.
+  const indexMap = new Map(items.map((item, index) => [
+    item,
+    index
+  ]));
+  resolved.sort((optionA, optionB) => indexMap.get(optionA) - indexMap.get(optionB));
+
+  return resolved;
+}
+/* eslint-enable no-underscore-dangle */
+
 /**
  * Helper method to dispatch custom events.
  * @param {HTMLElement} element - Element to dispatch event from.
@@ -304,6 +405,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.
@@ -378,6 +487,8 @@ class AuroMenu extends AuroElement {
     /**
      * @private
      */
+    menuInstanceIdCounter += 1;
+
     Object.assign(this, {
       // Root-level menu (true) or a nested submenu (false)
       rootMenu: true,
@@ -387,6 +498,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 +732,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 +786,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 +820,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,7 +848,10 @@ 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
@@ -706,6 +864,12 @@ class AuroMenu extends AuroElement {
             : [];
           if (rejectedValues.length > 0) {
             const reconciled = valueArray.filter((val) => !rejectedValues.includes(val));
+            // 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 +881,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 +1113,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 +1137,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 +1171,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 +1205,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 +1244,38 @@ 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
+    ]));
+
+    // 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 +1285,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