@mui/codemod 6.4.4 → 6.4.6

package/node/deprecations/tabs-classes/tabs-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\/Tabs$/)).forEach(path => {
+      path.node.specifiers.forEach(specifier => {
+        if (specifier.type === 'ImportSpecifier' && specifier.imported.name === 'tabsClasses') {
+          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('MuiTabs-', '').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), ...(atomicClasses.length > 1 ? [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/tabs-classes/test-cases/actual.js

@@ -0,0 +1,7 @@
+"use strict";
+
+var _Tabs = require("@mui/material/Tabs");
+'&.MuiTabs-flexContainer';
+'&.MuiTabs-flexContainerVertical';
+`&.${_Tabs.tabsClasses.flexContainer}`;
+`&.${_Tabs.tabsClasses.flexContainerVertical}`;

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

@@ -0,0 +1,7 @@
+"use strict";
+
+var _Tabs = require("@mui/material/Tabs");
+"&.MuiTabs-list";
+"&.MuiTabs-list.MuiTabs-vertical";
+`&.${_Tabs.tabsClasses.list}`;
+`&.${_Tabs.tabsClasses.list}.${_Tabs.tabsClasses.vertical}`;

package/node/deprecations/tabs-props/index.js

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

package/node/deprecations/tabs-props/tabs-props.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+var _movePropIntoSlots = _interopRequireDefault(require("../utils/movePropIntoSlots"));
+var _movePropIntoSlotProps = _interopRequireDefault(require("../utils/movePropIntoSlotProps"));
+/**
+ * @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;
+  (0, _movePropIntoSlots.default)(j, {
+    root,
+    componentName: 'Tabs',
+    propName: 'ScrollButtonComponent',
+    slotName: 'scrollButton'
+  });
+  (0, _movePropIntoSlotProps.default)(j, {
+    root,
+    componentName: 'Tabs',
+    propName: 'TabScrollButtonProps',
+    slotName: 'scrollButton'
+  });
+  (0, _movePropIntoSlotProps.default)(j, {
+    root,
+    componentName: 'Tabs',
+    propName: 'TabIndicatorProps',
+    slotName: 'indicator'
+  });
+  return root.toSource(printOptions);
+}

package/node/deprecations/tabs-props/test-cases/actual.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _Tabs = _interopRequireDefault(require("@mui/material/Tabs"));
+var _material = require("@mui/material");
+var _jsxRuntime = require("react/jsx-runtime");
+/*#__PURE__*/(0, _jsxRuntime.jsx)(_Tabs.default, {
+  ScrollButtonComponent: CustomScrollButton,
+  TabScrollButtonProps: {
+    disableRipple: true
+  },
+  TabIndicatorProps: {
+    className: 'indicator'
+  }
+});
+/*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Tabs, {
+  ScrollButtonComponent: CustomScrollButton,
+  TabScrollButtonProps: {
+    disableRipple: true
+  },
+  TabIndicatorProps: {
+    className: 'indicator'
+  }
+});
+/*#__PURE__*/(0, _jsxRuntime.jsx)(CustomTabs, {
+  ScrollButtonComponent: CustomScrollButton,
+  TabScrollButtonProps: {
+    disableRipple: true
+  },
+  TabIndicatorProps: {
+    className: 'indicator'
+  }
+});

package/node/deprecations/tabs-props/test-cases/expected.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _Tabs = _interopRequireDefault(require("@mui/material/Tabs"));
+var _material = require("@mui/material");
+var _jsxRuntime = require("react/jsx-runtime");
+/*#__PURE__*/(0, _jsxRuntime.jsx)(_Tabs.default, {
+  slots: {
+    scrollButton: CustomScrollButton
+  },
+  slotProps: {
+    scrollButton: {
+      disableRipple: true
+    },
+    indicator: {
+      className: 'indicator'
+    }
+  }
+});
+/*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Tabs, {
+  slots: {
+    scrollButton: CustomScrollButton
+  },
+  slotProps: {
+    scrollButton: {
+      disableRipple: true
+    },
+    indicator: {
+      className: 'indicator'
+    }
+  }
+});
+/*#__PURE__*/(0, _jsxRuntime.jsx)(CustomTabs, {
+  ScrollButtonComponent: CustomScrollButton,
+  TabScrollButtonProps: {
+    disableRipple: true
+  },
+  TabIndicatorProps: {
+    className: 'indicator'
+  }
+});

package/node/deprecations/tabs-props/test-cases/theme.actual.js

@@ -0,0 +1,15 @@
+"use strict";
+
+fn({
+  MuiTabs: {
+    defaultProps: {
+      ScrollButtonComponent: CustomScrollButton,
+      TabScrollButtonProps: {
+        disableRipple: true
+      },
+      TabIndicatorProps: {
+        className: 'indicator'
+      }
+    }
+  }
+});

package/node/deprecations/tabs-props/test-cases/theme.expected.js

@@ -0,0 +1,19 @@
+"use strict";
+
+fn({
+  MuiTabs: {
+    defaultProps: {
+      slots: {
+        scrollButton: CustomScrollButton
+      },
+      slotProps: {
+        scrollButton: {
+          disableRipple: true
+        },
+        indicator: {
+          className: 'indicator'
+        }
+      }
+    }
+  }
+});

package/node/deprecations/utils/movePropIntoSlotProps.js

@@ -9,10 +9,11 @@ var _findComponentJSX = _interopRequireDefault(require("../../util/findComponent
 var _findComponentDefaultProps = _interopRequireDefault(require("../../util/findComponentDefaultProps"));
 var _assignObject = _interopRequireDefault(require("../../util/assignObject"));
 var _appendAttribute = _interopRequireDefault(require("../../util/appendAttribute"));
-function moveJsxPropIntoSlotProps(j, element, propName, slotName) {
+function moveJsxPropIntoSlotProps(j, element, propName, slotName, slotPropName) {
   const propIndex = element.openingElement.attributes.findIndex(attr => attr.type === 'JSXAttribute' && attr.name.name === propName);
   if (propIndex !== -1) {
-    const removedValue = element.openingElement.attributes.splice(propIndex, 1)[0].value.expression;
+    const removedAttr = element.openingElement.attributes.splice(propIndex, 1)[0];
+    const removedValue = removedAttr.value.type === 'StringLiteral' ? j.literal(removedAttr.value.value) : removedAttr.value.expression;
     let hasSlotProps = false;
     element.openingElement.attributes.forEach(attr => {
       if (attr.name?.name === 'slotProps') {
@@ -20,31 +21,40 @@ function moveJsxPropIntoSlotProps(j, element, propName, slotName) {
         const slots = attr.value.expression;
         const slotIndex = slots.properties.findIndex(prop => prop?.key?.name === slotName);
         if (slotIndex === -1) {
+          // Create new slot
+          const slotValue = slotPropName ? j.objectExpression([j.objectProperty(j.identifier(slotPropName), removedValue)]) : removedValue;
           (0, _assignObject.default)(j, {
             target: attr,
             key: slotName,
-            expression: removedValue
+            expression: slotValue
           });
         } else {
-          const slotPropsSlotValue = slots.properties.splice(slotIndex, 1)[0].value;
-          (0, _assignObject.default)(j, {
-            target: attr,
-            key: slotName,
-            expression: j.objectExpression([j.spreadElement(removedValue), j.spreadElement(slotPropsSlotValue)])
-          });
+          // Add property to existing slot
+          const existingSlot = slots.properties[slotIndex].value;
+          if (slotPropName) {
+            if (existingSlot.type === 'ObjectExpression') {
+              existingSlot.properties.push(j.objectProperty(j.identifier(slotPropName), removedValue));
+            } else {
+              slots.properties[slotIndex].value = j.objectExpression([j.objectProperty(j.identifier(slotPropName), removedValue)]);
+            }
+          } else {
+            slots.properties[slotIndex].value = j.objectExpression([j.spreadElement(removedValue), j.spreadElement(existingSlot)]);
+          }
         }
       }
     });
     if (!hasSlotProps) {
+      // Create new slotProps
+      const slotValue = slotPropName ? j.objectExpression([j.objectProperty(j.identifier(slotPropName), removedValue)]) : removedValue;
       (0, _appendAttribute.default)(j, {
         target: element,
         attributeName: 'slotProps',
-        expression: j.objectExpression([j.objectProperty(j.identifier(slotName), removedValue)])
+        expression: j.objectExpression([j.objectProperty(j.identifier(slotName), slotValue)])
       });
     }
   }
 }
-function moveDefaultPropsPropIntoslotProps(j, defaultPropsPathCollection, propName, slotName) {
+function moveDefaultPropsPropIntoslotProps(j, defaultPropsPathCollection, propName, slotName, slotPropName) {
   defaultPropsPathCollection.find(j.ObjectProperty, {
     key: {
       name: propName
@@ -58,15 +68,28 @@ function moveDefaultPropsPropIntoslotProps(j, defaultPropsPathCollection, propNa
         hasSlotProps = true;
         const slotIndex = property.value.properties.findIndex(prop => prop?.key?.name === slotName);
         if (slotIndex === -1) {
-          property.value.properties.push(j.objectProperty(j.identifier(slotName), removedValue));
+          // Create new slot
+          const slotValue = slotPropName ? j.objectExpression([j.objectProperty(j.identifier(slotPropName), removedValue)]) : removedValue;
+          property.value.properties.push(j.objectProperty(j.identifier(slotName), slotValue));
         } else {
-          const slotPropsSlotValue = property.value.properties.splice(slotIndex, 1)[0].value;
-          property.value.properties.push(j.objectProperty(j.identifier(slotName), j.objectExpression([j.spreadElement(removedValue), j.spreadElement(slotPropsSlotValue)])));
+          // Add property to existing slot
+          const existingSlot = property.value.properties[slotIndex].value;
+          if (slotPropName) {
+            if (existingSlot.type === 'ObjectExpression') {
+              existingSlot.properties.push(j.objectProperty(j.identifier(slotPropName), removedValue));
+            } else {
+              property.value.properties[slotIndex].value = j.objectExpression([j.objectProperty(j.identifier(slotPropName), removedValue)]);
+            }
+          } else {
+            property.value.properties[slotIndex].value = j.objectExpression([j.spreadElement(removedValue), j.spreadElement(existingSlot)]);
+          }
         }
       }
     });
     if (!hasSlotProps) {
-      defaultProps.properties.push(j.objectProperty(j.identifier('slotProps'), j.objectExpression([j.objectProperty(j.identifier(slotName), removedValue)])));
+      // Create new slotProps
+      const slotValue = slotPropName ? j.objectExpression([j.objectProperty(j.identifier(slotPropName), removedValue)]) : removedValue;
+      defaultProps.properties.push(j.objectProperty(j.identifier('slotProps'), j.objectExpression([j.objectProperty(j.identifier(slotName), slotValue)])));
     }
     path.prune();
   });
@@ -78,26 +101,28 @@ function moveDefaultPropsPropIntoslotProps(j, defaultPropsPathCollection, propNa
  * If there are duplicated values, the values will be spread.
  *
  * @param {import('jscodeshift')} j
- * @param {{ root: import('jscodeshift').Collection; componentName: string, propName: string, slotName: string }} options
+ * @param {{ root: import('jscodeshift').Collection; componentName: string, propName: string, slotName: string, slotPropName?: string }} options
  *
  * @example <Component TransitionProps={value} /> => <Component slotProps={{ transition: value }} />
+ * @example <Component tooltipClasses={classes} /> => <Component slotProps={{ tooltip: { classes: classes } }} />
  */
 function movePropIntoSlotProps(j, options) {
   const {
     root,
     componentName,
     propName,
-    slotName
+    slotName,
+    slotPropName
   } = options;
   (0, _findComponentJSX.default)(j, {
     root,
     componentName
   }, elementPath => {
-    moveJsxPropIntoSlotProps(j, elementPath.node, propName, slotName);
+    moveJsxPropIntoSlotProps(j, elementPath.node, propName, slotName, slotPropName);
   });
   const defaultPropsPathCollection = (0, _findComponentDefaultProps.default)(j, {
     root,
     componentName
   });
-  moveDefaultPropsPropIntoslotProps(j, defaultPropsPathCollection, propName, slotName);
+  moveDefaultPropsPropIntoslotProps(j, defaultPropsPathCollection, propName, slotName, slotPropName);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/codemod",
-  "version": "6.4.4",
+  "version": "6.4.6",
   "bin": "./codemod.js",
   "private": false,
   "author": "MUI Team",