@mui/material 5.10.0 → 5.10.3

package/esm/transitions/index.js

@@ -0,0 +1 @@
+export * from './transition';

package/esm/transitions/transition.js

@@ -0,0 +1 @@
+export {};

package/esm/transitions/utils.js

@@ -0,0 +1,15 @@
+export const reflow = node => node.scrollTop;
+export function getTransitionProps(props, options) {
+  var _style$transitionDura, _style$transitionTimi;
+
+  const {
+    timeout,
+    easing,
+    style = {}
+  } = props;
+  return {
+    duration: (_style$transitionDura = style.transitionDuration) != null ? _style$transitionDura : typeof timeout === 'number' ? timeout : timeout[options.mode] || 0,
+    easing: (_style$transitionTimi = style.transitionTimingFunction) != null ? _style$transitionTimi : typeof easing === 'object' ? easing[options.mode] : easing,
+    delay: style.transitionDelay
+  };
+}

package/esm/useAutocomplete/index.js

@@ -0,0 +1 @@
+export { default, createFilterOptions } from './useAutocomplete';

package/esm/useAutocomplete/useAutocomplete.js

@@ -0,0 +1,2 @@
+export { useAutocomplete as default } from '@mui/base/AutocompleteUnstyled';
+export * from '@mui/base/AutocompleteUnstyled';

package/esm/useMediaQuery/index.js

@@ -0,0 +1 @@
+export { default } from './useMediaQuery';

package/esm/useMediaQuery/useMediaQuery.js

@@ -0,0 +1,124 @@
+import * as React from 'react';
+import { getThemeProps, useThemeWithoutDefault as useTheme } from '@mui/system';
+import useEnhancedEffect from '../utils/useEnhancedEffect';
+/**
+ * @deprecated Not used internally. Use `MediaQueryListEvent` from lib.dom.d.ts instead.
+ */
+
+function useMediaQueryOld(query, defaultMatches, matchMedia, ssrMatchMedia, noSsr) {
+  const supportMatchMedia = typeof window !== 'undefined' && typeof window.matchMedia !== 'undefined';
+  const [match, setMatch] = React.useState(() => {
+    if (noSsr && supportMatchMedia) {
+      return matchMedia(query).matches;
+    }
+
+    if (ssrMatchMedia) {
+      return ssrMatchMedia(query).matches;
+    } // Once the component is mounted, we rely on the
+    // event listeners to return the correct matches value.
+
+
+    return defaultMatches;
+  });
+  useEnhancedEffect(() => {
+    let active = true;
+
+    if (!supportMatchMedia) {
+      return undefined;
+    }
+
+    const queryList = matchMedia(query);
+
+    const updateMatch = () => {
+      // Workaround Safari wrong implementation of matchMedia
+      // TODO can we remove it?
+      // https://github.com/mui/material-ui/pull/17315#issuecomment-528286677
+      if (active) {
+        setMatch(queryList.matches);
+      }
+    };
+
+    updateMatch(); // TODO: Use `addEventListener` once support for Safari < 14 is dropped
+
+    queryList.addListener(updateMatch);
+    return () => {
+      active = false;
+      queryList.removeListener(updateMatch);
+    };
+  }, [query, matchMedia, supportMatchMedia]);
+  return match;
+} // eslint-disable-next-line no-useless-concat -- Workaround for https://github.com/webpack/webpack/issues/14814
+
+
+const maybeReactUseSyncExternalStore = React['useSyncExternalStore' + ''];
+
+function useMediaQueryNew(query, defaultMatches, matchMedia, ssrMatchMedia) {
+  const getDefaultSnapshot = React.useCallback(() => defaultMatches, [defaultMatches]);
+  const getServerSnapshot = React.useMemo(() => {
+    if (ssrMatchMedia !== null) {
+      const {
+        matches
+      } = ssrMatchMedia(query);
+      return () => matches;
+    }
+
+    return getDefaultSnapshot;
+  }, [getDefaultSnapshot, query, ssrMatchMedia]);
+  const [getSnapshot, subscribe] = React.useMemo(() => {
+    if (matchMedia === null) {
+      return [getDefaultSnapshot, () => () => {}];
+    }
+
+    const mediaQueryList = matchMedia(query);
+    return [() => mediaQueryList.matches, notify => {
+      // TODO: Use `addEventListener` once support for Safari < 14 is dropped
+      mediaQueryList.addListener(notify);
+      return () => {
+        mediaQueryList.removeListener(notify);
+      };
+    }];
+  }, [getDefaultSnapshot, matchMedia, query]);
+  const match = maybeReactUseSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  return match;
+}
+
+export default function useMediaQuery(queryInput, options = {}) {
+  const theme = useTheme(); // Wait for jsdom to support the match media feature.
+  // All the browsers MUI support have this built-in.
+  // This defensive check is here for simplicity.
+  // Most of the time, the match media logic isn't central to people tests.
+
+  const supportMatchMedia = typeof window !== 'undefined' && typeof window.matchMedia !== 'undefined';
+  const {
+    defaultMatches = false,
+    matchMedia = supportMatchMedia ? window.matchMedia : null,
+    ssrMatchMedia = null,
+    noSsr
+  } = getThemeProps({
+    name: 'MuiUseMediaQuery',
+    props: options,
+    theme
+  });
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (typeof queryInput === 'function' && theme === null) {
+      console.error(['MUI: The `query` argument provided is invalid.', 'You are providing a function without a theme in the context.', 'One of the parent elements needs to use a ThemeProvider.'].join('\n'));
+    }
+  }
+
+  let query = typeof queryInput === 'function' ? queryInput(theme) : queryInput;
+  query = query.replace(/^@media( ?)/m, ''); // TODO: Drop `useMediaQueryOld` and use  `use-sync-external-store` shim in `useMediaQueryNew` once the package is stable
+
+  const useMediaQueryImplementation = maybeReactUseSyncExternalStore !== undefined ? useMediaQueryNew : useMediaQueryOld;
+  const match = useMediaQueryImplementation(query, defaultMatches, matchMedia, ssrMatchMedia, noSsr);
+
+  if (process.env.NODE_ENV !== 'production') {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    React.useDebugValue({
+      query,
+      match
+    });
+  }
+
+  return match;
+}

package/esm/useMediaQuery/useMediaQueryTheme.js

@@ -0,0 +1,5 @@
+import useMediaQuery from './useMediaQuery'; // TODO v5: to deprecate in v4.x and remove in v5
+
+export default function useMediaQueryTheme(...args) {
+  return useMediaQuery(...args);
+}

package/esm/usePagination/index.js

@@ -0,0 +1 @@
+export { default } from './usePagination';

package/esm/usePagination/usePagination.js

@@ -0,0 +1,110 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["boundaryCount", "componentName", "count", "defaultPage", "disabled", "hideNextButton", "hidePrevButton", "onChange", "page", "showFirstButton", "showLastButton", "siblingCount"];
+import { unstable_useControlled as useControlled } from '@mui/utils';
+export default function usePagination(props = {}) {
+  // keep default values in sync with @default tags in Pagination.propTypes
+  const {
+    boundaryCount = 1,
+    componentName = 'usePagination',
+    count = 1,
+    defaultPage = 1,
+    disabled = false,
+    hideNextButton = false,
+    hidePrevButton = false,
+    onChange: handleChange,
+    page: pageProp,
+    showFirstButton = false,
+    showLastButton = false,
+    siblingCount = 1
+  } = props,
+        other = _objectWithoutPropertiesLoose(props, _excluded);
+
+  const [page, setPageState] = useControlled({
+    controlled: pageProp,
+    default: defaultPage,
+    name: componentName,
+    state: 'page'
+  });
+
+  const handleClick = (event, value) => {
+    if (!pageProp) {
+      setPageState(value);
+    }
+
+    if (handleChange) {
+      handleChange(event, value);
+    }
+  }; // https://dev.to/namirsab/comment/2050
+
+
+  const range = (start, end) => {
+    const length = end - start + 1;
+    return Array.from({
+      length
+    }, (_, i) => start + i);
+  };
+
+  const startPages = range(1, Math.min(boundaryCount, count));
+  const endPages = range(Math.max(count - boundaryCount + 1, boundaryCount + 1), count);
+  const siblingsStart = Math.max(Math.min( // Natural start
+  page - siblingCount, // Lower boundary when page is high
+  count - boundaryCount - siblingCount * 2 - 1), // Greater than startPages
+  boundaryCount + 2);
+  const siblingsEnd = Math.min(Math.max( // Natural end
+  page + siblingCount, // Upper boundary when page is low
+  boundaryCount + siblingCount * 2 + 2), // Less than endPages
+  endPages.length > 0 ? endPages[0] - 2 : count - 1); // Basic list of items to render
+  // e.g. itemList = ['first', 'previous', 1, 'ellipsis', 4, 5, 6, 'ellipsis', 10, 'next', 'last']
+
+  const itemList = [...(showFirstButton ? ['first'] : []), ...(hidePrevButton ? [] : ['previous']), ...startPages, // Start ellipsis
+  // eslint-disable-next-line no-nested-ternary
+  ...(siblingsStart > boundaryCount + 2 ? ['start-ellipsis'] : boundaryCount + 1 < count - boundaryCount ? [boundaryCount + 1] : []), // Sibling pages
+  ...range(siblingsStart, siblingsEnd), // End ellipsis
+  // eslint-disable-next-line no-nested-ternary
+  ...(siblingsEnd < count - boundaryCount - 1 ? ['end-ellipsis'] : count - boundaryCount > boundaryCount ? [count - boundaryCount] : []), ...endPages, ...(hideNextButton ? [] : ['next']), ...(showLastButton ? ['last'] : [])]; // Map the button type to its page number
+
+  const buttonPage = type => {
+    switch (type) {
+      case 'first':
+        return 1;
+
+      case 'previous':
+        return page - 1;
+
+      case 'next':
+        return page + 1;
+
+      case 'last':
+        return count;
+
+      default:
+        return null;
+    }
+  }; // Convert the basic item list to PaginationItem props objects
+
+
+  const items = itemList.map(item => {
+    return typeof item === 'number' ? {
+      onClick: event => {
+        handleClick(event, item);
+      },
+      type: 'page',
+      page: item,
+      selected: item === page,
+      disabled,
+      'aria-current': item === page ? 'true' : undefined
+    } : {
+      onClick: event => {
+        handleClick(event, buttonPage(item));
+      },
+      type: item,
+      page: buttonPage(item),
+      selected: false,
+      disabled: disabled || item.indexOf('ellipsis') === -1 && (item === 'next' || item === 'last' ? page >= count : page <= 1)
+    };
+  });
+  return _extends({
+    items
+  }, other);
+}

package/esm/useScrollTrigger/index.js

@@ -0,0 +1 @@
+export { default } from './useScrollTrigger';

package/esm/useScrollTrigger/useScrollTrigger.js

@@ -0,0 +1,58 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["getTrigger", "target"];
+import * as React from 'react';
+
+function defaultTrigger(store, options) {
+  const {
+    disableHysteresis = false,
+    threshold = 100,
+    target
+  } = options;
+  const previous = store.current;
+
+  if (target) {
+    // Get vertical scroll
+    store.current = target.pageYOffset !== undefined ? target.pageYOffset : target.scrollTop;
+  }
+
+  if (!disableHysteresis && previous !== undefined) {
+    if (store.current < previous) {
+      return false;
+    }
+  }
+
+  return store.current > threshold;
+}
+
+const defaultTarget = typeof window !== 'undefined' ? window : null;
+export default function useScrollTrigger(options = {}) {
+  const {
+    getTrigger = defaultTrigger,
+    target = defaultTarget
+  } = options,
+        other = _objectWithoutPropertiesLoose(options, _excluded);
+
+  const store = React.useRef();
+  const [trigger, setTrigger] = React.useState(() => getTrigger(store, other));
+  React.useEffect(() => {
+    const handleScroll = () => {
+      setTrigger(getTrigger(store, _extends({
+        target
+      }, other)));
+    };
+
+    handleScroll(); // Re-evaluate trigger when dependencies change
+
+    target.addEventListener('scroll', handleScroll, {
+      passive: true
+    });
+    return () => {
+      target.removeEventListener('scroll', handleScroll, {
+        passive: true
+      });
+    }; // See Option 3. https://github.com/facebook/react/issues/14476#issuecomment-471199055
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [target, getTrigger, JSON.stringify(other)]);
+  return trigger;
+}

package/esm/useTouchRipple/index.js

@@ -0,0 +1 @@
+export { default } from './useTouchRipple';

package/esm/useTouchRipple/useTouchRipple.js

@@ -0,0 +1,105 @@
+import * as React from 'react';
+import { useEventCallback } from '../utils';
+
+const useTouchRipple = props => {
+  const {
+    disabled,
+    disableFocusRipple,
+    disableRipple,
+    disableTouchRipple,
+    focusVisible,
+    rippleRef
+  } = props;
+  React.useEffect(() => {
+    if (focusVisible && !disableFocusRipple && !disableRipple) {
+      var _rippleRef$current;
+
+      (_rippleRef$current = rippleRef.current) == null ? void 0 : _rippleRef$current.pulsate();
+    }
+  }, [rippleRef, focusVisible, disableFocusRipple, disableRipple]);
+
+  function useRippleHandler(rippleAction, skipRippleAction = disableTouchRipple) {
+    return useEventCallback(event => {
+      if (!skipRippleAction && rippleRef.current) {
+        rippleRef.current[rippleAction](event);
+      }
+
+      return true;
+    });
+  }
+
+  const keydownRef = React.useRef(false);
+  const handleKeyDown = useEventCallback(event => {
+    if (!disableFocusRipple && !keydownRef.current && focusVisible && rippleRef.current && event.key === ' ') {
+      keydownRef.current = true;
+      rippleRef.current.stop(event, () => {
+        var _rippleRef$current2;
+
+        rippleRef == null ? void 0 : (_rippleRef$current2 = rippleRef.current) == null ? void 0 : _rippleRef$current2.start(event);
+      });
+    }
+  });
+  const handleKeyUp = useEventCallback(event => {
+    // calling preventDefault in keyUp on a <button> will not dispatch a click event if Space is pressed
+    // https://codesandbox.io/s/button-keyup-preventdefault-dn7f0
+    if (!disableFocusRipple && event.key === ' ' && rippleRef.current && focusVisible && !event.defaultPrevented) {
+      keydownRef.current = false;
+      rippleRef.current.stop(event, () => {
+        var _rippleRef$current3;
+
+        rippleRef == null ? void 0 : (_rippleRef$current3 = rippleRef.current) == null ? void 0 : _rippleRef$current3.pulsate(event);
+      });
+    }
+  });
+  const handleBlur = useRippleHandler('stop', false);
+  const handleMouseDown = useRippleHandler('start');
+  const handleContextMenu = useRippleHandler('stop');
+  const handleDragLeave = useRippleHandler('stop');
+  const handleMouseUp = useRippleHandler('stop');
+  const handleMouseLeave = useRippleHandler('stop');
+  const handleTouchStart = useRippleHandler('start');
+  const handleTouchEnd = useRippleHandler('stop');
+  const handleTouchMove = useRippleHandler('stop');
+  const [mountedState, setMountedState] = React.useState(false);
+  React.useEffect(() => {
+    setMountedState(true);
+  }, []);
+  const enableTouchRipple = mountedState && !disableRipple && !disabled;
+  const getRippleHandlers = React.useMemo(() => {
+    const rippleHandlers = {
+      onBlur: handleBlur,
+      onKeyDown: handleKeyDown,
+      onKeyUp: handleKeyUp,
+      onMouseDown: handleMouseDown,
+      onMouseUp: handleMouseUp,
+      onMouseLeave: handleMouseLeave,
+      onContextMenu: handleContextMenu,
+      onDragLeave: handleDragLeave,
+      onTouchStart: handleTouchStart,
+      onTouchEnd: handleTouchEnd,
+      onTouchMove: handleTouchMove
+    };
+    return (otherEvents = {}) => {
+      const eventNames = Object.keys(rippleHandlers);
+      const wrappedEvents = eventNames.map(eventName => ({
+        name: eventName,
+        handler: ev => {
+          var _otherEvents$eventNam;
+
+          (_otherEvents$eventNam = otherEvents[eventName]) == null ? void 0 : _otherEvents$eventNam.call(otherEvents, ev);
+          rippleHandlers[eventName](ev);
+        }
+      }));
+      return wrappedEvents.reduce((acc, current) => {
+        acc[current.name] = current.handler;
+        return acc;
+      }, {});
+    };
+  }, [handleBlur, handleKeyDown, handleKeyUp, handleMouseDown, handleMouseUp, handleMouseLeave, handleContextMenu, handleDragLeave, handleTouchStart, handleTouchEnd, handleTouchMove]);
+  return {
+    enableTouchRipple,
+    getRippleHandlers
+  };
+};
+
+export default useTouchRipple;

package/esm/utils/capitalize.js

@@ -0,0 +1,2 @@
+import { unstable_capitalize as capitalize } from '@mui/utils';
+export default capitalize;

package/esm/utils/createChainedFunction.js

@@ -0,0 +1,2 @@
+import { unstable_createChainedFunction as createChainedFunction } from '@mui/utils';
+export default createChainedFunction;

package/esm/utils/createSvgIcon.js

@@ -0,0 +1,25 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import SvgIcon from '../SvgIcon';
+/**
+ * Private module reserved for @mui packages.
+ */
+
+import { jsx as _jsx } from "react/jsx-runtime";
+export default function createSvgIcon(path, displayName) {
+  const Component = (props, ref) => /*#__PURE__*/_jsx(SvgIcon, _extends({
+    "data-testid": `${displayName}Icon`,
+    ref: ref
+  }, props, {
+    children: path
+  }));
+
+  if (process.env.NODE_ENV !== 'production') {
+    // Need to set `displayName` on the inner component for React.memo.
+    // React prior to 16.14 ignores `displayName` on the wrapper.
+    Component.displayName = `${displayName}Icon`;
+  }
+
+  Component.muiName = SvgIcon.muiName;
+  return /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef(Component));
+}

package/esm/utils/debounce.js

@@ -0,0 +1,2 @@
+import { unstable_debounce as debounce } from '@mui/utils';
+export default debounce;

package/esm/utils/deprecatedPropType.js

@@ -0,0 +1,2 @@
+import { unstable_deprecatedPropType as deprecatedPropType } from '@mui/utils';
+export default deprecatedPropType;

package/esm/utils/getScrollbarSize.js

@@ -0,0 +1,2 @@
+import { unstable_getScrollbarSize as getScrollbarSize } from '@mui/utils';
+export default getScrollbarSize;

package/esm/utils/index.js

@@ -0,0 +1,26 @@
+import { unstable_ClassNameGenerator as ClassNameGenerator } from '@mui/base/className';
+export { default as capitalize } from './capitalize';
+export { default as createChainedFunction } from './createChainedFunction';
+export { default as createSvgIcon } from './createSvgIcon';
+export { default as debounce } from './debounce';
+export { default as deprecatedPropType } from './deprecatedPropType';
+export { default as isMuiElement } from './isMuiElement';
+export { default as ownerDocument } from './ownerDocument';
+export { default as ownerWindow } from './ownerWindow';
+export { default as requirePropFactory } from './requirePropFactory';
+export { default as setRef } from './setRef';
+export { default as unstable_useEnhancedEffect } from './useEnhancedEffect';
+export { default as unstable_useId } from './useId';
+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 = {
+  configure: generator => {
+    console.warn(['MUI: `ClassNameGenerator` import from `@mui/material/utils` is outdated and might cause unexpected issues.', '', "You should use `import { unstable_ClassNameGenerator } from '@mui/material/className'` instead", '', 'The detail of the issue: https://github.com/mui/material-ui/issues/30011#issuecomment-1024993401', '', 'The updated documentation: https://mui.com/guides/classname-generator/'].join('\n'));
+    ClassNameGenerator.configure(generator);
+  }
+};

package/esm/utils/isMuiElement.js

@@ -0,0 +1,2 @@
+import { unstable_isMuiElement as isMuiElement } from '@mui/utils';
+export default isMuiElement;

package/esm/utils/ownerDocument.js

@@ -0,0 +1,2 @@
+import { unstable_ownerDocument as ownerDocument } from '@mui/utils';
+export default ownerDocument;

package/esm/utils/ownerWindow.js

@@ -0,0 +1,2 @@
+import { unstable_ownerWindow as ownerWindow } from '@mui/utils';
+export default ownerWindow;

package/esm/utils/requirePropFactory.js

@@ -0,0 +1,2 @@
+import { unstable_requirePropFactory as requirePropFactory } from '@mui/utils';
+export default requirePropFactory;

package/esm/utils/scrollLeft.js

@@ -0,0 +1 @@
+export { unstable_detectScrollType as detectScrollType, unstable_getNormalizedScrollLeft as getNormalizedScrollLeft } from '@mui/utils';

package/esm/utils/setRef.js

@@ -0,0 +1,2 @@
+import { unstable_setRef as setRef } from '@mui/utils';
+export default setRef;

package/esm/utils/shouldSpreadAdditionalProps.js

@@ -0,0 +1,7 @@
+import { isHostComponent } from '@mui/base';
+
+const shouldSpreadAdditionalProps = Slot => {
+  return !Slot || !isHostComponent(Slot);
+};
+
+export default shouldSpreadAdditionalProps;

package/esm/utils/unsupportedProp.js

@@ -0,0 +1,2 @@
+import { unstable_unsupportedProp as unsupportedProp } from '@mui/utils';
+export default unsupportedProp;

package/esm/utils/useControlled.js

@@ -0,0 +1,2 @@
+import { unstable_useControlled as useControlled } from '@mui/utils';
+export default useControlled;

package/esm/utils/useEnhancedEffect.js

@@ -0,0 +1,2 @@
+import { unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/utils';
+export default useEnhancedEffect;

package/esm/utils/useEventCallback.js

@@ -0,0 +1,2 @@
+import { unstable_useEventCallback as useEventCallback } from '@mui/utils';
+export default useEventCallback;

package/esm/utils/useForkRef.js

@@ -0,0 +1,2 @@
+import { unstable_useForkRef as useForkRef } from '@mui/utils';
+export default useForkRef;

package/esm/utils/useId.js

@@ -0,0 +1,2 @@
+import { unstable_useId as useId } from '@mui/utils';
+export default useId;

package/esm/utils/useIsFocusVisible.js

@@ -0,0 +1,2 @@
+import { unstable_useIsFocusVisible as useIsFocusVisible } from '@mui/utils';
+export default useIsFocusVisible;