@aurodesignsystem-dev/auro-formkit 0.0.0-pr1576.7 → 0.0.0-pr1577.0

package/components/menu/dist/index.js

@@ -279,107 +279,6 @@ 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.
@@ -405,14 +304,6 @@ 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.
@@ -484,8 +375,9 @@ class AuroMenu extends AuroElement {
 
     // Instance properties (non-reactive)
 
-    menuInstanceIdCounter += 1;
-
+    /**
+     * @private
+     */
     Object.assign(this, {
       // Root-level menu (true) or a nested submenu (false)
       rootMenu: true,
@@ -495,21 +387,6 @@ 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,
     });
   }
 
@@ -729,13 +606,6 @@ 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;
   }
@@ -783,17 +653,6 @@ 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
@@ -817,17 +676,6 @@ 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.
@@ -845,55 +693,19 @@ 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 || [];
-          // 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);
+          const matchingOptions = this.items ? this.items.filter((item) => isSelectableByValue(item) && valueArray.includes(item.value)) : [];
           newSelected = matchingOptions.length > 0 ? matchingOptions : undefined;
 
-          // 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;
+          // 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));
             this.value = serializeMultiSelectValue(reconciled);
             valueReconciled = true;
           }
@@ -905,11 +717,7 @@ 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.
-          // 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);
+          const matchingOption = this.items ? this.items.find((item) => isSelectableByValue(item) && item.value === this.value) : undefined;
 
           if (matchingOption) {
             newSelected = matchingOption;
@@ -1137,14 +945,6 @@ 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([
         [
@@ -1161,31 +961,6 @@ 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
 
   /**
@@ -1195,28 +970,24 @@ 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);
@@ -1229,22 +1000,18 @@ class AuroMenu extends AuroElement {
    */
   handleDeselectState(option) {
     if (this.multiSelect) {
-      // 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);
+      // 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);
       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
@@ -1268,38 +1035,9 @@ 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.
@@ -1309,7 +1047,6 @@ 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
@@ -1371,19 +1108,6 @@ class AuroMenu extends AuroElement {
       this.initItems();
     }
 
-    // Recover `_index` from the highlighted option when it has been reset to -1.
-    // In multi-select, deselecting the last remaining option collapses the value
-    // to undefined, and the updated() reconciliation resets `_index = -1` even
-    // though `optionActive` still points at the highlighted 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;