@mui/system 5.0.6 → 5.1.0

package/legacy/styleFunctionSx/styleFunctionSx.js

@@ -24,53 +24,63 @@ function callIfFn(maybeFn, arg) {
 
 function styleFunctionSx(props) {
   var _ref = props || {},
-      styles = _ref.sx,
+      sx = _ref.sx,
       _ref$theme = _ref.theme,
       theme = _ref$theme === void 0 ? {} : _ref$theme;
 
-  if (!styles) {
-    return null;
+  if (!sx) {
+    return null; // emotion & styled-components will neglect null
   }
+  /*
+   * Receive `sxInput` as object or callback
+   * and then recursively check keys & values to create media query object styles.
+   * (the result will be used in `styled`)
+   */
 
-  var stylesObject = styles;
 
-  if (typeof styles === 'function') {
-    stylesObject = styles(theme);
-  } else if (_typeof(styles) !== 'object') {
-    // value
-    return styles;
-  }
+  function traverse(sxInput) {
+    var sxObject = sxInput;
 
-  var emptyBreakpoints = createEmptyBreakpointObject(theme.breakpoints);
-  var breakpointsKeys = Object.keys(emptyBreakpoints);
-  var css = emptyBreakpoints;
-  Object.keys(stylesObject).forEach(function (styleKey) {
-    var value = callIfFn(stylesObject[styleKey], theme);
+    if (typeof sxInput === 'function') {
+      sxObject = sxInput(theme);
+    } else if (_typeof(sxInput) !== 'object') {
+      // value
+      return sxInput;
+    }
 
-    if (_typeof(value) === 'object') {
-      if (propToStyleFunction[styleKey]) {
-        css = merge(css, getThemeValue(styleKey, value, theme));
-      } else {
-        var breakpointsValues = handleBreakpoints({
-          theme: theme
-        }, value, function (x) {
-          return _defineProperty({}, styleKey, x);
-        });
+    var emptyBreakpoints = createEmptyBreakpointObject(theme.breakpoints);
+    var breakpointsKeys = Object.keys(emptyBreakpoints);
+    var css = emptyBreakpoints;
+    Object.keys(sxObject).forEach(function (styleKey) {
+      var value = callIfFn(sxObject[styleKey], theme);
 
-        if (objectsHaveSameKeys(breakpointsValues, value)) {
-          css[styleKey] = styleFunctionSx({
-            sx: value,
+      if (_typeof(value) === 'object') {
+        if (propToStyleFunction[styleKey]) {
+          css = merge(css, getThemeValue(styleKey, value, theme));
+        } else {
+          var breakpointsValues = handleBreakpoints({
             theme: theme
+          }, value, function (x) {
+            return _defineProperty({}, styleKey, x);
           });
-        } else {
-          css = merge(css, breakpointsValues);
+
+          if (objectsHaveSameKeys(breakpointsValues, value)) {
+            css[styleKey] = styleFunctionSx({
+              sx: value,
+              theme: theme
+            });
+          } else {
+            css = merge(css, breakpointsValues);
+          }
         }
+      } else {
+        css = merge(css, getThemeValue(styleKey, value, theme));
       }
-    } else {
-      css = merge(css, getThemeValue(styleKey, value, theme));
-    }
-  });
-  return removeUnusedBreakpoints(breakpointsKeys, css);
+    });
+    return removeUnusedBreakpoints(breakpointsKeys, css);
+  }
+
+  return Array.isArray(sx) ? sx.map(traverse) : traverse(sx);
 }
 
 styleFunctionSx.filterProps = ['sx'];

package/modern/breakpoints.js

@@ -8,12 +8,12 @@ export const values = {
   xs: 0,
   // phone
   sm: 600,
-  // tablets
+  // tablet
   md: 900,
   // small laptop
   lg: 1200,
   // desktop
-  xl: 1536 // large screens
+  xl: 1536 // large screen
 
 };
 const defaultBreakpoints = {
@@ -106,11 +106,41 @@ export function mergeBreakpointsInOrder(breakpointsInput, ...styles) {
   const emptyBreakpoints = createEmptyBreakpointObject(breakpointsInput);
   const mergedOutput = [emptyBreakpoints, ...styles].reduce((prev, next) => deepmerge(prev, next), {});
   return removeUnusedBreakpoints(Object.keys(emptyBreakpoints), mergedOutput);
+} // compute base for responsive values; e.g.,
+// [1,2,3] => {xs: true, sm: true, md: true}
+// {xs: 1, sm: 2, md: 3} => {xs: true, sm: true, md: true}
+
+export function computeBreakpointsBase(breakpointValues, themeBreakpoints) {
+  // fixed value
+  if (typeof breakpointValues !== 'object') {
+    return {};
+  }
+
+  const base = {};
+  const breakpointsKeys = Object.keys(themeBreakpoints);
+
+  if (Array.isArray(breakpointValues)) {
+    breakpointsKeys.forEach((breakpoint, i) => {
+      if (i < breakpointValues.length) {
+        base[breakpoint] = true;
+      }
+    });
+  } else {
+    breakpointsKeys.forEach(breakpoint => {
+      if (breakpointValues[breakpoint] != null) {
+        base[breakpoint] = true;
+      }
+    });
+  }
+
+  return base;
 }
 export function resolveBreakpointValues({
   values: breakpointValues,
-  base
+  breakpoints: themeBreakpoints,
+  base: customBase
 }) {
+  const base = customBase || computeBreakpointsBase(breakpointValues, themeBreakpoints);
   const keys = Object.keys(base);
 
   if (keys.length === 0) {
@@ -118,14 +148,15 @@ export function resolveBreakpointValues({
   }
 
   let previous;
-  return keys.reduce((acc, breakpoint) => {
-    if (typeof breakpointValues === 'object') {
-      acc[breakpoint] = breakpointValues[breakpoint] != null ? breakpointValues[breakpoint] : breakpointValues[previous];
+  return keys.reduce((acc, breakpoint, i) => {
+    if (Array.isArray(breakpointValues)) {
+      acc[breakpoint] = breakpointValues[i] != null ? breakpointValues[i] : breakpointValues[previous];
+      previous = i;
     } else {
-      acc[breakpoint] = breakpointValues;
+      acc[breakpoint] = breakpointValues[breakpoint] != null ? breakpointValues[breakpoint] : breakpointValues[previous] || breakpointValues;
+      previous = breakpoint;
     }
 
-    previous = breakpoint;
     return acc;
   }, {});
 }

package/modern/createBox.js

@@ -10,7 +10,9 @@ import useTheme from './useTheme';
 import { jsx as _jsx } from "react/jsx-runtime";
 export default function createBox(options = {}) {
   const {
-    defaultTheme
+    defaultTheme,
+    defaultClassName = 'MuiBox-root',
+    generateClassName
   } = options;
   const BoxRoot = styled('div')(styleFunctionSx);
   const Box = /*#__PURE__*/React.forwardRef(function Box(inProps, ref) {
@@ -26,7 +28,7 @@ export default function createBox(options = {}) {
     return /*#__PURE__*/_jsx(BoxRoot, _extends({
       as: component,
       ref: ref,
-      className: clsx(className, 'MuiBox-root'),
+      className: clsx(className, generateClassName ? generateClassName(defaultClassName) : defaultClassName),
       theme: theme
     }, other));
   });
@@ -52,7 +54,7 @@ export default function createBox(options = {}) {
     /**
      * @ignore
      */
-    sx: PropTypes.object
+    sx: PropTypes.oneOfType([PropTypes.object, PropTypes.array])
   } : void 0;
   return Box;
 }

package/modern/createTheme/createBreakpoints.js

@@ -13,12 +13,12 @@ export default function createBreakpoints(breakpoints) {
       xs: 0,
       // phone
       sm: 600,
-      // tablets
+      // tablet
       md: 900,
       // small laptop
       lg: 1200,
       // desktop
-      xl: 1536 // large screens
+      xl: 1536 // large screen
 
     },
     unit = 'px',

package/modern/cssVars/createCssVarsProvider.js

@@ -8,37 +8,21 @@ import PropTypes from 'prop-types';
 import { GlobalStyles } from '@mui/styled-engine';
 import { deepmerge } from '@mui/utils';
 import cssVarsParser from './cssVarsParser';
-import getInitColorSchemeScript, { DEFAULT_ATTRIBUTE, DEFAULT_STORAGE_KEY } from './getInitColorSchemeScript';
+import ThemeProvider from '../ThemeProvider';
+import getInitColorSchemeScript, { DEFAULT_ATTRIBUTE, DEFAULT_MODE_STORAGE_KEY } from './getInitColorSchemeScript';
+import useCurrentColorScheme from './useCurrentColorScheme';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
-
-const resolveMode = (key, fallback, supportedColorSchemes) => {
-  if (typeof window === 'undefined') {
-    return undefined;
-  }
-
-  let value;
-
-  try {
-    value = localStorage.getItem(key) || undefined;
-
-    if (!supportedColorSchemes.includes(value)) {
-      value = undefined;
-    }
-  } catch (e) {// Unsupported
-  }
-
-  return value || fallback;
-};
-
-export default function createCssVarsProvider(ThemeContext, options) {
+export default function createCssVarsProvider(options) {
   const {
     theme: baseTheme = {},
+    defaultMode: desisgnSystemMode = 'light',
     defaultColorScheme: designSystemColorScheme,
-    prefix: designSystemPrefix = ''
+    prefix: designSystemPrefix = '',
+    shouldSkipGeneratingVar
   } = options;
 
-  if (!baseTheme.colorSchemes || !baseTheme.colorSchemes[designSystemColorScheme]) {
+  if (!baseTheme.colorSchemes || typeof designSystemColorScheme === 'string' && !baseTheme.colorSchemes[designSystemColorScheme] || typeof designSystemColorScheme === 'object' && !baseTheme.colorSchemes[designSystemColorScheme?.light] || typeof designSystemColorScheme === 'object' && !baseTheme.colorSchemes[designSystemColorScheme?.dark]) {
     console.error(`MUI: \`${designSystemColorScheme}\` does not exist in \`theme.colorSchemes\`.`);
   }
 
@@ -58,8 +42,9 @@ export default function createCssVarsProvider(ThemeContext, options) {
     children,
     theme: themeProp = {},
     prefix = designSystemPrefix,
-    storageKey = DEFAULT_STORAGE_KEY,
+    modeStorageKey = DEFAULT_MODE_STORAGE_KEY,
     attribute = DEFAULT_ATTRIBUTE,
+    defaultMode = desisgnSystemMode,
     defaultColorScheme = designSystemColorScheme
   }) {
     const {
@@ -75,14 +60,44 @@ export default function createCssVarsProvider(ThemeContext, options) {
     let mergedTheme = deepmerge(restBaseTheme, restThemeProp);
     const colorSchemes = deepmerge(baseColorSchemes, colorSchemesProp);
     const allColorSchemes = Object.keys(colorSchemes);
-    const joinedColorSchemes = allColorSchemes.join(',');
-    const [colorScheme, setColorScheme] = React.useState(() => resolveMode(storageKey, defaultColorScheme, allColorSchemes));
-    const resolvedColorScheme = colorScheme || defaultColorScheme;
+    const defaultLightColorScheme = typeof defaultColorScheme === 'string' ? defaultColorScheme : defaultColorScheme.light;
+    const defaultDarkColorScheme = typeof defaultColorScheme === 'string' ? defaultColorScheme : defaultColorScheme.dark;
+    const {
+      mode,
+      setMode,
+      lightColorScheme,
+      darkColorScheme,
+      colorScheme,
+      setColorScheme
+    } = useCurrentColorScheme({
+      supportedColorSchemes: allColorSchemes,
+      defaultLightColorScheme,
+      defaultDarkColorScheme,
+      modeStorageKey,
+      defaultMode
+    });
+
+    const resolvedColorScheme = (() => {
+      if (!colorScheme) {
+        // This scope occurs on the server
+        if (defaultMode === 'dark') {
+          return defaultDarkColorScheme;
+        } // use light color scheme, if default mode is 'light' | 'auto'
+
+
+        return defaultLightColorScheme;
+      }
+
+      return colorScheme;
+    })();
+
     const {
       css: rootCss,
       vars: rootVars
     } = cssVarsParser(mergedTheme, {
-      prefix
+      prefix,
+      basePrefix: designSystemPrefix,
+      shouldSkipGeneratingVar
     });
     mergedTheme = _extends({}, mergedTheme, colorSchemes[resolvedColorScheme], {
       vars: rootVars
@@ -93,15 +108,29 @@ export default function createCssVarsProvider(ThemeContext, options) {
         css,
         vars
       } = cssVarsParser(scheme, {
-        prefix
+        prefix,
+        basePrefix: designSystemPrefix,
+        shouldSkipGeneratingVar
       });
 
       if (key === resolvedColorScheme) {
         mergedTheme.vars = _extends({}, mergedTheme.vars, vars);
       }
 
-      if (key === defaultColorScheme) {
-        styleSheet[':root'] = deepmerge(rootCss, css);
+      const resolvedDefaultColorScheme = (() => {
+        if (typeof defaultColorScheme === 'string') {
+          return defaultColorScheme;
+        }
+
+        if (defaultMode === 'dark') {
+          return defaultColorScheme.dark;
+        }
+
+        return defaultColorScheme.light;
+      })();
+
+      if (key === resolvedDefaultColorScheme) {
+        styleSheet[':root'] = css;
       } else {
         styleSheet[`[${attribute}="${key}"]`] = css;
       }
@@ -109,41 +138,26 @@ export default function createCssVarsProvider(ThemeContext, options) {
     React.useEffect(() => {
       if (colorScheme) {
         document.body.setAttribute(attribute, colorScheme);
-        localStorage.setItem(storageKey, colorScheme);
-      }
-    }, [colorScheme, attribute, storageKey]); // local storage modified in the context of another document
-
-    React.useEffect(() => {
-      const handleStorage = event => {
-        const storageColorScheme = event.newValue;
-
-        if (event.key === storageKey && joinedColorSchemes.match(storageColorScheme)) {
-          if (storageColorScheme) {
-            setColorScheme(storageColorScheme);
-          }
-        }
-      };
-
-      window.addEventListener('storage', handleStorage);
-      return () => window.removeEventListener('storage', handleStorage);
-    }, [setColorScheme, storageKey, joinedColorSchemes]);
-    const wrappedSetColorScheme = React.useCallback(val => {
-      if (typeof val === 'string' && !allColorSchemes.includes(val)) {
-        console.error(`\`${val}\` does not exist in \`theme.colorSchemes\`.`);
-      } else {
-        setColorScheme(val);
       }
-    }, [setColorScheme, allColorSchemes]);
+    }, [colorScheme, attribute]);
     return /*#__PURE__*/_jsxs(ColorSchemeContext.Provider, {
       value: {
+        mode,
+        setMode,
+        lightColorScheme,
+        darkColorScheme,
         colorScheme,
-        setColorScheme: wrappedSetColorScheme,
+        setColorScheme,
         allColorSchemes
       },
       children: [/*#__PURE__*/_jsx(GlobalStyles, {
+        styles: {
+          ':root': rootCss
+        }
+      }), /*#__PURE__*/_jsx(GlobalStyles, {
         styles: styleSheet
-      }), /*#__PURE__*/_jsx(ThemeContext.Provider, {
-        value: mergedTheme,
+      }), /*#__PURE__*/_jsx(ThemeProvider, {
+        theme: mergedTheme,
         children: children
       })]
     });
@@ -163,17 +177,22 @@ export default function createCssVarsProvider(ThemeContext, options) {
     /**
      * The initial color scheme used.
      */
-    defaultColorScheme: PropTypes.string,
+    defaultColorScheme: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
 
     /**
-     * css variable prefix
+     * The initial mode used.
      */
-    prefix: PropTypes.string,
+    defaultMode: PropTypes.string,
 
     /**
      * The key in the local storage used to store current color scheme.
      */
-    storageKey: PropTypes.string,
+    modeStorageKey: PropTypes.string,
+
+    /**
+     * css variable prefix
+     */
+    prefix: PropTypes.string,
 
     /**
      * The calculated theme object that will be passed through context.

package/modern/cssVars/cssVarsParser.js

@@ -1,3 +1,5 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+
 /**
  * This function create an object from keys, value and then assign to target
  *
@@ -50,7 +52,7 @@ export const walkObjectDeep = (obj, callback) => {
         if (typeof value === 'object' && Object.keys(value).length > 0) {
           recurse(value, [...parentKeys, key]);
         } else {
-          callback([...parentKeys, key], value);
+          callback([...parentKeys, key], value, object);
         }
       }
     });
@@ -75,7 +77,16 @@ const getCssValue = (keys, value) => {
  * a function that parse theme and return { css, vars }
  *
  * @param {Object} theme
- * @param {{ prefix?: string }} options
+ * @param {{
+ *  prefix?: string,
+ *  basePrefix?: string,
+ *  shouldSkipGeneratingVar?: (objectPathKeys: Array<string>, value: string | number) => boolean
+ * }} options.
+ *  `basePrefix`: defined by design system.
+ *  `prefix`: defined by application
+ *
+ *   This function also mutate the string value of theme input by replacing `basePrefix` (if existed) with `prefix`
+ *
  * @returns {{ css: Object, vars: Object }} `css` is the stylesheet, `vars` is an object to get css variable (same structure as theme)
  *
  * @example
@@ -90,19 +101,37 @@ const getCssValue = (keys, value) => {
  */
 
 
-export default function cssVarsParser(obj, options) {
+export default function cssVarsParser(theme, options) {
+  const clonedTheme = _extends({}, theme);
+
+  delete clonedTheme.vars; // remove 'vars' from the structure
+
   const {
-    prefix
+    prefix,
+    basePrefix = '',
+    shouldSkipGeneratingVar
   } = options || {};
   const css = {};
   const vars = {};
-  walkObjectDeep(obj, (keys, value) => {
-    if (typeof value === 'string' || typeof value === 'number') {
-      const cssVar = `--${prefix ? `${prefix}-` : ''}${keys.join('-')}`;
-      Object.assign(css, {
-        [cssVar]: getCssValue(keys, value)
-      });
-      assignNestedKeys(vars, keys, `var(${cssVar})`);
+  walkObjectDeep(clonedTheme, (keys, val, scope) => {
+    if (typeof val === 'string' || typeof val === 'number') {
+      let value = val;
+
+      if (typeof value === 'string' && value.startsWith('var')) {
+        // replace the value of the `scope` object with the prefix or remove basePrefix from the value
+        value = prefix ? value.replace(basePrefix, prefix) : value.replace(`${basePrefix}-`, ''); // scope is the deepest object in the tree, keys is the theme path keys
+
+        scope[keys.slice(-1)[0]] = value;
+      }
+
+      if (!shouldSkipGeneratingVar || shouldSkipGeneratingVar && !shouldSkipGeneratingVar(keys, value)) {
+        // only create css & var if `shouldSkipGeneratingVar` return false
+        const cssVar = `--${prefix ? `${prefix}-` : ''}${keys.join('-')}`;
+        Object.assign(css, {
+          [cssVar]: getCssValue(keys, value)
+        });
+        assignNestedKeys(vars, keys, `var(${cssVar})`);
+      }
     }
   });
   return {

package/modern/cssVars/getInitColorSchemeScript.js

@@ -1,17 +1,38 @@
 import * as React from 'react';
 import { jsx as _jsx } from "react/jsx-runtime";
-export const DEFAULT_STORAGE_KEY = 'mui-color-scheme';
+export const DEFAULT_MODE_STORAGE_KEY = 'mui-mode';
+export const DEFAULT_COLOR_SCHEME_STORAGE_KEY = 'mui-color-scheme';
 export const DEFAULT_ATTRIBUTE = 'data-mui-color-scheme';
 export default function getInitColorSchemeScript(options) {
   const {
-    storageKey = DEFAULT_STORAGE_KEY,
+    defaultMode = 'light',
+    defaultLightColorScheme = 'light',
+    defaultDarkColorScheme = 'dark',
+    modeStorageKey = DEFAULT_MODE_STORAGE_KEY,
+    colorSchemeStorageKey = DEFAULT_COLOR_SCHEME_STORAGE_KEY,
     attribute = DEFAULT_ATTRIBUTE
   } = options || {};
   return /*#__PURE__*/_jsx("script", {
     // eslint-disable-next-line react/no-danger
     dangerouslySetInnerHTML: {
       __html: `(function() { try {
-        var colorScheme = localStorage.getItem('${storageKey}');
+        var mode = localStorage.getItem('${modeStorageKey}');
+        var colorScheme = '';
+        if (mode === 'system' || (!mode && ${defaultMode} === 'system')) {
+          // handle system mode
+          var mql = window.matchMedia('(prefers-color-scheme: dark)');
+          if (mql.matches) {
+            colorScheme = localStorage.getItem('${colorSchemeStorageKey}-dark') || ${defaultLightColorScheme};
+          } else {
+            colorScheme = localStorage.getItem('${colorSchemeStorageKey}-light') || ${defaultDarkColorScheme};
+          }
+        }
+        if (mode === 'light') {
+          colorScheme = localStorage.getItem('${colorSchemeStorageKey}-light') || ${defaultLightColorScheme};
+        }
+        if (mode === 'dark') {
+          colorScheme = localStorage.getItem('${colorSchemeStorageKey}-dark') || ${defaultDarkColorScheme};
+        }
         if (colorScheme) {
           document.body.setAttribute('${attribute}', colorScheme);
         }