@mui/material 7.3.9 → 7.3.11

package/esm/styles/createThemeWithVars.js

@@ -329,21 +329,21 @@ export default function createThemeWithVars(options = {}, ...args) {
       setColor(palette.TableCell, 'border', colorMix(safeDarken, safeAlpha(nativeColor ? getCssVar('palette-divider') : palette.divider, 1), 0.68));
       setColor(palette.Tooltip, 'bg', colorMix(safeAlpha, nativeColor ? getCssVar('palette-grey-700') : palette.grey[700], 0.92));
     }
+    if (!nativeColor) {
+      setColorChannel(palette.background, 'default');
 
-    // MUI X - DataGrid needs this token.
-    setColorChannel(palette.background, 'default');
-
-    // added for consistency with the `background.default` token
-    setColorChannel(palette.background, 'paper');
-    setColorChannel(palette.common, 'background');
-    setColorChannel(palette.common, 'onBackground');
-    setColorChannel(palette, 'divider');
+      // added for consistency with the `background.default` token
+      setColorChannel(palette.background, 'paper');
+      setColorChannel(palette.common, 'background');
+      setColorChannel(palette.common, 'onBackground');
+      setColorChannel(palette, 'divider');
+    }
     Object.keys(palette).forEach(color => {
       const colors = palette[color];
 
       // The default palettes (primary, secondary, error, info, success, and warning) errors are handled by the above `createTheme(...)`.
 
-      if (color !== 'tonalOffset' && colors && typeof colors === 'object') {
+      if (color !== 'tonalOffset' && !nativeColor && colors && typeof colors === 'object') {
         // Silent the error for custom palettes.
         if (colors.main) {
           setColor(palette[color], 'mainChannel', safeColorChannel(toRgb(colors.main)));

package/esm/transitions/utils.d.ts

@@ -19,5 +19,12 @@ interface TransitionProps {
   easing: string | undefined;
   delay: string | undefined;
 }
+export declare function normalizedTransitionCallback(nodeRef: React.RefObject<HTMLElement | null>, callback: ((node: HTMLElement, isAppearing?: boolean) => void) | undefined): (maybeIsAppearing?: boolean) => void;
+type TransitionState = 'entering' | 'entered' | 'exiting' | 'exited';
+/**
+ * Computes the child style for a transition component, reusing existing
+ * references when possible to preserve referential equality for React.memo.
+ */
+export declare function getTransitionChildStyle(state: TransitionState, inProp: boolean | undefined, baseStyles: Record<string, React.CSSProperties>, hiddenStyles: React.CSSProperties, styleProp: React.CSSProperties | undefined, childStyle: React.CSSProperties | undefined): React.CSSProperties | undefined;
 export declare function getTransitionProps(props: ComponentProps, options: Options): TransitionProps;
 export {};

package/esm/transitions/utils.js

@@ -1,4 +1,29 @@
 export const reflow = node => node.scrollTop;
+export function normalizedTransitionCallback(nodeRef, callback) {
+  return maybeIsAppearing => {
+    if (callback) {
+      const node = nodeRef.current;
+      // onEnterXxx and onExitXxx callbacks have a different arguments.length value.
+      if (maybeIsAppearing === undefined) {
+        callback(node);
+      } else {
+        callback(node, maybeIsAppearing);
+      }
+    }
+  };
+}
+/**
+ * Computes the child style for a transition component, reusing existing
+ * references when possible to preserve referential equality for React.memo.
+ */
+export function getTransitionChildStyle(state, inProp, baseStyles, hiddenStyles, styleProp, childStyle) {
+  const base = state === 'exited' && !inProp ? hiddenStyles : baseStyles[state] || baseStyles.exited;
+  return styleProp || childStyle ? {
+    ...base,
+    ...styleProp,
+    ...childStyle
+  } : base;
+}
 export function getTransitionProps(props, options) {
   const {
     timeout,

package/esm/useAutocomplete/useAutocomplete.d.ts

@@ -46,12 +46,11 @@ export interface UseAutocompleteProps<Value, Multiple extends boolean | undefine
    */
   autoHighlight?: boolean | undefined;
   /**
-   * If `true`, the selected option becomes the value of the input
-   * when the Autocomplete loses focus unless the user chooses
-   * a different option or changes the character string in the input.
+   * If `true`, the value is updated when the input loses focus under one of these conditions:
    *
-   * When using the `freeSolo` mode, the typed value will be the input value
-   * if the Autocomplete loses focus without highlighting an option.
+   * - An option highlighted via keyboard navigation or `autoHighlight` is selected.
+   *   Hover and touch highlights are ignored.
+   * - Otherwise, in `freeSolo` mode, the typed text becomes the value.
    * @default false
    */
   autoSelect?: boolean | undefined;

package/esm/useAutocomplete/useAutocomplete.js

@@ -1,6 +1,7 @@
 'use client';
 
 import * as React from 'react';
+import contains from '@mui/utils/contains';
 import setRef from '@mui/utils/setRef';
 import useEventCallback from '@mui/utils/useEventCallback';
 import useControlled from '@mui/utils/useControlled';
@@ -55,7 +56,8 @@ const defaultFilterOptions = createFilterOptions();
 
 // Number of options to jump in list box when `Page Up` and `Page Down` keys are used.
 const pageSize = 5;
-const defaultIsActiveElementInListbox = listboxRef => listboxRef.current !== null && listboxRef.current.parentElement?.contains(document.activeElement);
+const defaultIsActiveElementInListbox = listboxRef => listboxRef.current !== null && contains(listboxRef.current.parentElement, document.activeElement);
+const defaultIsOptionEqualToValue = (option, value) => option === value;
 const MULTIPLE_DEFAULT_VALUE = [];
 function getInputValue(value, multiple, getOptionLabel, renderValue) {
   if (multiple || value == null || renderValue) {
@@ -94,7 +96,7 @@ function useAutocomplete(props) {
     id: idProp,
     includeInputInList = false,
     inputValue: inputValueProp,
-    isOptionEqualToValue = (option, value) => option === value,
+    isOptionEqualToValue = defaultIsOptionEqualToValue,
     multiple = false,
     onChange,
     onClose,
@@ -126,11 +128,26 @@ function useAutocomplete(props) {
   const firstFocus = React.useRef(true);
   const inputRef = React.useRef(null);
   const listboxRef = React.useRef(null);
+  const windowLostFocus = React.useRef(false);
   const [anchorEl, setAnchorEl] = React.useState(null);
   const [focusedItem, setFocusedItem] = React.useState(-1);
   const defaultHighlighted = autoHighlight ? 0 : -1;
   const highlightedIndexRef = React.useRef(defaultHighlighted);
 
+  // Tracks how the current highlight was set:
+  // - 'keyboard' — arrow keys, Home/End, PageUp/PageDown
+  // - 'mouse'    — handleOptionMouseMove
+  // - 'touch'    — handleOptionTouchStart
+  // - null       — programmatic (autoHighlight, value sync)
+  //
+  // This lets handleBlur and the Enter handler distinguish intentional
+  // interactions from incidental ones — e.g. autoSelect should not commit
+  // a highlight that came from a casual mouse hover.
+  /** @type {React.RefObject<AutocompleteHighlightChangeReason | null>} */
+  const highlightReasonRef = React.useRef(null);
+  const touchScrolledRef = React.useRef(false);
+  const isTouchRef = React.useRef(false);
+
   // Calculate the initial inputValue on mount only.
   // useRef ensures it doesn't update dynamically with defaultValue or value props.
   const initialInputValue = React.useRef(getInputValue(defaultValue ?? valueProp, multiple, getOptionLabel)).current;
@@ -171,8 +188,30 @@ function useAutocomplete(props) {
   const [inputPristine, setInputPristine] = React.useState(true);
   const inputValueIsSelectedValue = !multiple && value != null && inputValue === getOptionLabel(value);
   const popupOpen = open && !readOnly;
+  const selectedValues = React.useMemo(() => {
+    if (multiple) {
+      return value;
+    }
+    if (value != null) {
+      return [value];
+    }
+    return [];
+  }, [multiple, value]);
+  const selectedValuesSet = React.useMemo(() => {
+    // Fast path for the default strict equality comparator to avoid O(n^2) option checks.
+    if (isOptionEqualToValue !== defaultIsOptionEqualToValue || selectedValues.length === 0) {
+      return null;
+    }
+    return new Set(selectedValues);
+  }, [isOptionEqualToValue, selectedValues]);
+  const isOptionSelected = React.useCallback(option => {
+    if (selectedValuesSet) {
+      return selectedValuesSet.has(option);
+    }
+    return selectedValues.some(value2 => value2 != null && isOptionEqualToValue(option, value2));
+  }, [isOptionEqualToValue, selectedValues, selectedValuesSet]);
   const filteredOptions = popupOpen ? filterOptions(options.filter(option => {
-    if (filterSelectedOptions && (multiple ? value : [value]).some(value2 => value2 !== null && isOptionEqualToValue(option, value2))) {
+    if (filterSelectedOptions && isOptionSelected(option)) {
       return false;
     }
     return true;
@@ -248,22 +287,17 @@ function useAutocomplete(props) {
       }
     }
   }
-  const setHighlightedIndex = useEventCallback(({
-    event,
+  const syncHighlightedIndexToDOM = useEventCallback(({
     index,
-    reason
+    reason,
+    preserveScroll = false
   }) => {
-    highlightedIndexRef.current = index;
-
     // does the index exist?
     if (index === -1) {
       inputRef.current.removeAttribute('aria-activedescendant');
     } else {
       inputRef.current.setAttribute('aria-activedescendant', `${id}-option-${index}`);
     }
-    if (onHighlightChange && ['mouse', 'keyboard', 'touch'].includes(reason)) {
-      onHighlightChange(event, index === -1 ? null : filteredOptions[index], reason);
-    }
     if (!listboxRef.current) {
       return;
     }
@@ -282,7 +316,9 @@ function useAutocomplete(props) {
       return;
     }
     if (index === -1) {
-      listboxNode.scrollTop = 0;
+      if (!preserveScroll) {
+        listboxNode.scrollTop = 0;
+      }
       return;
     }
     const option = listboxRef.current.querySelector(`[data-option-index="${index}"]`);
@@ -310,15 +346,46 @@ function useAutocomplete(props) {
       }
     }
   });
+  const setHighlightedIndex = useEventCallback(({
+    event,
+    index,
+    reason,
+    preserveScroll = false
+  }) => {
+    highlightedIndexRef.current = index;
+    highlightReasonRef.current = reason ?? null;
+    if (onHighlightChange && ['mouse', 'keyboard', 'touch'].includes(reason)) {
+      onHighlightChange(event, index === -1 ? null : filteredOptions[index], reason);
+    }
+    syncHighlightedIndexToDOM({
+      index,
+      reason,
+      preserveScroll
+    });
+  });
+  const setHighlightedIndexFromSync = useEventCallback(({
+    index
+  }) => {
+    highlightedIndexRef.current = index;
+    syncHighlightedIndexToDOM({
+      index,
+      reason: highlightReasonRef.current
+    });
+  });
   const changeHighlightedIndex = useEventCallback(({
     event,
     diff,
     direction = 'next',
-    reason
+    reason,
+    preserveScroll
   }) => {
     if (!popupOpen) {
       return;
     }
+    if (reason === 'keyboard') {
+      touchScrolledRef.current = false;
+      isTouchRef.current = false;
+    }
     const getNextIndex = () => {
       const maxIndex = filteredOptions.length - 1;
       if (diff === 'reset') {
@@ -355,7 +422,8 @@ function useAutocomplete(props) {
     setHighlightedIndex({
       index: nextIndex,
       reason,
-      event
+      event,
+      preserveScroll
     });
 
     // Sync the content of the input with the highlighted option.
@@ -409,15 +477,24 @@ function useAutocomplete(props) {
     // If it exists and the value and the inputValue haven't changed, just update its index, otherwise continue execution
     const previousHighlightedOptionIndex = getPreviousHighlightedOptionIndex();
     if (previousHighlightedOptionIndex !== -1) {
-      highlightedIndexRef.current = previousHighlightedOptionIndex;
+      // Keep the original highlight reason while re-syncing the DOM state.
+      // The highlighted option still exists after the filteredOptions array changed
+      // (e.g. async fetch returns new options while the user is mid-navigation),
+      // so the original interaction reason (keyboard, mouse, etc.) still applies.
+      setHighlightedIndexFromSync({
+        index: previousHighlightedOptionIndex
+      });
       return;
     }
     const valueItem = multiple ? value[0] : value;
 
     // The popup is empty, reset
     if (filteredOptions.length === 0 || valueItem == null) {
+      // Preserve scroll when new options are appended without changing the current filter.
+      const isAppendOnly = filteredOptionsChanged && previousProps.inputValue === inputValue && previousProps.filteredOptions?.length > 0 && filteredOptions.length > previousProps.filteredOptions.length && previousProps.filteredOptions.every((option, index) => getOptionLabel(option) === getOptionLabel(filteredOptions[index]));
       changeHighlightedIndex({
-        diff: 'reset'
+        diff: 'reset',
+        preserveScroll: isAppendOnly
       });
       return;
     }
@@ -429,8 +506,12 @@ function useAutocomplete(props) {
     if (valueItem != null) {
       const currentOption = filteredOptions[highlightedIndexRef.current];
 
-      // Keep the current highlighted index if possible
-      if (multiple && currentOption && value.findIndex(val => isOptionEqualToValue(currentOption, val)) !== -1) {
+      // Keep the current selected highlight while the popup stays open;
+      // on reopen, resync from the selected value.
+      if (multiple && currentOption && value.findIndex(val => isOptionEqualToValue(currentOption, val)) !== -1 && previousProps.filteredOptions?.length > 0) {
+        setHighlightedIndexFromSync({
+          index: highlightedIndexRef.current
+        });
         return;
       }
       const itemIndex = filteredOptions.findIndex(optionItem => isOptionEqualToValue(optionItem, valueItem));
@@ -465,7 +546,7 @@ function useAutocomplete(props) {
   filteredOptions.length,
   // Don't sync the highlighted index with the value when multiple
   // eslint-disable-next-line react-hooks/exhaustive-deps
-  multiple ? false : value, changeHighlightedIndex, setHighlightedIndex, popupOpen, inputValue, multiple]);
+  multiple ? false : value, changeHighlightedIndex, setHighlightedIndex, setHighlightedIndexFromSync, popupOpen, inputValue, multiple]);
   const handleListboxRef = useEventCallback(node => {
     setRef(listboxRef, node);
     if (!node) {
@@ -490,12 +571,28 @@ function useAutocomplete(props) {
       syncHighlightedIndex();
     }
   }, [syncHighlightedIndex, filteredOptionsChanged, popupOpen, disableCloseOnSelect]);
+
+  // Listen for browser window blur to detect when the user switches tabs or windows.
+  // This helps prevent the popup from reopening automatically when the window regains focus.
+  React.useEffect(() => {
+    if (typeof window === 'undefined') {
+      return undefined;
+    }
+    const handleWindowBlur = () => {
+      windowLostFocus.current = true;
+    };
+    window.addEventListener('blur', handleWindowBlur);
+    return () => {
+      window.removeEventListener('blur', handleWindowBlur);
+    };
+  }, []);
   const handleOpen = event => {
     if (open) {
       return;
     }
     setOpenState(true);
     setInputPristine(true);
+    isTouchRef.current = false;
     if (onOpen) {
       onOpen(event);
     }
@@ -505,6 +602,8 @@ function useAutocomplete(props) {
       return;
     }
     setOpenState(false);
+    touchScrolledRef.current = false;
+    highlightReasonRef.current = null;
     if (onClose) {
       onClose(event, reason);
     }
@@ -522,7 +621,6 @@ function useAutocomplete(props) {
     }
     setValueState(newValue);
   };
-  const isTouch = React.useRef(false);
   const selectNewValue = (event, option, reasonProp = 'selectOption', origin = 'options') => {
     let reason = reasonProp;
     let newValue = option;
@@ -549,7 +647,7 @@ function useAutocomplete(props) {
     if (!disableCloseOnSelect && (!event || !event.ctrlKey && !event.metaKey)) {
       handleClose(event, reason);
     }
-    if (blurOnSelect === true || blurOnSelect === 'touch' && isTouch.current || blurOnSelect === 'mouse' && !isTouch.current) {
+    if (blurOnSelect === true || blurOnSelect === 'touch' && isTouchRef.current || blurOnSelect === 'mouse' && !isTouchRef.current) {
       inputRef.current.blur();
     }
   };
@@ -738,29 +836,47 @@ function useAutocomplete(props) {
           }
           break;
         case 'Enter':
-          if (highlightedIndexRef.current !== -1 && popupOpen) {
-            const option = filteredOptions[highlightedIndexRef.current];
-            const disabled = getOptionDisabled ? getOptionDisabled(option) : false;
+          {
+            // In freeSolo, only select the highlighted option if the user hasn't
+            // typed new text (inputPristine) or explicitly interacted with an option
+            // (keyboard, mouse, or touch — any non-null reason). This lets typed
+            // text win over a programmatic highlight (reason=null, e.g. from
+            // syncHighlightedIndex matching a previous value) while still honoring
+            // deliberate user interactions like hovering a suggestion then pressing Enter.
+            const shouldSelectHighlighted = !freeSolo || inputPristine || highlightReasonRef.current !== null;
+            if (highlightedIndexRef.current !== -1 && popupOpen && shouldSelectHighlighted &&
+            // After a touch-scroll the highlight is stale (the user scrolled
+            // past it), so skip selection until the next deliberate interaction.
+            !touchScrolledRef.current) {
+              const option = filteredOptions[highlightedIndexRef.current];
+              const disabled = getOptionDisabled ? getOptionDisabled(option) : false;
 
-            // Avoid early form validation, let the end-users continue filling the form.
-            event.preventDefault();
-            if (disabled) {
-              return;
-            }
-            selectNewValue(event, option, 'selectOption');
+              // Avoid early form validation, let the end-users continue filling the form.
+              event.preventDefault();
+              if (disabled) {
+                return;
+              }
+              selectNewValue(event, option, 'selectOption');
 
-            // Move the selection to the end.
-            if (autoComplete) {
-              inputRef.current.setSelectionRange(inputRef.current.value.length, inputRef.current.value.length);
-            }
-          } else if (freeSolo && inputValue !== '' && inputValueIsSelectedValue === false) {
-            if (multiple) {
-              // Allow people to add new values before they submit the form.
+              // Move the selection to the end.
+              if (autoComplete) {
+                inputRef.current.setSelectionRange(inputRef.current.value.length, inputRef.current.value.length);
+              }
+            } else if (freeSolo && inputValue !== '' && inputValueIsSelectedValue === false) {
+              if (multiple) {
+                // Allow people to add new values before they submit the form.
+                event.preventDefault();
+              }
+              selectNewValue(event, inputValue, 'createOption', 'freeSolo');
+            } else if (popupOpen && touchScrolledRef.current) {
+              // The highlight is stale from a touch-scroll - close without selecting.
               event.preventDefault();
+              // This happens on Enter, but re-using "escape" as the closest `AutocompleteCloseReason`
+              // to avoid creating a new reason
+              handleClose(event, 'escape');
             }
-            selectNewValue(event, inputValue, 'createOption', 'freeSolo');
+            break;
           }
-          break;
         case 'Escape':
           if (popupOpen) {
             // Avoid Opera to exit fullscreen mode.
@@ -825,6 +941,14 @@ function useAutocomplete(props) {
       // Ensure DOM focus lands on the input
       focusItem(-1);
     }
+
+    // If the window previously lost focus while the popup was open,
+    // ignore this focus event to prevent unintended reopening.
+    // Reset the flag so normal focus behavior resumes.
+    if (windowLostFocus.current) {
+      windowLostFocus.current = false;
+      return;
+    }
     if (openOnFocus && !ignoreFocus.current) {
       handleOpen(event);
     }
@@ -838,7 +962,12 @@ function useAutocomplete(props) {
     setFocused(false);
     firstFocus.current = true;
     ignoreFocus.current = false;
-    if (autoSelect && highlightedIndexRef.current !== -1 && popupOpen) {
+
+    // Auto-select the highlighted option on blur, but only if the highlight
+    // came from keyboard navigation or was set programmatically (autoHighlight).
+    // Mouse hover and touch should not trigger selection — the user may have
+    // moved the pointer over an option without intending to commit to it.
+    if (autoSelect && highlightedIndexRef.current !== -1 && popupOpen && highlightReasonRef.current !== 'mouse' && highlightReasonRef.current !== 'touch') {
       selectNewValue(event, filteredOptions[highlightedIndexRef.current], 'blur');
     } else if (autoSelect && freeSolo && inputValue !== '') {
       selectNewValue(event, inputValue, 'blur', 'freeSolo');
@@ -849,9 +978,10 @@ function useAutocomplete(props) {
   };
   const handleInputChange = event => {
     const newValue = event.target.value;
-    if (inputValue !== newValue) {
+    const valueChanged = inputValue !== newValue;
+    if (valueChanged) {
       setInputValueState(newValue);
-      setInputPristine(false);
+      touchScrolledRef.current = false;
       if (onInputChange) {
         onInputChange(event, newValue, 'input');
       }
@@ -865,6 +995,12 @@ function useAutocomplete(props) {
     } else {
       handleOpen(event);
     }
+
+    // Called after handleOpen so it overrides handleOpen's setInputPristine(true)
+    // when the first keystroke also opens the popup.
+    if (valueChanged) {
+      setInputPristine(false);
+    }
   };
   const handleOptionMouseMove = event => {
     const index = Number(event.currentTarget.getAttribute('data-option-index'));
@@ -874,20 +1010,35 @@ function useAutocomplete(props) {
         index,
         reason: 'mouse'
       });
+    } else {
+      // The option is already highlighted (e.g. programmatically via autoHighlight),
+      // but the user moved the mouse over it — mark as mouse-initiated so
+      // autoSelect on blur correctly treats this as incidental hover.
+      highlightReasonRef.current = 'mouse';
+    }
+    // Don't clear the touch-scroll guard while touch state is still latched.
+    // After a touch gesture, browsers may fire compatibility mousemove
+    // events; if those cleared the guard immediately, later compat events in
+    // the same sequence could be misclassified as a real mouse interaction.
+    // Touch state is cleared by the next deliberate interaction
+    // (keyboard nav, handleOptionClick, or handleOpen).
+    if (!isTouchRef.current) {
+      touchScrolledRef.current = false;
     }
   };
   const handleOptionTouchStart = event => {
+    touchScrolledRef.current = false;
     setHighlightedIndex({
       event,
       index: Number(event.currentTarget.getAttribute('data-option-index')),
       reason: 'touch'
     });
-    isTouch.current = true;
+    isTouchRef.current = true;
   };
   const handleOptionClick = event => {
     const index = Number(event.currentTarget.getAttribute('data-option-index'));
     selectNewValue(event, filteredOptions[index], 'selectOption');
-    isTouch.current = false;
+    isTouchRef.current = false;
   };
   const handleItemDelete = index => event => {
     const newValue = value.slice();
@@ -912,7 +1063,11 @@ function useAutocomplete(props) {
   // Prevent input blur when interacting with the combobox
   const handleMouseDown = event => {
     // Prevent focusing the input if click is anywhere outside the Autocomplete
-    if (!event.currentTarget.contains(event.target)) {
+    if (!contains(event.currentTarget, event.target)) {
+      return;
+    }
+    // Don't interfere with interactions outside the input area (e.g. helper text)
+    if (anchorEl && !contains(anchorEl, event.target)) {
       return;
     }
     if (event.target.getAttribute('id') !== id) {
@@ -923,7 +1078,11 @@ function useAutocomplete(props) {
   // Focus the input when interacting with the combobox
   const handleClick = event => {
     // Prevent focusing the input if click is anywhere outside the Autocomplete
-    if (!event.currentTarget.contains(event.target)) {
+    if (!contains(event.currentTarget, event.target)) {
+      return;
+    }
+    // Don't interfere with interactions outside the input area (e.g. helper text)
+    if (anchorEl && !contains(anchorEl, event.target)) {
       return;
     }
     inputRef.current.focus();
@@ -1048,13 +1207,18 @@ function useAutocomplete(props) {
       onMouseDown: event => {
         // Prevent blur
         event.preventDefault();
+      },
+      onScroll: () => {
+        if (isTouchRef.current) {
+          touchScrolledRef.current = true;
+        }
       }
     }),
     getOptionProps: ({
       index,
       option
     }) => {
-      const selected = (multiple ? value : [value]).some(value2 => value2 != null && isOptionEqualToValue(option, value2));
+      const selected = isOptionSelected(option);
       const disabled = getOptionDisabled ? getOptionDisabled(option) : false;
       return {
         key: getOptionKey?.(option) ?? getOptionLabel(option),

package/esm/utils/contains.d.ts

@@ -0,0 +1,2 @@
+import contains from '@mui/utils/contains';
+export default contains;

package/esm/utils/contains.js

@@ -0,0 +1,2 @@
+import contains from '@mui/utils/contains';
+export default contains;

package/esm/utils/focusable.d.ts

@@ -0,0 +1,7 @@
+export declare const FOCUSABLE_ATTRIBUTE = "data-mui-focusable";
+/**
+ * Returns the element marked as the initial focus target inside a focus trap.
+ * The root element takes precedence over marked descendants so components can
+ * opt into focusing their own root surface directly.
+ */
+export declare function getFocusTarget(rootElement: HTMLElement | null | undefined): HTMLElement | null;

package/esm/utils/focusable.js

@@ -0,0 +1,13 @@
+export const FOCUSABLE_ATTRIBUTE = 'data-mui-focusable';
+
+/**
+ * Returns the element marked as the initial focus target inside a focus trap.
+ * The root element takes precedence over marked descendants so components can
+ * opt into focusing their own root surface directly.
+ */
+export function getFocusTarget(rootElement) {
+  if (!rootElement) {
+    return null;
+  }
+  return rootElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? rootElement : rootElement.querySelector(`[${FOCUSABLE_ATTRIBUTE}]`);
+}

package/esm/utils/getEventTarget.d.ts

@@ -0,0 +1,2 @@
+import getEventTarget from '@mui/utils/getEventTarget';
+export default getEventTarget;

package/esm/utils/getEventTarget.js

@@ -0,0 +1,2 @@
+import getEventTarget from '@mui/utils/getEventTarget';
+export default getEventTarget;

package/esm/version/index.js

@@ -1,6 +1,6 @@
-export const version = "7.3.9";
+export const version = "7.3.11";
 export const major = Number("7");
 export const minor = Number("3");
-export const patch = Number("9");
+export const patch = Number("11");
 export const prerelease = undefined;
 export default version;

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/material v7.3.9
+ * @mui/material v7.3.11
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/material",
-  "version": "7.3.9",
+  "version": "7.3.11",
   "author": "MUI Team",
   "description": "Material UI is an open-source React component library that implements Google's Material Design. It's comprehensive and can be used in production out of the box.",
   "keywords": [
@@ -33,10 +33,10 @@
     "prop-types": "^15.8.1",
     "react-is": "^19.2.3",
     "react-transition-group": "^4.4.5",
-    "@mui/core-downloads-tracker": "^7.3.9",
-    "@mui/system": "^7.3.9",
+    "@mui/core-downloads-tracker": "^7.3.11",
+    "@mui/utils": "^7.3.11",
     "@mui/types": "^7.4.12",
-    "@mui/utils": "^7.3.9"
+    "@mui/system": "^7.3.11"
   },
   "peerDependencies": {
     "@emotion/react": "^11.5.0",
@@ -44,7 +44,7 @@
     "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
     "react": "^17.0.0 || ^18.0.0 || ^19.0.0",
     "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0",
-    "@mui/material-pigment-css": "^7.3.9"
+    "@mui/material-pigment-css": "^7.3.11"
   },
   "peerDependenciesMeta": {
     "@types/react": {