@mui/utils 5.10.6 → 5.10.14

package/modern/elementAcceptingRef.js

@@ -1,6 +1,5 @@
 import PropTypes from 'prop-types';
 import chainPropTypes from './chainPropTypes';
-
 function isClassComponent(elementType) {
   // elementType.prototype?.isReactComponent
   const {
@@ -8,19 +7,17 @@ function isClassComponent(elementType) {
   } = elementType;
   return Boolean(prototype.isReactComponent);
 }
-
 function acceptingRef(props, propName, componentName, location, propFullName) {
   const element = props[propName];
   const safePropName = propFullName || propName;
-
-  if (element == null || // When server-side rendering React doesn't warn either.
+  if (element == null ||
+  // When server-side rendering React doesn't warn either.
   // This is not an accurate check for SSR.
   // This is only in place for Emotion compat.
   // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
   typeof window === 'undefined') {
     return null;
   }
-
   let warningHint;
   const elementType = element.type;
   /**
@@ -32,18 +29,14 @@ function acceptingRef(props, propName, componentName, location, propFullName) {
    * or class components. "Safe" means there's no public API.
    *
    */
-
   if (typeof elementType === 'function' && !isClassComponent(elementType)) {
     warningHint = 'Did you accidentally use a plain function component for an element instead?';
   }
-
   if (warningHint !== undefined) {
     return new Error(`Invalid ${location} \`${safePropName}\` supplied to \`${componentName}\`. ` + `Expected an element that can hold a ref. ${warningHint} ` + 'For more information see https://mui.com/r/caveat-with-refs-guide');
   }
-
   return null;
 }
-
 const elementAcceptingRef = chainPropTypes(PropTypes.element, acceptingRef);
 elementAcceptingRef.isRequired = chainPropTypes(PropTypes.element.isRequired, acceptingRef);
 export default elementAcceptingRef;

package/modern/elementTypeAcceptingRef.js

@@ -1,6 +1,5 @@
 import PropTypes from 'prop-types';
 import chainPropTypes from './chainPropTypes';
-
 function isClassComponent(elementType) {
   // elementType.prototype?.isReactComponent
   const {
@@ -8,20 +7,19 @@ function isClassComponent(elementType) {
   } = elementType;
   return Boolean(prototype.isReactComponent);
 }
-
 function elementTypeAcceptingRef(props, propName, componentName, location, propFullName) {
   const propValue = props[propName];
   const safePropName = propFullName || propName;
-
-  if (propValue == null || // When server-side rendering React doesn't warn either.
+  if (propValue == null ||
+  // When server-side rendering React doesn't warn either.
   // This is not an accurate check for SSR.
   // This is only in place for emotion compat.
   // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
   typeof window === 'undefined') {
     return null;
   }
-
   let warningHint;
+
   /**
    * Blacklisting instead of whitelisting
    *
@@ -31,16 +29,12 @@ function elementTypeAcceptingRef(props, propName, componentName, location, propF
    * or class components. "Safe" means there's no public API.
    *
    */
-
   if (typeof propValue === 'function' && !isClassComponent(propValue)) {
     warningHint = 'Did you accidentally provide a plain function component instead?';
   }
-
   if (warningHint !== undefined) {
     return new Error(`Invalid ${location} \`${safePropName}\` supplied to \`${componentName}\`. ` + `Expected an element type that can hold a ref. ${warningHint} ` + 'For more information see https://mui.com/r/caveat-with-refs-guide');
   }
-
   return null;
 }
-
 export default chainPropTypes(PropTypes.elementType, elementTypeAcceptingRef);

package/modern/exactProp.js

@@ -2,20 +2,18 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 // This module is based on https://github.com/airbnb/prop-types-exact repository.
 // However, in order to reduce the number of dependencies and to remove some extra safe checks
 // the module was forked.
+
 const specialProperty = 'exact-prop: \u200b';
 export default function exactProp(propTypes) {
   if (process.env.NODE_ENV === 'production') {
     return propTypes;
   }
-
   return _extends({}, propTypes, {
     [specialProperty]: props => {
       const unsupportedProps = Object.keys(props).filter(prop => !propTypes.hasOwnProperty(prop));
-
       if (unsupportedProps.length > 0) {
         return new Error(`The following props are not supported: ${unsupportedProps.map(prop => `\`${prop}\``).join(', ')}. Please remove them.`);
       }
-
       return null;
     }
   });

package/modern/formatMuiErrorMessage.js

@@ -7,16 +7,13 @@ export default function formatMuiErrorMessage(code) {
   // Apply babel-plugin-transform-template-literals in loose mode
   // loose mode is safe iff we're concatenating primitives
   // see https://babeljs.io/docs/en/babel-plugin-transform-template-literals#loose
-
   /* eslint-disable prefer-template */
   let url = 'https://mui.com/production-error/?code=' + code;
-
   for (let i = 1; i < arguments.length; i += 1) {
     // rest params over-transpile for this case
     // eslint-disable-next-line prefer-rest-params
     url += '&args[]=' + encodeURIComponent(arguments[i]);
   }
-
   return 'Minified MUI error #' + code + '; visit ' + url + ' for the full message.';
   /* eslint-enable prefer-template */
 }

package/modern/getDisplayName.js

@@ -1,54 +1,47 @@
-import { ForwardRef, Memo } from 'react-is'; // Simplified polyfill for IE11 support
-// https://github.com/JamesMGreene/Function.name/blob/58b314d4a983110c3682f1228f845d39ccca1817/Function.name.js#L3
+import { ForwardRef, Memo } from 'react-is';
 
+// Simplified polyfill for IE11 support
+// https://github.com/JamesMGreene/Function.name/blob/58b314d4a983110c3682f1228f845d39ccca1817/Function.name.js#L3
 const fnNameMatchRegex = /^\s*function(?:\s|\s*\/\*.*\*\/\s*)+([^(\s/]*)\s*/;
 export function getFunctionName(fn) {
   const match = `${fn}`.match(fnNameMatchRegex);
   const name = match && match[1];
   return name || '';
 }
-
 function getFunctionComponentName(Component, fallback = '') {
   return Component.displayName || Component.name || getFunctionName(Component) || fallback;
 }
-
 function getWrappedName(outerType, innerType, wrapperName) {
   const functionName = getFunctionComponentName(innerType);
   return outerType.displayName || (functionName !== '' ? `${wrapperName}(${functionName})` : wrapperName);
 }
+
 /**
  * cherry-pick from
  * https://github.com/facebook/react/blob/769b1f270e1251d9dbdce0fcbd9e92e502d059b8/packages/shared/getComponentName.js
  * originally forked from recompose/getDisplayName with added IE11 support
  */
-
-
 export default function getDisplayName(Component) {
   if (Component == null) {
     return undefined;
   }
-
   if (typeof Component === 'string') {
     return Component;
   }
-
   if (typeof Component === 'function') {
     return getFunctionComponentName(Component, 'Component');
-  } // TypeScript can't have components as objects but they exist in the form of `memo` or `Suspense`
-
+  }
 
+  // TypeScript can't have components as objects but they exist in the form of `memo` or `Suspense`
   if (typeof Component === 'object') {
     switch (Component.$$typeof) {
       case ForwardRef:
         return getWrappedName(Component, Component.render, 'ForwardRef');
-
       case Memo:
         return getWrappedName(Component, Component.type, 'memo');
-
       default:
         return undefined;
     }
   }
-
   return undefined;
 }

package/modern/index.js

@@ -1,4 +1,4 @@
-/** @license MUI v5.10.6
+/** @license MUI v5.10.14
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.

package/modern/integerPropType.js

@@ -1,66 +1,51 @@
 export function getTypeByValue(value) {
   const valueType = typeof value;
-
   switch (valueType) {
     case 'number':
       if (Number.isNaN(value)) {
         return 'NaN';
       }
-
       if (!Number.isFinite(value)) {
         return 'Infinity';
       }
-
       if (value !== Math.floor(value)) {
         return 'float';
       }
-
       return 'number';
-
     case 'object':
       if (value === null) {
         return 'null';
       }
-
       return value.constructor.name;
-
     default:
       return valueType;
   }
-} // IE 11 support
+}
 
+// IE 11 support
 function ponyfillIsInteger(x) {
   // eslint-disable-next-line no-restricted-globals
   return typeof x === 'number' && isFinite(x) && Math.floor(x) === x;
 }
-
 const isInteger = Number.isInteger || ponyfillIsInteger;
-
 function requiredInteger(props, propName, componentName, location) {
   const propValue = props[propName];
-
   if (propValue == null || !isInteger(propValue)) {
     const propType = getTypeByValue(propValue);
     return new RangeError(`Invalid ${location} \`${propName}\` of type \`${propType}\` supplied to \`${componentName}\`, expected \`integer\`.`);
   }
-
   return null;
 }
-
 function validator(props, propName, ...other) {
   const propValue = props[propName];
-
   if (propValue === undefined) {
     return null;
   }
-
   return requiredInteger(props, propName, ...other);
 }
-
 function validatorNoop() {
   return null;
 }
-
 validator.isRequired = requiredInteger;
 validatorNoop.isRequired = validatorNoop;
 export default process.env.NODE_ENV === 'production' ? validatorNoop : validator;

package/modern/requirePropFactory.js

@@ -2,29 +2,23 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 export default function requirePropFactory(componentNameInError, Component) {
   if (process.env.NODE_ENV === 'production') {
     return () => null;
-  } // eslint-disable-next-line react/forbid-foreign-prop-types
-
+  }
 
+  // eslint-disable-next-line react/forbid-foreign-prop-types
   const prevPropTypes = Component ? _extends({}, Component.propTypes) : null;
-
   const requireProp = requiredProp => (props, propName, componentName, location, propFullName, ...args) => {
     const propFullNameSafe = propFullName || propName;
     const defaultTypeChecker = prevPropTypes?.[propFullNameSafe];
-
     if (defaultTypeChecker) {
       const typeCheckerResult = defaultTypeChecker(props, propName, componentName, location, propFullName, ...args);
-
       if (typeCheckerResult) {
         return typeCheckerResult;
       }
     }
-
     if (typeof props[propName] !== 'undefined' && !props[requiredProp]) {
       return new Error(`The prop \`${propFullNameSafe}\` of ` + `\`${componentNameInError}\` can only be used together with the \`${requiredProp}\` prop.`);
     }
-
     return null;
   };
-
   return requireProp;
 }

package/modern/resolveProps.js

@@ -1,5 +1,4 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
-
 /**
  * Add keys, values of `defaultProps` that does not exist in `props`
  * @param {object} defaultProps
@@ -8,7 +7,6 @@ import _extends from "@babel/runtime/helpers/esm/extends";
  */
 export default function resolveProps(defaultProps, props) {
   const output = _extends({}, props);
-
   Object.keys(defaultProps).forEach(propName => {
     if (output[propName] === undefined) {
       output[propName] = defaultProps[propName];

package/modern/scrollLeft.js

@@ -1,5 +1,6 @@
 // Source from https://github.com/alitaheri/normalize-scroll-left
 let cachedType;
+
 /**
  * Based on the jquery plugin https://github.com/othree/jquery.rtl-scroll-type
  *
@@ -19,12 +20,10 @@ let cachedType;
  *
  * spec* https://drafts.csswg.org/cssom-view/#dom-window-scroll
  */
-
 export function detectScrollType() {
   if (cachedType) {
     return cachedType;
   }
-
   const dummy = document.createElement('div');
   const container = document.createElement('div');
   container.style.width = '10px';
@@ -39,37 +38,32 @@ export function detectScrollType() {
   dummy.style.overflow = 'scroll';
   document.body.appendChild(dummy);
   cachedType = 'reverse';
-
   if (dummy.scrollLeft > 0) {
     cachedType = 'default';
   } else {
     dummy.scrollLeft = 1;
-
     if (dummy.scrollLeft === 0) {
       cachedType = 'negative';
     }
   }
-
   document.body.removeChild(dummy);
   return cachedType;
-} // Based on https://stackoverflow.com/a/24394376
+}
 
+// Based on https://stackoverflow.com/a/24394376
 export function getNormalizedScrollLeft(element, direction) {
-  const scrollLeft = element.scrollLeft; // Perform the calculations only when direction is rtl to avoid messing up the ltr behavior
+  const scrollLeft = element.scrollLeft;
 
+  // Perform the calculations only when direction is rtl to avoid messing up the ltr behavior
   if (direction !== 'rtl') {
     return scrollLeft;
   }
-
   const type = detectScrollType();
-
   switch (type) {
     case 'negative':
       return element.scrollWidth - element.clientWidth + scrollLeft;
-
     case 'reverse':
       return element.scrollWidth - element.clientWidth - scrollLeft;
-
     default:
       return scrollLeft;
   }

package/modern/unsupportedProp.js

@@ -2,12 +2,9 @@ export default function unsupportedProp(props, propName, componentName, location
   if (process.env.NODE_ENV === 'production') {
     return null;
   }
-
   const propFullNameSafe = propFullName || propName;
-
   if (typeof props[propName] !== 'undefined') {
     return new Error(`The prop \`${propFullNameSafe}\` is not supported. Please remove it.`);
   }
-
   return null;
 }

package/modern/useControlled.js

@@ -12,7 +12,6 @@ export default function useControlled({
   } = React.useRef(controlled !== undefined);
   const [valueState, setValue] = React.useState(defaultProp);
   const value = isControlled ? controlled : valueState;
-
   if (process.env.NODE_ENV !== 'production') {
     React.useEffect(() => {
       if (isControlled !== (controlled !== undefined)) {
@@ -28,7 +27,6 @@ export default function useControlled({
       }
     }, [JSON.stringify(defaultProp)]);
   }
-
   const setValueIfUncontrolled = React.useCallback(newValue => {
     if (!isControlled) {
       setValue(newValue);

package/modern/useEventCallback.js

@@ -1,15 +1,16 @@
 import * as React from 'react';
 import useEnhancedEffect from './useEnhancedEffect';
+
 /**
  * https://github.com/facebook/react/issues/14099#issuecomment-440013892
  */
-
 export default function useEventCallback(fn) {
   const ref = React.useRef(fn);
   useEnhancedEffect(() => {
     ref.current = fn;
   });
-  return React.useCallback((...args) => // @ts-expect-error hide `this`
+  return React.useCallback((...args) =>
+  // @ts-expect-error hide `this`
   // tslint:disable-next-line:ban-comma-operator
   (0, ref.current)(...args), []);
 }

package/modern/useForkRef.js

@@ -1,19 +1,20 @@
 import * as React from 'react';
 import setRef from './setRef';
-export default function useForkRef(refA, refB) {
+export default function useForkRef(...refs) {
   /**
-   * This will create a new function if the ref props change and are defined.
+   * This will create a new function if the refs passed to this hook change and are all defined.
    * This means react will call the old forkRef with `null` and the new forkRef
    * with the ref. Cleanup naturally emerges from this behavior.
    */
   return React.useMemo(() => {
-    if (refA == null && refB == null) {
+    if (refs.every(ref => ref == null)) {
       return null;
     }
-
-    return refValue => {
-      setRef(refA, refValue);
-      setRef(refB, refValue);
+    return instance => {
+      refs.forEach(ref => {
+        setRef(ref, instance);
+      });
     };
-  }, [refA, refB]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, refs);
 }

package/modern/useId.js

@@ -1,6 +1,5 @@
 import * as React from 'react';
 let globalId = 0;
-
 function useGlobalId(idOverride) {
   const [defaultId, setDefaultId] = React.useState(idOverride);
   const id = idOverride || defaultId;
@@ -15,9 +14,9 @@ function useGlobalId(idOverride) {
     }
   }, [defaultId]);
   return id;
-} // eslint-disable-next-line no-useless-concat -- Workaround for https://github.com/webpack/webpack/issues/14814
-
+}
 
+// eslint-disable-next-line no-useless-concat -- Workaround for https://github.com/webpack/webpack/issues/14814
 const maybeReactUseId = React['useId' + ''];
 /**
  *
@@ -25,13 +24,11 @@ const maybeReactUseId = React['useId' + ''];
  * @param idOverride
  * @returns {string}
  */
-
 export default function useId(idOverride) {
   if (maybeReactUseId !== undefined) {
     const reactId = maybeReactUseId();
     return idOverride ?? reactId;
-  } // eslint-disable-next-line react-hooks/rules-of-hooks -- `React.useId` is invariant at runtime.
-
-
+  }
+  // eslint-disable-next-line react-hooks/rules-of-hooks -- `React.useId` is invariant at runtime.
   return useGlobalId(idOverride);
 }

package/modern/useIsFocusVisible.js

@@ -18,6 +18,7 @@ const inputTypesWhitelist = {
   datetime: true,
   'datetime-local': true
 };
+
 /**
  * Computes whether the given element should automatically trigger the
  * `focus-visible` class being added, i.e. whether it should always match
@@ -25,27 +26,23 @@ const inputTypesWhitelist = {
  * @param {Element} node
  * @returns {boolean}
  */
-
 function focusTriggersKeyboardModality(node) {
   const {
     type,
     tagName
   } = node;
-
   if (tagName === 'INPUT' && inputTypesWhitelist[type] && !node.readOnly) {
     return true;
   }
-
   if (tagName === 'TEXTAREA' && !node.readOnly) {
     return true;
   }
-
   if (node.isContentEditable) {
     return true;
   }
-
   return false;
 }
+
 /**
  * Keep track of our keyboard modality state with `hadKeyboardEvent`.
  * If the most recent user interaction was via the keyboard;
@@ -53,15 +50,13 @@ function focusTriggersKeyboardModality(node) {
  * then the modality is keyboard. Otherwise, the modality is not keyboard.
  * @param {KeyboardEvent} event
  */
-
-
 function handleKeyDown(event) {
   if (event.metaKey || event.altKey || event.ctrlKey) {
     return;
   }
-
   hadKeyboardEvent = true;
 }
+
 /**
  * If at any point a user clicks with a pointing device, ensure that we change
  * the modality away from keyboard.
@@ -69,12 +64,9 @@ function handleKeyDown(event) {
  * element, and then clicks on a different element, focusing it with a
  * pointing device, while we still think we're in keyboard modality.
  */
-
-
 function handlePointerDown() {
   hadKeyboardEvent = false;
 }
-
 function handleVisibilityChange() {
   if (this.visibilityState === 'hidden') {
     // If the tab becomes active again, the browser will handle calling focus
@@ -86,7 +78,6 @@ function handleVisibilityChange() {
     }
   }
 }
-
 function prepare(doc) {
   doc.addEventListener('keydown', handleKeyDown, true);
   doc.addEventListener('mousedown', handlePointerDown, true);
@@ -94,7 +85,6 @@ function prepare(doc) {
   doc.addEventListener('touchstart', handlePointerDown, true);
   doc.addEventListener('visibilitychange', handleVisibilityChange, true);
 }
-
 export function teardown(doc) {
   doc.removeEventListener('keydown', handleKeyDown, true);
   doc.removeEventListener('mousedown', handlePointerDown, true);
@@ -102,25 +92,23 @@ export function teardown(doc) {
   doc.removeEventListener('touchstart', handlePointerDown, true);
   doc.removeEventListener('visibilitychange', handleVisibilityChange, true);
 }
-
 function isFocusVisible(event) {
   const {
     target
   } = event;
-
   try {
     return target.matches(':focus-visible');
-  } catch (error) {// Browsers not implementing :focus-visible will throw a SyntaxError.
+  } catch (error) {
+    // Browsers not implementing :focus-visible will throw a SyntaxError.
     // We use our own heuristic for those browsers.
     // Rethrow might be better if it's not the expected error but do we really
     // want to crash if focus-visible malfunctioned?
-  } // No need for validFocusTarget check. The user does that by attaching it to
-  // focusable events only.
-
+  }
 
+  // No need for validFocusTarget check. The user does that by attaching it to
+  // focusable events only.
   return hadKeyboardEvent || focusTriggersKeyboardModality(target);
 }
-
 export default function useIsFocusVisible() {
   const ref = React.useCallback(node => {
     if (node != null) {
@@ -128,10 +116,10 @@ export default function useIsFocusVisible() {
     }
   }, []);
   const isFocusVisibleRef = React.useRef(false);
+
   /**
    * Should be called if a blur event is fired
    */
-
   function handleBlurVisible() {
     // checking against potential state variable does not suffice if we focus and blur synchronously.
     // React wouldn't have time to trigger a re-render so `focusVisible` would be stale.
@@ -151,23 +139,19 @@ export default function useIsFocusVisible() {
       isFocusVisibleRef.current = false;
       return true;
     }
-
     return false;
   }
+
   /**
    * Should be called if a blur event is fired
    */
-
-
   function handleFocusVisible(event) {
     if (isFocusVisible(event)) {
       isFocusVisibleRef.current = true;
       return true;
     }
-
     return false;
   }
-
   return {
     isFocusVisibleRef,
     onFocus: handleFocusVisible,

package/modern/usePreviousProps.js

@@ -1,5 +1,4 @@
 import * as React from 'react';
-
 const usePreviousProps = value => {
   const ref = React.useRef({});
   React.useEffect(() => {
@@ -7,5 +6,4 @@ const usePreviousProps = value => {
   });
   return ref.current;
 };
-
 export default usePreviousProps;

package/ownerDocument.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = ownerDocument;
-
 function ownerDocument(node) {
   return node && node.ownerDocument || document;
 }

package/ownerWindow.js

@@ -1,14 +1,11 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = ownerWindow;
-
 var _ownerDocument = _interopRequireDefault(require("./ownerDocument"));
-
 function ownerWindow(node) {
   const doc = (0, _ownerDocument.default)(node);
   return doc.defaultView || window;