@mui/material 6.0.0-alpha.12 → 6.0.0-alpha.14

package/modern/PigmentHidden/PigmentHidden.js

@@ -0,0 +1,278 @@
+'use client';
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+// @ts-ignore
+import Hidden from '@pigment-css/react/Hidden';
+import capitalize from '@mui/utils/capitalize';
+import composeClasses from '@mui/utils/composeClasses';
+import HiddenJs from '../Hidden/HiddenJs';
+import { getHiddenCssUtilityClass } from '../Hidden/hiddenCssClasses';
+import { useTheme } from '../zero-styled';
+import { jsx as _jsx } from "react/jsx-runtime";
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    breakpoints
+  } = ownerState;
+  const slots = {
+    root: ['root', ...breakpoints.map(({
+      breakpoint,
+      dir
+    }) => {
+      return dir === 'only' ? `${dir}${capitalize(breakpoint)}` : `${breakpoint}${capitalize(dir)}`;
+    })]
+  };
+  return composeClasses(slots, getHiddenCssUtilityClass, classes);
+};
+function HiddenCss(props) {
+  const theme = useTheme();
+  const {
+    children,
+    className,
+    only,
+    ...other
+  } = props;
+  if (process.env.NODE_ENV !== 'production') {
+    const unknownProps = Object.keys(other).filter(propName => {
+      const isUndeclaredBreakpoint = !theme.breakpoints.keys.some(breakpoint => {
+        return `${breakpoint}Up` === propName || `${breakpoint}Down` === propName;
+      });
+      return !['classes', 'theme', 'isRtl', 'sx'].includes(propName) && isUndeclaredBreakpoint;
+    });
+    if (unknownProps.length > 0) {
+      console.error(`MUI: Unsupported props received by \`<Hidden implementation="css" />\`: ${unknownProps.join(', ')}. Did you forget to wrap this component in a ThemeProvider declaring these breakpoints?`);
+    }
+  }
+  const breakpoints = [];
+  for (let i = 0; i < theme.breakpoints.keys.length; i += 1) {
+    const breakpoint = theme.breakpoints.keys[i];
+    const breakpointUp = other[`${breakpoint}Up`];
+    const breakpointDown = other[`${breakpoint}Down`];
+    if (breakpointUp) {
+      breakpoints.push({
+        breakpoint,
+        dir: 'up'
+      });
+    }
+    if (breakpointDown) {
+      breakpoints.push({
+        breakpoint,
+        dir: 'down'
+      });
+    }
+  }
+  if (only) {
+    const onlyBreakpoints = Array.isArray(only) ? only : [only];
+    onlyBreakpoints.forEach(breakpoint => {
+      breakpoints.push({
+        breakpoint,
+        dir: 'only'
+      });
+    });
+  }
+  const ownerState = {
+    ...props,
+    classes: {},
+    breakpoints
+  };
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(Hidden, {
+    className: clsx(classes.root, className),
+    ...props
+  });
+}
+process.env.NODE_ENV !== "production" ? HiddenCss.propTypes /* remove-proptypes */ = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: PropTypes.node,
+  className: PropTypes.string,
+  /**
+   * Specify which implementation to use.  'js' is the default, 'css' works better for
+   * server-side rendering.
+   * @default 'js'
+   */
+  implementation: PropTypes.oneOf(['css', 'js']),
+  /**
+   * You can use this prop when choosing the `js` implementation with server-side rendering.
+   *
+   * As `window.innerWidth` is unavailable on the server,
+   * we default to rendering an empty component during the first mount.
+   * You might want to use a heuristic to approximate
+   * the screen width of the client browser screen width.
+   *
+   * For instance, you could be using the user-agent or the client-hints.
+   * https://caniuse.com/#search=client%20hint
+   */
+  initialWidth: PropTypes.oneOf(['lg', 'md', 'sm', 'xl', 'xs']),
+  /**
+   * If `true`, component is hidden on screens below (but not including) this size.
+   * @default false
+   */
+  lgDown: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens this size and above.
+   * @default false
+   */
+  lgUp: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens below (but not including) this size.
+   * @default false
+   */
+  mdDown: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens this size and above.
+   * @default false
+   */
+  mdUp: PropTypes.bool,
+  /**
+   * Hide the given breakpoint(s).
+   */
+  only: PropTypes.oneOfType([PropTypes.oneOf(['lg', 'md', 'sm', 'xl', 'xs']), PropTypes.arrayOf(PropTypes.oneOf(['lg', 'md', 'sm', 'xl', 'xs']).isRequired)]),
+  /**
+   * If `true`, component is hidden on screens below (but not including) this size.
+   * @default false
+   */
+  smDown: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens this size and above.
+   * @default false
+   */
+  smUp: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens below (but not including) this size.
+   * @default false
+   */
+  xlDown: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens this size and above.
+   * @default false
+   */
+  xlUp: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens below (but not including) this size.
+   * @default false
+   */
+  xsDown: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens this size and above.
+   * @default false
+   */
+  xsUp: PropTypes.bool
+} : void 0;
+/**
+ *
+ * Demos:
+ *
+ * - [Hidden](https://next.mui.com/material-ui/react-hidden/)
+ *
+ * API:
+ *
+ * - [PigmentHidden API](https://next.mui.com/material-ui/api/pigment-hidden/)
+ */
+function PigmentHidden({
+  implementation = 'js',
+  ...props
+}) {
+  if (implementation === 'js') {
+    return /*#__PURE__*/_jsx(HiddenJs, {
+      ...props
+    });
+  }
+  return /*#__PURE__*/_jsx(HiddenCss, {
+    ...props
+  });
+}
+process.env.NODE_ENV !== "production" ? PigmentHidden.propTypes /* remove-proptypes */ = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: PropTypes.node,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * Specify which implementation to use.  'js' is the default, 'css' works better for
+   * server-side rendering.
+   * @default 'js'
+   */
+  implementation: PropTypes.oneOf(['css', 'js']),
+  /**
+   * You can use this prop when choosing the `js` implementation with server-side rendering.
+   *
+   * As `window.innerWidth` is unavailable on the server,
+   * we default to rendering an empty component during the first mount.
+   * You might want to use a heuristic to approximate
+   * the screen width of the client browser screen width.
+   *
+   * For instance, you could be using the user-agent or the client-hints.
+   * https://caniuse.com/#search=client%20hint
+   */
+  initialWidth: PropTypes.oneOf(['lg', 'md', 'sm', 'xl', 'xs']),
+  /**
+   * If `true`, component is hidden on screens below (but not including) this size.
+   * @default false
+   */
+  lgDown: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens this size and above.
+   * @default false
+   */
+  lgUp: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens below (but not including) this size.
+   * @default false
+   */
+  mdDown: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens this size and above.
+   * @default false
+   */
+  mdUp: PropTypes.bool,
+  /**
+   * Hide the given breakpoint(s).
+   */
+  only: PropTypes.oneOfType([PropTypes.oneOf(['lg', 'md', 'sm', 'xl', 'xs']), PropTypes.arrayOf(PropTypes.oneOf(['lg', 'md', 'sm', 'xl', 'xs']).isRequired)]),
+  /**
+   * If `true`, component is hidden on screens below (but not including) this size.
+   * @default false
+   */
+  smDown: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens this size and above.
+   * @default false
+   */
+  smUp: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens below (but not including) this size.
+   * @default false
+   */
+  xlDown: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens this size and above.
+   * @default false
+   */
+  xlUp: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens below (but not including) this size.
+   * @default false
+   */
+  xsDown: PropTypes.bool,
+  /**
+   * If `true`, component is hidden on screens this size and above.
+   * @default false
+   */
+  xsUp: PropTypes.bool
+} : void 0;
+export default PigmentHidden;

package/modern/PigmentHidden/index.js

@@ -0,0 +1,2 @@
+export { default } from './PigmentHidden';
+export * from './PigmentHidden';

package/modern/PigmentStack/PigmentStack.js

@@ -0,0 +1,81 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+// @ts-ignore
+import Stack from '@pigment-css/react/Stack';
+import composeClasses from '@mui/utils/composeClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+import { jsx as _jsx } from "react/jsx-runtime";
+const useUtilityClasses = () => {
+  const slots = {
+    root: ['root']
+  };
+  return composeClasses(slots, slot => generateUtilityClass('MuiStack', slot), {});
+};
+/**
+ *
+ * Demos:
+ *
+ * - [Stack](https://next.mui.com/material-ui/react-stack/)
+ *
+ * API:
+ *
+ * - [PigmentStack API](https://next.mui.com/material-ui/api/pigment-stack/)
+ */
+const PigmentStack = /*#__PURE__*/React.forwardRef(function PigmentStack({
+  className,
+  ...props
+}, ref) {
+  const classes = useUtilityClasses();
+  return /*#__PURE__*/_jsx(Stack, {
+    ref: ref,
+    className: clsx(classes.root, className),
+    ...props
+  });
+});
+process.env.NODE_ENV !== "production" ? PigmentStack.propTypes /* remove-proptypes */ = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: PropTypes.node,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * Defines the `flex-direction` style property.
+   * It is applied for all screen sizes.
+   * @default 'column'
+   */
+  direction: PropTypes.oneOfType([PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']), PropTypes.arrayOf(PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])), PropTypes.shape({
+    lg: PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']),
+    md: PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']),
+    sm: PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']),
+    xl: PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']),
+    xs: PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])
+  })]),
+  /**
+   * Add an element between each child.
+   */
+  divider: PropTypes.node,
+  /**
+   * Defines the space between immediate children.
+   * @default 0
+   */
+  spacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.shape({
+    lg: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+    md: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+    sm: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+    xl: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+    xs: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
+  }), PropTypes.string]),
+  /**
+   * The system prop, which allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
+} : void 0;
+export default PigmentStack;

package/modern/PigmentStack/index.js

@@ -0,0 +1,3 @@
+export { default } from './PigmentStack';
+export * from './PigmentStack';
+export { default as stackClasses } from '../Stack/stackClasses';

package/modern/Rating/Rating.js

@@ -8,7 +8,8 @@ import visuallyHidden from '@mui/utils/visuallyHidden';
 import chainPropTypes from '@mui/utils/chainPropTypes';
 import composeClasses from '@mui/utils/composeClasses';
 import { useRtl } from '@mui/system/RtlProvider';
-import { capitalize, useForkRef, useIsFocusVisible, useControlled, unstable_useId as useId } from '../utils';
+import isFocusVisible from '@mui/utils/isFocusVisible';
+import { capitalize, useForkRef, useControlled, unstable_useId as useId } from '../utils';
 import Star from '../internal/svg-icons/Star';
 import StarBorder from '../internal/svg-icons/StarBorder';
 import { styled } from '../zero-styled';
@@ -353,15 +354,9 @@ const Rating = /*#__PURE__*/React.forwardRef(function Rating(inProps, ref) {
   if (focus !== -1) {
     value = focus;
   }
-  const {
-    isFocusVisibleRef,
-    onBlur: handleBlurVisible,
-    onFocus: handleFocusVisible,
-    ref: focusVisibleRef
-  } = useIsFocusVisible();
   const [focusVisible, setFocusVisible] = React.useState(false);
   const rootRef = React.useRef();
-  const handleRef = useForkRef(focusVisibleRef, rootRef, ref);
+  const handleRef = useForkRef(rootRef, ref);
   const handleMouseMove = event => {
     if (onMouseMove) {
       onMouseMove(event);
@@ -431,8 +426,7 @@ const Rating = /*#__PURE__*/React.forwardRef(function Rating(inProps, ref) {
     }
   };
   const handleFocus = event => {
-    handleFocusVisible(event);
-    if (isFocusVisibleRef.current === true) {
+    if (isFocusVisible(event.target)) {
       setFocusVisible(true);
     }
     const newFocus = parseFloat(event.target.value);
@@ -445,8 +439,7 @@ const Rating = /*#__PURE__*/React.forwardRef(function Rating(inProps, ref) {
     if (hover !== -1) {
       return;
     }
-    handleBlurVisible(event);
-    if (isFocusVisibleRef.current === false) {
+    if (!isFocusVisible(event.target)) {
       setFocusVisible(false);
     }
     const newFocus = -1;

package/modern/Tooltip/Tooltip.js

@@ -9,6 +9,7 @@ import { appendOwnerState } from '@mui/base/utils';
 import composeClasses from '@mui/utils/composeClasses';
 import { alpha } from '@mui/system/colorManipulator';
 import { useRtl } from '@mui/system/RtlProvider';
+import isFocusVisible from '@mui/utils/isFocusVisible';
 import { styled, useTheme } from '../zero-styled';
 import { useDefaultProps } from '../DefaultPropsProvider';
 import capitalize from '../utils/capitalize';
@@ -17,7 +18,6 @@ import Popper from '../Popper';
 import useEventCallback from '../utils/useEventCallback';
 import useForkRef from '../utils/useForkRef';
 import useId from '../utils/useId';
-import useIsFocusVisible from '../utils/useIsFocusVisible';
 import useControlled from '../utils/useControlled';
 import tooltipClasses, { getTooltipUtilityClass } from './tooltipClasses';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
@@ -444,18 +444,9 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
       handleClose(event);
     });
   };
-  const {
-    isFocusVisibleRef,
-    onBlur: handleBlurVisible,
-    onFocus: handleFocusVisible,
-    ref: focusVisibleRef
-  } = useIsFocusVisible();
-  // We don't necessarily care about the focusVisible state (which is safe to access via ref anyway).
-  // We just need to re-render the Tooltip if the focus-visible state changes.
   const [, setChildIsFocusVisible] = React.useState(false);
   const handleBlur = event => {
-    handleBlurVisible(event);
-    if (isFocusVisibleRef.current === false) {
+    if (!isFocusVisible(event.target)) {
       setChildIsFocusVisible(false);
       handleMouseLeave(event);
     }
@@ -467,8 +458,7 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
     if (!childNode) {
       setChildNode(event.currentTarget);
     }
-    handleFocusVisible(event);
-    if (isFocusVisibleRef.current === true) {
+    if (isFocusVisible(event.target)) {
       setChildIsFocusVisible(true);
       handleMouseOver(event);
     }
@@ -520,7 +510,7 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
       document.removeEventListener('keydown', handleKeyDown);
     };
   }, [handleClose, open]);
-  const handleRef = useForkRef(children.ref, focusVisibleRef, setChildNode, ref);
+  const handleRef = useForkRef(children.ref, setChildNode, ref);
 
   // There is no point in displaying an empty tooltip.
   // So we exclude all falsy values, except 0, which is valid.

package/modern/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/material v6.0.0-alpha.12
+ * @mui/material v6.0.0-alpha.14
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/modern/utils/index.js

@@ -17,7 +17,6 @@ export { default as unsupportedProp } from './unsupportedProp';
 export { default as useControlled } from './useControlled';
 export { default as useEventCallback } from './useEventCallback';
 export { default as useForkRef } from './useForkRef';
-export { default as useIsFocusVisible } from './useIsFocusVisible';
 // TODO: remove this export once ClassNameGenerator is stable
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export const unstable_ClassNameGenerator = {

package/node/ButtonBase/ButtonBase.js

@@ -12,11 +12,11 @@ var _clsx = _interopRequireDefault(require("clsx"));
 var _refType = _interopRequireDefault(require("@mui/utils/refType"));
 var _elementTypeAcceptingRef = _interopRequireDefault(require("@mui/utils/elementTypeAcceptingRef"));
 var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _isFocusVisible = _interopRequireDefault(require("@mui/utils/isFocusVisible"));
 var _zeroStyled = require("../zero-styled");
 var _DefaultPropsProvider = require("../DefaultPropsProvider");
 var _useForkRef = _interopRequireDefault(require("../utils/useForkRef"));
 var _useEventCallback = _interopRequireDefault(require("../utils/useEventCallback"));
-var _useIsFocusVisible = _interopRequireDefault(require("../utils/useIsFocusVisible"));
 var _TouchRipple = _interopRequireDefault(require("./TouchRipple"));
 var _buttonBaseClasses = _interopRequireWildcard(require("./buttonBaseClasses"));
 var _jsxRuntime = require("react/jsx-runtime");
@@ -127,12 +127,6 @@ const ButtonBase = /*#__PURE__*/React.forwardRef(function ButtonBase(inProps, re
   const buttonRef = React.useRef(null);
   const rippleRef = React.useRef(null);
   const handleRippleRef = (0, _useForkRef.default)(rippleRef, touchRippleRef);
-  const {
-    isFocusVisibleRef,
-    onFocus: handleFocusVisible,
-    onBlur: handleBlurVisible,
-    ref: focusVisibleRef
-  } = (0, _useIsFocusVisible.default)();
   const [focusVisible, setFocusVisible] = React.useState(false);
   if (disabled && focusVisible) {
     setFocusVisible(false);
@@ -181,8 +175,7 @@ const ButtonBase = /*#__PURE__*/React.forwardRef(function ButtonBase(inProps, re
   const handleTouchEnd = useRippleHandler('stop', onTouchEnd);
   const handleTouchMove = useRippleHandler('stop', onTouchMove);
   const handleBlur = useRippleHandler('stop', event => {
-    handleBlurVisible(event);
-    if (isFocusVisibleRef.current === false) {
+    if (!(0, _isFocusVisible.default)(event.target)) {
       setFocusVisible(false);
     }
     if (onBlur) {
@@ -194,8 +187,7 @@ const ButtonBase = /*#__PURE__*/React.forwardRef(function ButtonBase(inProps, re
     if (!buttonRef.current) {
       buttonRef.current = event.currentTarget;
     }
-    handleFocusVisible(event);
-    if (isFocusVisibleRef.current === true) {
+    if ((0, _isFocusVisible.default)(event.target)) {
       setFocusVisible(true);
       if (onFocusVisible) {
         onFocusVisible(event);
@@ -264,7 +256,7 @@ const ButtonBase = /*#__PURE__*/React.forwardRef(function ButtonBase(inProps, re
       buttonProps['aria-disabled'] = disabled;
     }
   }
-  const handleRef = (0, _useForkRef.default)(ref, focusVisibleRef, buttonRef);
+  const handleRef = (0, _useForkRef.default)(ref, buttonRef);
   if (process.env.NODE_ENV !== 'production') {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     React.useEffect(() => {

package/node/Dialog/Dialog.js

@@ -132,7 +132,8 @@ const DialogPaper = (0, _zeroStyled.styled)(_Paper.default, {
     },
     style: {
       display: 'inline-block',
-      verticalAlign: 'middle'
+      verticalAlign: 'middle',
+      textAlign: 'initial'
     }
   }, {
     props: ({

package/node/Link/Link.js

@@ -12,11 +12,10 @@ var _clsx = _interopRequireDefault(require("clsx"));
 var _colorManipulator = require("@mui/system/colorManipulator");
 var _elementTypeAcceptingRef = _interopRequireDefault(require("@mui/utils/elementTypeAcceptingRef"));
 var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _isFocusVisible = _interopRequireDefault(require("@mui/utils/isFocusVisible"));
 var _capitalize = _interopRequireDefault(require("../utils/capitalize"));
 var _zeroStyled = require("../zero-styled");
 var _DefaultPropsProvider = require("../DefaultPropsProvider");
-var _useIsFocusVisible = _interopRequireDefault(require("../utils/useIsFocusVisible"));
-var _useForkRef = _interopRequireDefault(require("../utils/useForkRef"));
 var _Typography = _interopRequireDefault(require("../Typography"));
 var _linkClasses = _interopRequireWildcard(require("./linkClasses"));
 var _getTextDecoration = _interopRequireWildcard(require("./getTextDecoration"));
@@ -143,17 +142,9 @@ const Link = /*#__PURE__*/React.forwardRef(function Link(inProps, ref) {
     sx,
     ...other
   } = props;
-  const {
-    isFocusVisibleRef,
-    onBlur: handleBlurVisible,
-    onFocus: handleFocusVisible,
-    ref: focusVisibleRef
-  } = (0, _useIsFocusVisible.default)();
   const [focusVisible, setFocusVisible] = React.useState(false);
-  const handlerRef = (0, _useForkRef.default)(ref, focusVisibleRef);
   const handleBlur = event => {
-    handleBlurVisible(event);
-    if (isFocusVisibleRef.current === false) {
+    if (!(0, _isFocusVisible.default)(event.target)) {
       setFocusVisible(false);
     }
     if (onBlur) {
@@ -161,8 +152,7 @@ const Link = /*#__PURE__*/React.forwardRef(function Link(inProps, ref) {
     }
   };
   const handleFocus = event => {
-    handleFocusVisible(event);
-    if (isFocusVisibleRef.current === true) {
+    if ((0, _isFocusVisible.default)(event.target)) {
       setFocusVisible(true);
     }
     if (onFocus) {
@@ -185,7 +175,7 @@ const Link = /*#__PURE__*/React.forwardRef(function Link(inProps, ref) {
     component: component,
     onBlur: handleBlur,
     onFocus: handleFocus,
-    ref: handlerRef,
+    ref: ref,
     ownerState: ownerState,
     variant: variant,
     ...other,