text: import { deepmerge } from '@material-ui/utils';
  import { generateUtilityClass } from '@material-ui/unstyled';
  import { createTheme as systemCreateTheme } from '@material-ui/system';
  import createMixins from './createMixins';
  import createPalette from './createPalette';
  import createTypography from './createTypography';
  import shadows from './shadows';
  import createTransitions from './createTransitions';
  import zIndex from './zIndex';
  
  function createTheme(options = {}, ...args) {
    const {
      breakpoints: breakpointsInput,
      mixins: mixinsInput = {},
      spacing: spacingInput,
      palette: paletteInput = {},
      transitions: transitionsInput = {},
      typography: typographyInput = {},
      shape: shapeInput,
      ...other
    } = options;
  
    const palette = createPalette(paletteInput);
    const systemTheme = systemCreateTheme(options);
  
    let muiTheme = deepmerge(systemTheme, {
      mixins: createMixins(systemTheme.breakpoints, systemTheme.spacing, mixinsInput),
      palette,
      // Don't use [...shadows] until you've verified its transpiled code is not invoking the iterator protocol.
      shadows: shadows.slice(),
      typography: createTypography(palette, typographyInput),
      transitions: createTransitions(transitionsInput),
      zIndex: { ...zIndex },
    });
  
    muiTheme = deepmerge(muiTheme, other);
    muiTheme = args.reduce((acc, argument) => deepmerge(acc, argument), muiTheme);
  
    if (process.env.NODE_ENV !== 'production') {
      const stateClasses = [
        'active',
        'checked',
        'completed',
        'disabled',
        'error',
        'expanded',
        'focused',
        'focusVisible',
        'required',
        'selected',
      ];
  
      const traverse = (node, component) => {
        let key;
  
        // eslint-disable-next-line guard-for-in, no-restricted-syntax
        for (key in node) {
          const child = node[key];
          if (stateClasses.indexOf(key) !== -1 && Object.keys(child).length > 0) {
            if (process.env.NODE_ENV !== 'production') {
              const stateClass = generateUtilityClass('', key);
              console.error(
                [
                  `Material-UI: The \`${component}\` component increases ` +
                    `the CSS specificity of the \`${key}\` internal state.`,
                  'You can not override it like this: ',
                  JSON.stringify(node, null, 2),
                  '',
                  `Instead, you need to use the '&.${stateClass}' syntax:`,
                  JSON.stringify(
                    {
                      root: {
                        [`&.${stateClass}`]: child,
                      },
                    },
                    null,
                    2,
                  ),
                  '',
                  'https://material-ui.com/r/state-classes-guide',
                ].join('\n'),
              );
            }
            // Remove the style to prevent global conflicts.
            node[key] = {};
          }
        }
      };
  
      Object.keys(muiTheme.components).forEach((component) => {
        const styleOverrides = muiTheme.components[component].styleOverrides;
  
        if (styleOverrides && component.indexOf('Mui') === 0) {
          traverse(styleOverrides, component);
        }
      });
    }
  
    return muiTheme;
  }
  
  let warnedOnce = false;
  
  export function createMuiTheme(...args) {
    if (process.env.NODE_ENV !== 'production') {
      if (!warnedOnce) {
        warnedOnce = true;
        console.error(
          [
            'Material-UI: the createMuiTheme function was renamed to createTheme.',
            '',
            "You should use `import { createTheme } from '@material-ui/core/styles'`",
          ].join('\n'),
        );
      }
    }
  
    return createTheme(...args);
  }
  
  export default createTheme;
  