@mui/x-codemod 9.0.0-alpha.3 → 9.0.0-rc.0

package/util/renameClasses.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renameClasses = renameClasses;
+/**
+ * Renames classes objects and their properties.
+ *
+ * Handles:
+ * - Root imports: `import { lineElementClasses } from '@mui/x-charts'`
+ * - Nested imports: `import { lineElementClasses } from '@mui/x-charts/LineChart'`
+ * - Aliases: `import { lineElementClasses as lec } from '@mui/x-charts'`
+ *   (renames imported name but keeps alias, still renames properties on aliased usage)
+ * - Member expression property renaming: `lineElementClasses.root` → `lineClasses.elementRoot`
+ */
+function renameClasses(parameters) {
+  const {
+    j,
+    root,
+    packageNames
+  } = parameters;
+  const packageRegExp = new RegExp(`^(${packageNames.join('|')})(/.*)?$`);
+
+  // Track local names → old class name, so we can rename properties on aliased usages
+  const localNameToOldClassName = {};
+  // Track non-aliased identifiers that need renaming
+  const renamedIdentifiersMap = {};
+  // Track name already added to the file
+  const alreadyAvailableIdentifiersMap = new Set();
+  const importDeclarations = root.find(j.ImportDeclaration).filter(path => {
+    const pathStr = path.node.source.value?.toString() ?? '';
+    return !!pathStr.match(packageRegExp);
+  });
+
+  // Rename import specifiers and collect local names for property renaming
+  importDeclarations.find(j.ImportSpecifier).filter(path => parameters.classes.hasOwnProperty(path.node.imported.name)).forEach(path => {
+    const oldName = path.node.imported.name;
+    const config = parameters.classes[oldName];
+    const localName = path.node.local?.name;
+    const hasAlias = localName !== oldName;
+
+    // Track the local name for property renaming
+    localNameToOldClassName[hasAlias ? localName : oldName] = oldName;
+    renamedIdentifiersMap[oldName] = config.newClassName;
+    if (!hasAlias && alreadyAvailableIdentifiersMap.has(config.newClassName)) {
+      const importDeclarationCollection = j(path).closest(j.ImportDeclaration);
+      path.prune();
+      if (importDeclarationCollection.length > 0) {
+        const importDeclaration = importDeclarationCollection.nodes()[0];
+        if (importDeclaration.specifiers?.length === 0) {
+          importDeclarationCollection.remove();
+        }
+      }
+      return;
+    }
+    alreadyAvailableIdentifiersMap.add(config.newClassName);
+    if (hasAlias) {
+      // Keep the alias, only rename the imported name
+      path.replace(j.importSpecifier(j.identifier(config.newClassName), j.identifier(localName)));
+    } else {
+      path.replace(j.importSpecifier(j.identifier(config.newClassName)));
+    }
+  });
+
+  // Rename member expression properties (e.g., lineElementClasses.root → lineClasses.elementRoot)
+  root.find(j.MemberExpression).filter(path => {
+    if (path.node.object.type !== 'Identifier') {
+      return false;
+    }
+    const objectName = path.node.object.name;
+    if (!localNameToOldClassName.hasOwnProperty(objectName)) {
+      return false;
+    }
+    if (path.node.property.type !== 'Identifier') {
+      return false;
+    }
+    const oldClassName = localNameToOldClassName[objectName];
+    return parameters.classes[oldClassName].properties.hasOwnProperty(path.node.property.name);
+  }).replaceWith(path => {
+    const objectName = path.node.object.name;
+    const oldPropertyName = path.node.property.name;
+    const oldClassName = localNameToOldClassName[objectName];
+    const newPropertyName = parameters.classes[oldClassName].properties[oldPropertyName];
+    return j.memberExpression(path.node.object, j.identifier(newPropertyName));
+  });
+
+  // Rename identifier usages (non-aliased)
+  root.find(j.Identifier).filter(path => renamedIdentifiersMap.hasOwnProperty(path.node.name)).replaceWith(path => {
+    return j.identifier(renamedIdentifiersMap[path.node.name]);
+  });
+  return root;
+}

package/v9.0.0/charts/preset-safe/index.js

@@ -15,9 +15,13 @@ var replaceHeatmapHideLegend = _interopRequireWildcard(require("../replace-heatm
 var renameSankeyChart = _interopRequireWildcard(require("../rename-sankey-chart"));
 var replaceShowMarkDefault = _interopRequireWildcard(require("../replace-show-mark-default"));
 var removeEnableKeyboardNavigation = _interopRequireWildcard(require("../remove-enable-keyboard-navigation"));
+var removeStabilizedExperimentalFeatures = _interopRequireWildcard(require("../remove-stabilized-experimentalFeatures"));
+var renameVoronoiMaxRadius = _interopRequireWildcard(require("../rename-voronoi-max-radius"));
+var removeDeprecatedSeriesTypes = _interopRequireWildcard(require("../remove-deprecated-series-types"));
+var removeIsBarSeriesHelpers = _interopRequireWildcard(require("../remove-is-bar-series-helpers"));
 const allModules = [
 // Add other transforms here as they are created
-replaceHeatmapHideLegend, replaceShowMarkDefault, removeEnableKeyboardNavigation, renameIdToSeriesId, renameChartApiImport, renameSankeyChart, renameChartContainer, renameChartDataProvider, renameChartZoomSlider];
+replaceHeatmapHideLegend, replaceShowMarkDefault, removeEnableKeyboardNavigation, removeStabilizedExperimentalFeatures, renameIdToSeriesId, renameChartApiImport, renameSankeyChart, renameChartContainer, renameChartDataProvider, renameChartZoomSlider, renameVoronoiMaxRadius, removeDeprecatedSeriesTypes, removeIsBarSeriesHelpers];
 function transformer(file, api, options) {
   allModules.forEach(module => {
     file.source = module.default(file, api, options);

package/v9.0.0/charts/remove-deprecated-series-types/index.js

@@ -0,0 +1,206 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+exports.testConfig = void 0;
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _readFile = _interopRequireDefault(require("../../../util/readFile"));
+// Maps from removed type to the replacement info
+const REMOVED_TYPES = {
+  CartesianSeriesType: {
+    baseType: 'AllSeriesType',
+    genericType: 'CartesianChartSeriesType'
+  },
+  DefaultizedCartesianSeriesType: {
+    baseType: 'DefaultizedSeriesType',
+    genericType: 'CartesianChartSeriesType'
+  },
+  StackableSeriesType: {
+    baseType: 'DefaultizedSeriesType',
+    genericType: 'StackableChartSeriesType'
+  }
+};
+const REMOVED_TYPE_NAMES = Object.keys(REMOVED_TYPES);
+function transformer(file, api, options) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const printOptions = options.printOptions || {
+    quote: 'single',
+    trailingComma: true,
+    wrapColumn: 40
+  };
+
+  // Track local names for removed types and the source they came from
+  const removedTypeLocalNames = {};
+  let originalImportSource = null;
+
+  // Find and remove imports of deprecated types
+  const packageRegex = /^@mui\/x-charts(-pro|-premium)?(\/(models|internals))?$/;
+  root.find(j.ImportDeclaration).forEach(astPath => {
+    const source = astPath.node.source.value?.toString() ?? '';
+    if (!packageRegex.test(source)) {
+      return;
+    }
+    const specifiers = astPath.node.specifiers || [];
+    const remainingSpecifiers = [];
+    specifiers.forEach(specifier => {
+      if (specifier.type === 'ImportSpecifier') {
+        const importedName = specifier.imported.name.toString();
+        if (REMOVED_TYPE_NAMES.includes(importedName)) {
+          // Track the local name used for this import
+          const localName = specifier.local?.name.toString() || importedName;
+          removedTypeLocalNames[localName] = importedName;
+          // Track the original import source (use the first one found)
+          if (!originalImportSource) {
+            originalImportSource = source;
+          }
+        } else {
+          remainingSpecifiers.push(specifier);
+        }
+      } else {
+        remainingSpecifiers.push(specifier);
+      }
+    });
+    if (remainingSpecifiers.length === 0) {
+      // Remove the entire import declaration if no specifiers remain
+      j(astPath).remove();
+    } else if (remainingSpecifiers.length !== specifiers.length) {
+      // Update the import declaration with remaining specifiers
+      astPath.node.specifiers = remainingSpecifiers;
+    }
+  });
+
+  // If no relevant imports were found, return the source unchanged to avoid reformatting
+  if (Object.keys(removedTypeLocalNames).length === 0) {
+    return file.source;
+  }
+
+  // Replace type references with the new types
+  // We need to add the necessary imports if they're not already present
+  const typesToImport = new Set();
+  const genericTypesToImport = new Set();
+  Object.entries(removedTypeLocalNames).forEach(([localName, originalName]) => {
+    const replacementInfo = REMOVED_TYPES[originalName];
+    if (!replacementInfo) {
+      return;
+    }
+
+    // Find all usages of the type as a type reference
+    root.find(j.TSTypeReference).forEach(astPath => {
+      if (astPath.node.typeName.type === 'Identifier' && astPath.node.typeName.name === localName) {
+        typesToImport.add(replacementInfo.baseType);
+        genericTypesToImport.add(replacementInfo.genericType);
+
+        // Replace with the generic type: e.g., AllSeriesType<CartesianChartSeriesType>
+        const newTypeReference = j.tsTypeReference(j.identifier(replacementInfo.baseType), j.tsTypeParameterInstantiation([j.tsTypeReference(j.identifier(replacementInfo.genericType))]));
+        j(astPath).replaceWith(newTypeReference);
+      }
+    });
+  });
+
+  // Helper to check if a type is already imported from a given package pattern
+  const isAlreadyImported = (typeName, sourcePattern) => {
+    return root.find(j.ImportSpecifier, {
+      imported: {
+        name: typeName
+      }
+    }).filter(specPath => {
+      const importDecl = specPath.parentPath.parentPath;
+      const source = importDecl.node.source.value?.toString() ?? '';
+      return sourcePattern.test(source);
+    }).size() > 0;
+  };
+
+  // Collect all types that need to be added to imports
+  const allTypesToAdd = new Set([...typesToImport, ...genericTypesToImport]);
+  const typesToAdd = Array.from(allTypesToAdd).filter(typeName => !isAlreadyImported(typeName, packageRegex));
+
+  // Determine where to add types - use original source or default to same pattern
+  // If original was '@mui/x-charts', add to '@mui/x-charts'
+  // If original was '@mui/x-charts/models', add to '@mui/x-charts/models'
+  const importSource = originalImportSource || '@mui/x-charts/models';
+
+  // Merge duplicate import declarations from the same source before adding new types.
+  // Previous codemods may have split imports, leaving multiple declarations from the same source.
+  const importsBySource = new Map();
+  root.find(j.ImportDeclaration).forEach(astPath => {
+    const source = astPath.node.source.value?.toString() ?? '';
+    if (!packageRegex.test(source)) {
+      return;
+    }
+    if (!importsBySource.has(source)) {
+      importsBySource.set(source, []);
+    }
+    importsBySource.get(source).push(astPath);
+  });
+  importsBySource.forEach(paths => {
+    if (paths.length <= 1) {
+      return;
+    }
+
+    // Collect all specifiers from all declarations, deduplicating by name
+    const allSpecifiers = [];
+    const seenNames = new Set();
+    paths.forEach(importPath => {
+      (importPath.node.specifiers || []).forEach(specifier => {
+        if (specifier.type === 'ImportSpecifier') {
+          const name = specifier.imported.name.toString();
+          if (!seenNames.has(name)) {
+            seenNames.add(name);
+            allSpecifiers.push(specifier);
+          }
+        } else {
+          allSpecifiers.push(specifier);
+        }
+      });
+    });
+
+    // Keep the first declaration with all specifiers, remove the rest
+    paths[0].node.specifiers = allSpecifiers;
+    for (let i = 1; i < paths.length; i += 1) {
+      j(paths[i]).remove();
+    }
+  });
+
+  // Add all replacement types to the same import source as the original
+  if (typesToAdd.length > 0) {
+    const existingImport = root.find(j.ImportDeclaration, {
+      source: {
+        value: importSource
+      }
+    });
+    if (existingImport.size() > 0) {
+      // Add to the existing import
+      const specifiers = existingImport.at(0).get().node.specifiers || [];
+      typesToAdd.forEach(typeName => {
+        specifiers.push(j.importSpecifier(j.identifier(typeName)));
+      });
+    } else {
+      // Create new import
+      const newImport = j.importDeclaration(typesToAdd.map(typeName => j.importSpecifier(j.identifier(typeName))), j.stringLiteral(importSource));
+      const firstImport = root.find(j.ImportDeclaration).at(0);
+      if (firstImport.size() > 0) {
+        firstImport.insertBefore(newImport);
+      } else {
+        root.get().node.program.body.unshift(newImport);
+      }
+    }
+  }
+  return root.toSource(printOptions);
+}
+const testConfig = () => ({
+  name: 'remove-deprecated-series-types',
+  specFiles: [{
+    name: 'root-imports',
+    actual: (0, _readFile.default)(_nodePath.default.join(__dirname, 'actual-root-imports.spec.tsx')),
+    expected: (0, _readFile.default)(_nodePath.default.join(__dirname, 'expected-root-imports.spec.tsx'))
+  }, {
+    name: 'nested-imports',
+    actual: (0, _readFile.default)(_nodePath.default.join(__dirname, 'actual-nested-imports.spec.tsx')),
+    expected: (0, _readFile.default)(_nodePath.default.join(__dirname, 'expected-nested-imports.spec.tsx'))
+  }]
+});
+exports.testConfig = testConfig;

package/v9.0.0/charts/remove-is-bar-series-helpers/index.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+exports.testConfig = void 0;
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _readFile = _interopRequireDefault(require("../../../util/readFile"));
+const REMOVED_FUNCTIONS = ['isBarSeries', 'isDefaultizedBarSeries'];
+function transformer(file, api, options) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const printOptions = options.printOptions || {
+    quote: 'single',
+    trailingComma: true,
+    wrapColumn: 40
+  };
+  const importedFunctions = {};
+
+  // Find and remove imports of isBarSeries and isDefaultizedBarSeries
+  const packageRegex = /^@mui\/x-charts(-pro|-premium)?(\/(models|internals))?$/;
+  root.find(j.ImportDeclaration).forEach(astPath => {
+    const source = astPath.node.source.value?.toString() ?? '';
+    if (!packageRegex.test(source)) {
+      return;
+    }
+    const specifiers = astPath.node.specifiers || [];
+    const remainingSpecifiers = [];
+    specifiers.forEach(specifier => {
+      if (specifier.type === 'ImportSpecifier') {
+        const importedName = specifier.imported.name.toString();
+        if (REMOVED_FUNCTIONS.includes(importedName)) {
+          // Track the local name used for this import
+          const localName = specifier.local?.name.toString() || importedName;
+          importedFunctions[localName] = importedName;
+        } else {
+          remainingSpecifiers.push(specifier);
+        }
+      } else {
+        remainingSpecifiers.push(specifier);
+      }
+    });
+    if (remainingSpecifiers.length === 0) {
+      // Remove the entire import declaration if no specifiers remain
+      j(astPath).remove();
+    } else if (remainingSpecifiers.length !== specifiers.length) {
+      // Update the import declaration with remaining specifiers
+      astPath.node.specifiers = remainingSpecifiers;
+    }
+  });
+
+  // If no relevant imports were found, return the source unchanged to avoid reformatting
+  if (Object.keys(importedFunctions).length === 0) {
+    return file.source;
+  }
+
+  // Replace function calls with series.type === 'bar'
+  // isBarSeries(series) -> series.type === 'bar'
+  // isDefaultizedBarSeries(series) -> series.type === 'bar'
+  Object.keys(importedFunctions).forEach(localName => {
+    root.find(j.CallExpression, {
+      callee: {
+        type: 'Identifier',
+        name: localName
+      }
+    }).replaceWith(astPath => {
+      const args = astPath.node.arguments;
+      if (args.length !== 1) {
+        // If not exactly 1 argument, keep as-is (shouldn't happen)
+        return astPath.node;
+      }
+      const arg = args[0];
+      if (arg.type === 'SpreadElement') {
+        // Can't handle spread elements
+        return astPath.node;
+      }
+
+      // Create: arg.type === 'bar'
+      return j.binaryExpression('===', j.memberExpression(arg, j.identifier('type')), j.stringLiteral('bar'));
+    });
+  });
+  return root.toSource(printOptions);
+}
+const testConfig = () => ({
+  name: 'remove-is-bar-series-helpers',
+  specFiles: [{
+    name: 'root-imports',
+    actual: (0, _readFile.default)(_nodePath.default.join(__dirname, 'actual-root-imports.spec.tsx')),
+    expected: (0, _readFile.default)(_nodePath.default.join(__dirname, 'expected-root-imports.spec.tsx'))
+  }, {
+    name: 'nested-imports',
+    actual: (0, _readFile.default)(_nodePath.default.join(__dirname, 'actual-nested-imports.spec.tsx')),
+    expected: (0, _readFile.default)(_nodePath.default.join(__dirname, 'expected-nested-imports.spec.tsx'))
+  }]
+});
+exports.testConfig = testConfig;

package/v9.0.0/charts/remove-stabilized-experimentalFeatures/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+exports.testConfig = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _removeObjectProperty = _interopRequireDefault(require("../../../util/removeObjectProperty"));
+var _readFile = _interopRequireDefault(require("../../../util/readFile"));
+const componentsNames = ['BarChart', 'LineChart', 'PieChart', 'ScatterChart', 'SparkLineChart', 'RadarChart', 'ChartsContainer', 'ChartsDataProvider', 'BarChartPro', 'LineChartPro', 'PieChartPro', 'ScatterChartPro', 'RadarChartPro', 'FunnelChart', 'Heatmap', 'SankeyChart', 'BarChartPremium', 'HeatmapPremium', 'ChartDataProvider', 'ChartDataProviderPro', 'ChartDataProviderPremium', 'ChartsDataProviderPro', 'ChartsDataProviderPremium'];
+const propName = 'experimentalFeatures';
+const propKeys = ['preferStrictDomainInLineCharts'];
+function transformer(file, api, options) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const printOptions = options.printOptions || {
+    quote: 'single',
+    trailingComma: true
+  };
+  propKeys.forEach(propKey => {
+    (0, _removeObjectProperty.default)({
+      root,
+      j,
+      propName,
+      componentsNames,
+      propKey
+    });
+  });
+  return root.toSource(printOptions);
+}
+const testConfig = () => ({
+  name: 'remove-stabilized-experimentalFeatures',
+  specFiles: [{
+    name: 'remove preferStrictDomainInLineCharts from experimentalFeatures',
+    actual: (0, _readFile.default)(_path.default.join(__dirname, 'actual.spec.tsx')),
+    expected: (0, _readFile.default)(_path.default.join(__dirname, 'expected.spec.tsx'))
+  }]
+});
+exports.testConfig = testConfig;

package/v9.0.0/charts/rename-classes/index.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+exports.testConfig = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _readFile = _interopRequireDefault(require("../../../util/readFile"));
+var _renameClasses = require("../../../util/renameClasses");
+function transformer(file, api, options) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const printOptions = options.printOptions || {
+    quote: 'single',
+    trailingComma: true
+  };
+  (0, _renameClasses.renameClasses)({
+    j,
+    root,
+    packageNames: ['@mui/x-charts', '@mui/x-charts-pro', '@mui/x-charts-premium'],
+    classes: {
+      barElementClasses: {
+        newClassName: 'barClasses',
+        properties: {
+          root: 'element'
+        }
+      },
+      barLabelClasses: {
+        newClassName: 'barClasses',
+        properties: {
+          root: 'label',
+          animate: 'labelAnimate'
+        }
+      },
+      pieArcClasses: {
+        newClassName: 'pieClasses',
+        properties: {
+          root: 'arc'
+        }
+      },
+      pieArcLabelClasses: {
+        newClassName: 'pieClasses',
+        properties: {
+          root: 'arcLabel'
+        }
+      },
+      radarSeriesPlotClasses: {
+        newClassName: 'radarClasses',
+        properties: {
+          root: 'seriesRoot',
+          area: 'seriesArea',
+          mark: 'seriesMark'
+        }
+      },
+      areaElementClasses: {
+        newClassName: 'lineClasses',
+        properties: {
+          root: 'area'
+        }
+      },
+      lineElementClasses: {
+        newClassName: 'lineClasses',
+        properties: {
+          root: 'line'
+        }
+      },
+      markElementClasses: {
+        newClassName: 'lineClasses',
+        properties: {
+          root: 'mark',
+          animate: 'markAnimate'
+        }
+      },
+      lineHighlightElementClasses: {
+        newClassName: 'lineClasses',
+        properties: {
+          root: 'highlight'
+        }
+      },
+      funnelSectionClasses: {
+        newClassName: 'funnelClasses',
+        properties: {
+          root: 'section',
+          filled: 'sectionFilled',
+          outlined: 'sectionOutlined',
+          label: 'sectionLabel'
+        }
+      },
+      sankeyPlotClasses: {
+        newClassName: 'sankeyClasses',
+        properties: {}
+      }
+    }
+  });
+
+  // Classes that had same name as cartesian classes but only for radar charts.
+  (0, _renameClasses.renameClasses)({
+    j,
+    root,
+    packageNames: ['@mui/x-charts/RadarChart', '@mui/x-charts-pro/RadarChart', '@mui/x-charts-premium/RadarChart'],
+    classes: {
+      chartsAxisHighlightClasses: {
+        newClassName: 'radarClasses',
+        properties: {
+          root: 'axisHighlightRoot',
+          line: 'axisHighlightLine',
+          dot: 'axisHighlightDot'
+        }
+      },
+      chartsAxisClasses: {
+        newClassName: 'radarClasses',
+        properties: {
+          root: 'axisRoot',
+          line: 'axisLine',
+          label: 'axisLabel'
+        }
+      },
+      chartsGridClasses: {
+        newClassName: 'radarClasses',
+        properties: {
+          radial: 'gridRadial',
+          divider: 'gridDivider',
+          stripe: 'gridStripe'
+        }
+      }
+    }
+  });
+  return root.toSource(printOptions);
+}
+const testConfig = () => ({
+  name: 'rename-classes',
+  specFiles: [{
+    name: 'rename barElementClasses to barClasses',
+    actual: (0, _readFile.default)(_path.default.join(__dirname, 'actual-imports.spec.tsx')),
+    expected: (0, _readFile.default)(_path.default.join(__dirname, 'expected-imports.spec.tsx'))
+  }, {
+    name: 'rename radar-specific classes only when imported from RadarChart',
+    actual: (0, _readFile.default)(_path.default.join(__dirname, 'actual-radar-imports.spec.tsx')),
+    expected: (0, _readFile.default)(_path.default.join(__dirname, 'expected-radar-imports.spec.tsx'))
+  }, {
+    name: 'do not rename radar-specific classes when imported from root package',
+    actual: (0, _readFile.default)(_path.default.join(__dirname, 'actual-not-radar-imports.spec.tsx')),
+    expected: (0, _readFile.default)(_path.default.join(__dirname, 'expected-not-radar-imports.spec.tsx'))
+  }]
+});
+exports.testConfig = testConfig;

package/v9.0.0/charts/rename-voronoi-max-radius/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+exports.testConfig = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _readFile = _interopRequireDefault(require("../../../util/readFile"));
+var _renameProps = _interopRequireDefault(require("../../../util/renameProps"));
+function transformer(file, api, options) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const printOptions = options.printOptions || {
+    quote: 'single',
+    trailingComma: true
+  };
+  (0, _renameProps.default)({
+    j,
+    root,
+    componentNames: ['ScatterChart', 'ScatterChartPro', 'SparkLineChart', 'ChartsContainer', 'ChartContainer', 'ChartDataProvider', 'ChartsDataProvider', 'ChartDataProviderPro', 'ChartsDataProviderPro', 'ChartDataProviderPremium', 'ChartsDataProviderPremium'],
+    props: {
+      voronoiMaxRadius: 'hitAreaRadius',
+      disableVoronoi: 'disableHitArea'
+    }
+  });
+  return root.toSource(printOptions);
+}
+const testConfig = () => ({
+  name: 'rename-voronoi-max-radius',
+  specFiles: [{
+    name: 'rename voronoiMaxRadius to hitAreaRadius and disableVoronoi to disableHitArea',
+    actual: (0, _readFile.default)(_path.default.join(__dirname, 'actual-imports.spec.tsx')),
+    expected: (0, _readFile.default)(_path.default.join(__dirname, 'expected-imports.spec.tsx'))
+  }]
+});
+exports.testConfig = testConfig;

package/v9.0.0/data-grid/remove-stabilized-experimentalFeatures/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+exports.testConfig = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _removeObjectProperty = _interopRequireDefault(require("../../../util/removeObjectProperty"));
+var _readFile = _interopRequireDefault(require("../../../util/readFile"));
+const componentsNames = ['DataGridPremium'];
+const propName = 'experimentalFeatures';
+const propKeys = ['charts'];
+function transformer(file, api, options) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const printOptions = options.printOptions || {
+    quote: 'single',
+    trailingComma: true
+  };
+  propKeys.forEach(propKey => {
+    (0, _removeObjectProperty.default)({
+      root,
+      j,
+      propName,
+      componentsNames,
+      propKey
+    });
+  });
+  return root.toSource(printOptions);
+}
+const testConfig = () => ({
+  name: 'remove-stabilized-experimentalFeatures',
+  specFiles: [{
+    name: 'remove charts from experimentalFeatures',
+    actual: (0, _readFile.default)(_path.default.join(__dirname, 'actual.spec.tsx')),
+    expected: (0, _readFile.default)(_path.default.join(__dirname, 'expected.spec.tsx'))
+  }]
+});
+exports.testConfig = testConfig;