@mui/codemod 6.0.0-alpha.10 → 6.0.0-alpha.12

package/codemod.js

@@ -23,7 +23,6 @@ async function runJscodeshiftTransform(transform, files, flags, codemodFlags) {
 
   let transformerPath;
   let error;
-  // eslint-disable-next-line no-restricted-syntax
   for (const item of paths) {
     try {
       // eslint-disable-next-line no-await-in-loop
@@ -113,7 +112,6 @@ async function runPostcssTransform(transform, files) {
 
   let configPath;
   let error;
-  // eslint-disable-next-line no-restricted-syntax
   for (const item of paths) {
     try {
       // eslint-disable-next-line no-await-in-loop

package/node/deprecations/all/deprecations-all.js

@@ -26,9 +26,11 @@ var _modalProps = _interopRequireDefault(require("../modal-props"));
 var _outlinedInputProps = _interopRequireDefault(require("../outlined-input-props"));
 var _paginationItemClasses = _interopRequireDefault(require("../pagination-item-classes"));
 var _speedDialProps = _interopRequireDefault(require("../speed-dial-props"));
+var _tableSortLabelClasses = _interopRequireDefault(require("../table-sort-label-classes"));
 var _stepConnectorClasses = _interopRequireDefault(require("../step-connector-classes"));
 var _stepLabelProps = _interopRequireDefault(require("../step-label-props"));
 var _textFieldProps = _interopRequireDefault(require("../text-field-props"));
+var _tabClasses = _interopRequireDefault(require("../tab-classes"));
 var _toggleButtonGroupClasses = _interopRequireDefault(require("../toggle-button-group-classes"));
 /**
  * @param {import('jscodeshift').FileInfo} file
@@ -58,7 +60,9 @@ function deprecationsAll(file, api, options) {
   file.source = (0, _speedDialProps.default)(file, api, options);
   file.source = (0, _stepConnectorClasses.default)(file, api, options);
   file.source = (0, _stepLabelProps.default)(file, api, options);
+  file.source = (0, _tableSortLabelClasses.default)(file, api, options);
   file.source = (0, _textFieldProps.default)(file, api, options);
+  file.source = (0, _tabClasses.default)(file, api, options);
   file.source = (0, _toggleButtonGroupClasses.default)(file, api, options);
   return file.source;
 }

package/node/deprecations/all/postcss.config.js

@@ -27,6 +27,12 @@ const {
 const {
   plugin: circularProgressClassesPlugin
 } = require('../circular-progress-classes/postcss-plugin');
+const {
+  plugin: tabClassesPlugin
+} = require('../tab-classes/postcss-plugin');
+const {
+  plugin: tableSortLabelClassesPlugin
+} = require('../table-sort-label-classes/postcss-plugin');
 module.exports = {
-  plugins: [accordionSummaryClassesPlugin, alertClassesPlugin, buttonClassesPlugin, buttonGroupClassesPlugin, chipClassesPlugin, circularProgressClassesPlugin, paginationItemClassesPlugin, stepConnectorClassesPlugin, toggleButtonGroupClassesPlugin]
+  plugins: [accordionSummaryClassesPlugin, alertClassesPlugin, buttonClassesPlugin, buttonGroupClassesPlugin, chipClassesPlugin, circularProgressClassesPlugin, paginationItemClassesPlugin, stepConnectorClassesPlugin, toggleButtonGroupClassesPlugin, tabClassesPlugin, tableSortLabelClassesPlugin]
 };

package/node/deprecations/tab-classes/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _tabClasses.default;
+  }
+});
+var _tabClasses = _interopRequireDefault(require("./tab-classes"));

package/node/deprecations/tab-classes/postcss-plugin.js

@@ -0,0 +1,30 @@
+"use strict";
+
+const classes = [{
+  deprecatedClass: ' .MuiTab-iconWrapper',
+  replacementSelector: ' .MuiTab-icon'
+}];
+const plugin = () => {
+  return {
+    postcssPlugin: `Replace deprecated Tab classes with new classes`,
+    Rule(rule) {
+      const {
+        selector
+      } = rule;
+      classes.forEach(({
+        deprecatedClass,
+        replacementSelector
+      }) => {
+        const selectorRegex = new RegExp(`${deprecatedClass}$`);
+        if (selector.match(selectorRegex)) {
+          rule.selector = selector.replace(selectorRegex, replacementSelector);
+        }
+      });
+    }
+  };
+};
+plugin.postcss = true;
+module.exports = {
+  plugin,
+  classes
+};

package/node/deprecations/tab-classes/postcss.config.js

@@ -0,0 +1,8 @@
+"use strict";
+
+const {
+  plugin
+} = require('./postcss-plugin');
+module.exports = {
+  plugins: [plugin]
+};

package/node/deprecations/tab-classes/tab-classes.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+var _postcssPlugin = require("./postcss-plugin");
+/**
+ * @param {import('jscodeshift').FileInfo} file
+ * @param {import('jscodeshift').API} api
+ */
+function transformer(file, api, options) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const printOptions = options.printOptions;
+  _postcssPlugin.classes.forEach(({
+    deprecatedClass,
+    replacementSelector
+  }) => {
+    const replacementSelectorPrefix = '&';
+    root.find(j.ImportDeclaration).filter(path => path.node.source.value.match(/^@mui\/material\/Tab$/)).forEach(path => {
+      path.node.specifiers.forEach(specifier => {
+        if (specifier.type === 'ImportSpecifier' && specifier.imported.name === 'tabClasses') {
+          const deprecatedAtomicClass = deprecatedClass.replace(`${deprecatedClass.split('-')[0]}-`, '');
+          root.find(j.MemberExpression, {
+            object: {
+              name: specifier.local.name
+            },
+            property: {
+              name: deprecatedAtomicClass
+            }
+          }).forEach(memberExpression => {
+            const parent = memberExpression.parentPath.parentPath.value;
+            if (parent.type === j.TemplateLiteral.name) {
+              const memberExpressionIndex = parent.expressions.findIndex(expression => expression === memberExpression.value);
+              const precedingTemplateElement = parent.quasis[memberExpressionIndex];
+              const atomicClasses = ['icon'];
+              if (precedingTemplateElement.value.raw.endsWith(deprecatedClass.startsWith(' ') ? `${replacementSelectorPrefix} .` : `${replacementSelectorPrefix}.`)) {
+                const atomicClassesArgs = [memberExpressionIndex, 1, ...atomicClasses.map(atomicClass => j.memberExpression(memberExpression.value.object, j.identifier(atomicClass)))];
+                parent.expressions.splice(...atomicClassesArgs);
+              }
+            }
+          });
+        }
+      });
+    });
+    const selectorRegex = new RegExp(`${replacementSelectorPrefix}${deprecatedClass}$`);
+    root.find(j.Literal, literal => typeof literal.value === 'string' && literal.value.match(selectorRegex)).forEach(path => {
+      path.replace(j.literal(path.value.value.replace(selectorRegex, `${replacementSelectorPrefix}${replacementSelector}`)));
+    });
+  });
+  return root.toSource(printOptions);
+}

package/node/deprecations/tab-classes/test-cases/actual.js

@@ -0,0 +1,5 @@
+"use strict";
+
+var _Tab = require("@mui/material/Tab");
+'& .MuiTab-iconWrapper';
+`& .${_Tab.tabClasses.iconWrapper}`;

package/node/deprecations/tab-classes/test-cases/expected.js

@@ -0,0 +1,5 @@
+"use strict";
+
+var _Tab = require("@mui/material/Tab");
+"& .MuiTab-icon";
+`& .${_Tab.tabClasses.icon}`;

package/node/deprecations/table-sort-label-classes/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _tableSortLabelClasses.default;
+  }
+});
+var _tableSortLabelClasses = _interopRequireDefault(require("./table-sort-label-classes"));

package/node/deprecations/table-sort-label-classes/postcss-plugin.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const classes = [{
+  deprecatedClass: ' .MuiTableSortLabel-iconDirectionDesc',
+  replacementSelector: '.MuiTableSortLabel-directionDesc > .MuiTableSortLabel-icon'
+}, {
+  deprecatedClass: ' .MuiTableSortLabel-iconDirectionAsc',
+  replacementSelector: '.MuiTableSortLabel-directionAsc > .MuiTableSortLabel-icon'
+}];
+const plugin = () => {
+  return {
+    postcssPlugin: `Replace deprecated TableSortLabel classes with new classes`,
+    Rule(rule) {
+      const {
+        selector
+      } = rule;
+      classes.forEach(({
+        deprecatedClass,
+        replacementSelector
+      }) => {
+        const selectorRegex = new RegExp(`${deprecatedClass}$`);
+        if (selector.match(selectorRegex)) {
+          rule.selector = selector.replace(selectorRegex, replacementSelector);
+        }
+      });
+    }
+  };
+};
+plugin.postcss = true;
+module.exports = {
+  plugin,
+  classes
+};

package/node/deprecations/table-sort-label-classes/postcss.config.js

@@ -0,0 +1,8 @@
+"use strict";
+
+const {
+  plugin
+} = require('./postcss-plugin');
+module.exports = {
+  plugins: [plugin]
+};

package/node/deprecations/table-sort-label-classes/table-sort-label-classes.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+var _postcssPlugin = require("./postcss-plugin");
+/**
+ * @param {import('jscodeshift').FileInfo} file
+ * @param {import('jscodeshift').API} api
+ */
+function transformer(file, api, options) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const printOptions = options.printOptions;
+  _postcssPlugin.classes.forEach(({
+    deprecatedClass,
+    replacementSelector
+  }) => {
+    const replacementSelectorPrefix = '&';
+    root.find(j.ImportDeclaration).filter(path => path.node.source.value.match(/^@mui\/material\/TableSortLabel$/)).forEach(path => {
+      path.node.specifiers.forEach(specifier => {
+        if (specifier.type === 'ImportSpecifier' && specifier.imported.name === 'tableSortLabelClasses') {
+          const deprecatedAtomicClass = deprecatedClass.replace(`${deprecatedClass.split('-')[0]}-`, '');
+          root.find(j.MemberExpression, {
+            object: {
+              name: specifier.local.name
+            },
+            property: {
+              name: deprecatedAtomicClass
+            }
+          }).forEach(memberExpression => {
+            const parent = memberExpression.parentPath.parentPath.value;
+            if (parent.type === j.TemplateLiteral.name) {
+              const memberExpressionIndex = parent.expressions.findIndex(expression => expression === memberExpression.value);
+              const precedingTemplateElement = parent.quasis[memberExpressionIndex];
+              const atomicClasses = replacementSelector.replaceAll('MuiTableSortLabel-', '').replaceAll(replacementSelectorPrefix, '').replaceAll(' > ', '').split('.').filter(Boolean);
+              if (precedingTemplateElement.value.raw.endsWith(deprecatedClass.startsWith(' ') ? `${replacementSelectorPrefix} .` : `${replacementSelectorPrefix}.`)) {
+                const atomicClassesArgs = [memberExpressionIndex, 1, ...atomicClasses.map(atomicClass => j.memberExpression(memberExpression.value.object, j.identifier(atomicClass)))];
+                parent.expressions.splice(...atomicClassesArgs);
+                if (replacementSelector.includes(' > ')) {
+                  const quasisArgs = [memberExpressionIndex, 1, j.templateElement({
+                    raw: precedingTemplateElement.value.raw.replace(' ', ''),
+                    cooked: precedingTemplateElement.value.cooked.replace(' ', '')
+                  }, false), j.templateElement({
+                    raw: ' > .',
+                    cooked: ' > .'
+                  }, false)];
+                  if (atomicClasses.length === 3) {
+                    quasisArgs.splice(3, 0, j.templateElement({
+                      raw: '.',
+                      cooked: '.'
+                    }, false));
+                  }
+                  parent.quasis.splice(...quasisArgs);
+                } else {
+                  parent.quasis.splice(memberExpressionIndex, 1, j.templateElement({
+                    raw: precedingTemplateElement.value.raw,
+                    cooked: precedingTemplateElement.value.cooked
+                  }, false), j.templateElement({
+                    raw: '.',
+                    cooked: '.'
+                  }, false));
+                }
+              }
+            }
+          });
+        }
+      });
+    });
+    const selectorRegex = new RegExp(`${replacementSelectorPrefix}${deprecatedClass}$`);
+    root.find(j.Literal, literal => typeof literal.value === 'string' && literal.value.match(selectorRegex)).forEach(path => {
+      path.replace(j.literal(path.value.value.replace(selectorRegex, `${replacementSelectorPrefix}${replacementSelector}`)));
+    });
+  });
+  return root.toSource(printOptions);
+}

package/node/deprecations/table-sort-label-classes/test-cases/actual.js

@@ -0,0 +1,7 @@
+"use strict";
+
+var _TableSortLabel = require("@mui/material/TableSortLabel");
+'& .MuiTableSortLabel-iconDirectionDesc';
+'& .MuiTableSortLabel-iconDirectionAsc';
+`& .${_TableSortLabel.tableSortLabelClasses.iconDirectionDesc}`;
+`& .${_TableSortLabel.tableSortLabelClasses.iconDirectionAsc}`;

package/node/deprecations/table-sort-label-classes/test-cases/expected.js

@@ -0,0 +1,7 @@
+"use strict";
+
+var _TableSortLabel = require("@mui/material/TableSortLabel");
+"&.MuiTableSortLabel-directionDesc > .MuiTableSortLabel-icon";
+"&.MuiTableSortLabel-directionAsc > .MuiTableSortLabel-icon";
+`&.${_TableSortLabel.tableSortLabelClasses.directionDesc} > .${_TableSortLabel.tableSortLabelClasses.icon}`;
+`&.${_TableSortLabel.tableSortLabelClasses.directionAsc} > .${_TableSortLabel.tableSortLabelClasses.icon}`;

package/node/util/migrateToVariants.js

@@ -163,6 +163,11 @@ function migrateToVariants(j, styles) {
   const buildArrowFunctionAST = getBuildArrowFunctionAST(j);
   const objectToArrowFunction = getObjectToArrowFunction(j);
 
+  /**
+   * A map of used variable with its original name
+   */
+  const parameterMap = {};
+
   /**
    *
    * @param {import('jscodeshift').Identifier | import('jscodeshift').BinaryExpression | import('jscodeshift').UnaryExpression | import('jscodeshift').MemberExpression} node
@@ -199,6 +204,21 @@ function migrateToVariants(j, styles) {
     });
     return result;
   }
+  function resolveParamName(name) {
+    if (typeof name !== 'string') {
+      if (name.type === 'Identifier' && parameterMap[name.name]) {
+        if (parameterMap[name.name].includes('-')) {
+          return j.stringLiteral(parameterMap[name.name]);
+        }
+        return {
+          ...name,
+          name: parameterMap[name.name]
+        };
+      }
+      return name;
+    }
+    return parameterMap[name] || name;
+  }
 
   /**
    *
@@ -213,25 +233,25 @@ function migrateToVariants(j, styles) {
     };
     function assignProperties(_node) {
       if (_node.type === 'BinaryExpression') {
-        variables.add(getObjectKey(_node.left).name);
+        variables.add(resolveParamName(getObjectKey(_node.left).name));
         if (_node.operator === '===') {
-          properties.push(j.objectProperty(getIdentifierKey(_node.left), _node.right));
+          properties.push(j.objectProperty(resolveParamName(getIdentifierKey(_node.left)), _node.right));
         } else {
           isAllEqual = false;
         }
       }
       if (_node.type === 'MemberExpression' || _node.type === 'Identifier') {
         isAllEqual = false;
-        variables.add(getObjectKey(_node).name);
+        variables.add(resolveParamName(getObjectKey(_node).name));
       }
       if (_node.type === 'UnaryExpression') {
         isAllEqual = false;
         if (_node.argument.type === 'UnaryExpression') {
           // handle `!!variable`
-          variables.add(getObjectKey(_node.argument.argument).name);
+          variables.add(resolveParamName(getObjectKey(_node.argument.argument).name));
         } else {
           // handle `!variable`
-          variables.add(getObjectKey(_node.argument).name);
+          variables.add(resolveParamName(getObjectKey(_node.argument).name));
         }
       }
     }
@@ -267,7 +287,7 @@ function migrateToVariants(j, styles) {
     const currentArrow = currentProps.type === 'ObjectExpression' ? objectToArrowFunction(currentProps) : currentProps;
     const variables = new Set();
     [...parentArrow.params[0].properties, ...currentArrow.params[0].properties].forEach(param => {
-      variables.add(param.key.name);
+      variables.add(resolveParamName(param.key.name));
     });
     return buildArrowFunctionAST(variables, j.logicalExpression('&&', parentArrow.body, currentArrow.body));
   }
@@ -278,7 +298,24 @@ function migrateToVariants(j, styles) {
     style.params.forEach(param => {
       if (param.type === 'ObjectPattern') {
         param.properties.forEach(prop => {
-          parameters.add(prop.key.name);
+          if (prop.type === 'ObjectProperty') {
+            let paramName;
+            if (prop.value.type === 'Identifier') {
+              paramName = prop.value.name;
+            }
+            if (prop.value.type === 'AssignmentPattern') {
+              paramName = prop.value.left.name;
+            }
+            if (paramName) {
+              parameters.add(paramName);
+              if (prop.key.type === 'Identifier') {
+                parameterMap[paramName] = prop.key.name;
+              }
+              if (prop.key.type === 'StringLiteral') {
+                parameterMap[paramName] = prop.key.value;
+              }
+            }
+          }
         });
       }
       if (param.type === 'Identifier') {
@@ -294,25 +331,32 @@ function migrateToVariants(j, styles) {
     } else if (style.body.type === 'ConditionalExpression') {
       // skip ConditionalExpression
     } else {
-      let objectExpression = style.body;
-      let counter = 0;
-      while (objectExpression.type !== 'ObjectExpression' && counter < MAX_DEPTH) {
-        counter += 1;
-        if (objectExpression.type === 'BlockStatement') {
-          objectExpression = objectExpression.body.find(item => item.type === 'ReturnStatement').argument;
-        }
+      const expressions = [];
+      if (style.body.type === 'ArrayExpression') {
+        expressions.push(...style.body.elements);
+      } else {
+        expressions.push(style.body);
       }
-      recurseObjectExpression({
-        node: objectExpression,
-        buildStyle: createBuildStyle()
+      expressions.forEach(objectExpression => {
+        let counter = 0;
+        while (objectExpression.type !== 'ObjectExpression' && counter < MAX_DEPTH) {
+          counter += 1;
+          if (objectExpression.type === 'BlockStatement') {
+            objectExpression = objectExpression.body.find(item => item.type === 'ReturnStatement').argument;
+          }
+        }
+        recurseObjectExpression({
+          node: objectExpression,
+          buildStyle: createBuildStyle()
+        });
+        if (variants.length && objectExpression.type === 'ObjectExpression') {
+          objectExpression.properties.push(j.objectProperty(j.identifier('variants'), j.arrayExpression(variants.filter(variant => {
+            const props = variant.properties.find(prop => prop.key.name === 'props');
+            const styleVal = variant.properties.find(prop => prop.key.name === 'style');
+            return props && styleVal && (!styleVal.value.properties || styleVal.value.properties.length > 0) && (props.value.type === 'ArrowFunctionExpression' || props.value.properties.length > 0);
+          }))));
+        }
       });
-      if (variants.length) {
-        objectExpression.properties.push(j.objectProperty(j.identifier('variants'), j.arrayExpression(variants.filter(variant => {
-          const props = variant.properties.find(prop => prop.key.name === 'props');
-          const styleVal = variant.properties.find(prop => prop.key.name === 'style');
-          return props && styleVal && (!styleVal.value.properties || styleVal.value.properties.length > 0) && (props.value.type === 'ArrowFunctionExpression' || props.value.properties.length > 0);
-        }))));
-      }
     }
     function recurseObjectExpression(data) {
       if (data.node.type === 'ObjectExpression') {
@@ -440,7 +484,6 @@ function migrateToVariants(j, styles) {
             leftName = (_getObjectKey5 = getObjectKey(data.node.test.argument)) == null ? void 0 : _getObjectKey5.name;
           }
           if (parameters.has(leftName) && leftName !== 'theme') {
-            var _data$parentNode;
             let props = buildProps(data.node.test);
             if (data.props) {
               props = mergeProps(data.props, props);
@@ -451,32 +494,37 @@ function migrateToVariants(j, styles) {
               style: styleVal
             };
             variants.push(buildObjectAST(variant));
-
-            // create another variant with inverted condition
-            let props2 = buildProps(inverseBinaryExpression(data.node.test));
-            if (data.props) {
-              props2 = mergeProps(data.props, props2);
-            }
-            const styleVal2 = data.buildStyle(data.node.alternate);
-            const variant2 = {
-              props: props2,
-              style: styleVal2
-            };
-            variants.push(buildObjectAST(variant2));
-            if (((_data$parentNode = data.parentNode) == null ? void 0 : _data$parentNode.type) === 'ObjectExpression') {
-              removeProperty(data.parentNode, data.node);
+            if (data.node.consequent.type === 'ObjectExpression' && data.node.alternate.type === 'ObjectExpression') {
+              var _data$parentNode;
+              // create another variant with inverted condition
+              let props2 = buildProps(inverseBinaryExpression(data.node.test));
+              if (data.props) {
+                props2 = mergeProps(data.props, props2);
+              }
+              const styleVal2 = data.buildStyle(data.node.alternate);
+              const variant2 = {
+                props: props2,
+                style: styleVal2
+              };
+              variants.push(buildObjectAST(variant2));
+              if (((_data$parentNode = data.parentNode) == null ? void 0 : _data$parentNode.type) === 'ObjectExpression') {
+                removeProperty(data.parentNode, data.node);
+              }
+            } else {
+              var _data$replaceValue;
+              (_data$replaceValue = data.replaceValue) == null || _data$replaceValue.call(data, data.node.alternate);
             }
           }
           if (leftName === 'theme' && ((_data$parentNode2 = data.parentNode) == null ? void 0 : _data$parentNode2.type) === 'ObjectExpression' && ((_data$node$test = data.node.test) == null ? void 0 : _data$node$test.type) === 'BinaryExpression' && isThemePaletteMode(data.node.test.left)) {
             if (data.node.consequent.type !== 'ObjectExpression' && data.node.alternate.type !== 'ObjectExpression') {
-              var _data$replaceValue;
+              var _data$replaceValue2;
               if (data.modeStyles) {
                 if (!data.modeStyles[data.node.test.right.value]) {
                   data.modeStyles[data.node.test.right.value] = [];
                 }
                 data.modeStyles[data.node.test.right.value].push(j.objectProperty(data.key, data.node.consequent));
               }
-              (_data$replaceValue = data.replaceValue) == null || _data$replaceValue.call(data, data.node.alternate);
+              (_data$replaceValue2 = data.replaceValue) == null || _data$replaceValue2.call(data, data.node.alternate);
             }
           }
         }
@@ -512,10 +560,10 @@ function migrateToVariants(j, styles) {
               data.modeStyles[mode].push(j.objectProperty(data.key, clonedNode));
             });
             if (data.key) {
-              var _data$replaceValue2;
+              var _data$replaceValue3;
               // to remove the arrow function
               // { ...: theme => `1px solid...` } to { ...: `1px solid...` }
-              (_data$replaceValue2 = data.replaceValue) == null || _data$replaceValue2.call(data, data.node);
+              (_data$replaceValue3 = data.replaceValue) == null || _data$replaceValue3.call(data, data.node);
             }
           }
         }

package/node/v6.0.0/styled/test-cases/ConditionalStyled.expected.js

@@ -18,6 +18,7 @@ const LinearProgressBar1 = styled('span', {
       variant: 'buffer'
     },
     style: {
+      backgroundColor: (theme.vars || theme).palette[ownerState.color].light,
       '&:hover': {}
     }
   }, {
@@ -28,14 +29,6 @@ const LinearProgressBar1 = styled('span', {
     style: {
       backgroundColor: 'currentColor'
     }
-  }, {
-    props: {
-      variant: 'buffer',
-      color: 'normal'
-    },
-    style: {
-      backgroundColor: (theme.vars || theme).palette[ownerState.color].light
-    }
   }, {
     props: ({
       variant,
@@ -58,18 +51,18 @@ const LinearProgressBar1 = styled('span', {
     }
   }, {
     props: ({
-      ownerState,
-      color
-    }) => ownerState.variant !== 'buffer' && color === 'inherit',
+      ownerState
+    }) => ownerState.variant !== 'buffer',
     style: {
-      backgroundColor: 'currentColor'
+      backgroundColor: (theme.vars || theme).palette[ownerState.color].main
     }
   }, {
     props: ({
-      ownerState
-    }) => ownerState.variant !== 'buffer' && ownerState.color !== 'inherit',
+      ownerState,
+      color
+    }) => ownerState.variant !== 'buffer' && color === 'inherit',
     style: {
-      backgroundColor: (theme.vars || theme).palette[ownerState.color].main
+      backgroundColor: 'currentColor'
     }
   }]
 }));
@@ -84,6 +77,7 @@ const ExpandMore = styled(props => {
 })(({
   theme
 }) => ({
+  transform: 'rotate(180deg)',
   marginLeft: 'auto',
   transition: theme.transitions.create('transform', {
     duration: theme.transitions.duration.shortest
@@ -95,13 +89,6 @@ const ExpandMore = styled(props => {
     style: {
       transform: 'rotate(0deg)'
     }
-  }, {
-    props: ({
-      expand
-    }) => !!expand,
-    style: {
-      transform: 'rotate(180deg)'
-    }
   }]
 }));
 const Main = styled('main', {

package/node/v6.0.0/styled/test-cases/DynamicPropsStyled.actual.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _styles = require("@mui/material/styles");
+const DemoToolbarRoot = (0, _styles.styled)('div', {
+  shouldForwardProp: prop => prop !== 'demoOptions' && prop !== 'openDemoSource'
+})(({
+  theme,
+  demoOptions,
+  openDemoSource
+}) => [{
+  display: 'none',
+  [theme.breakpoints.up('sm')]: {
+    top: 0,
+    maxHeight: 50,
+    display: 'block',
+    marginTop: demoOptions.bg === 'inline' ? theme.spacing(1) : -1,
+    padding: theme.spacing(0.5, 1),
+    border: `1px solid ${(theme.vars || theme).palette.divider}`,
+    borderTopWidth: demoOptions.bg === 'inline' ? 1 : 0,
+    backgroundColor: (0, _styles.alpha)(theme.palette.grey[50], 0.2),
+    borderRadius: openDemoSource ? 0 : '0 0 12px 12px',
+    transition: theme.transitions.create('border-radius'),
+    ...(theme.direction === 'rtl' && {
+      left: theme.spacing(1)
+    }),
+    ...(theme.direction !== 'rtl' && {
+      right: theme.spacing(1)
+    })
+  }
+}, theme.applyDarkStyles({
+  [theme.breakpoints.up('sm')]: {
+    backgroundColor: (0, _styles.alpha)(theme.palette.primaryDark[800], 0.2)
+  }
+})]);
+var _default = exports.default = DemoToolbarRoot;