@mui/x-charts 7.0.0-beta.0 → 7.0.0-beta.2

package/legacy/ChartsOnAxisClickHandler/ChartsOnAxisClickHandler.js

@@ -0,0 +1,75 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { SVGContext } from '../context/DrawingProvider';
+import { InteractionContext } from '../context/InteractionProvider';
+import { CartesianContext } from '../context/CartesianContextProvider';
+import { SeriesContext } from '../context/SeriesContextProvider';
+import { jsx as _jsx } from "react/jsx-runtime";
+function ChartsOnAxisClickHandler(props) {
+  var onAxisClick = props.onAxisClick;
+  var svgRef = React.useContext(SVGContext);
+  var series = React.useContext(SeriesContext);
+  var _React$useContext = React.useContext(InteractionContext),
+    axis = _React$useContext.axis;
+  var _React$useContext2 = React.useContext(CartesianContext),
+    xAxisIds = _React$useContext2.xAxisIds,
+    xAxis = _React$useContext2.xAxis,
+    yAxisIds = _React$useContext2.yAxisIds,
+    yAxis = _React$useContext2.yAxis;
+  React.useEffect(function () {
+    var element = svgRef.current;
+    if (element === null || !onAxisClick) {
+      return function () {};
+    }
+    var handleMouseClick = function handleMouseClick(event) {
+      var _USED_AXIS_ID$data;
+      event.preventDefault();
+      var isXaxis = (axis.x && axis.x.index) !== undefined;
+      var USED_AXIS_ID = isXaxis ? xAxisIds[0] : yAxisIds[0];
+      var dataIndex = isXaxis ? axis.x && axis.x.index : axis.y && axis.y.index;
+      if (dataIndex == null) {
+        return;
+      }
+      var seriesValues = {};
+      Object.keys(series).filter(function (seriesType) {
+        return ['bar', 'line'].includes(seriesType);
+      }).forEach(function (seriesType) {
+        var _series$seriesType;
+        (_series$seriesType = series[seriesType]) == null || _series$seriesType.seriesOrder.forEach(function (seriesId) {
+          var seriesItem = series[seriesType].series[seriesId];
+          var axisKey = isXaxis ? seriesItem.xAxisKey : seriesItem.yAxisKey;
+          if (axisKey === undefined || axisKey === USED_AXIS_ID) {
+            seriesValues[seriesId] = seriesItem.data[dataIndex];
+          }
+        });
+      });
+      var axisValue = (_USED_AXIS_ID$data = (isXaxis ? xAxis : yAxis)[USED_AXIS_ID].data) == null ? void 0 : _USED_AXIS_ID$data[dataIndex];
+      onAxisClick(event, {
+        dataIndex: dataIndex,
+        axisValue: axisValue,
+        seriesValues: seriesValues
+      });
+    };
+    element.addEventListener('click', handleMouseClick);
+    return function () {
+      element.removeEventListener('click', handleMouseClick);
+    };
+  }, [axis.x, axis.y, onAxisClick, series, svgRef, xAxis, xAxisIds, yAxis, yAxisIds]);
+
+  // eslint-disable-next-line react/jsx-no-useless-fragment
+  return /*#__PURE__*/_jsx(React.Fragment, {});
+}
+process.env.NODE_ENV !== "production" ? ChartsOnAxisClickHandler.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The function called for onClick events.
+   * The second argument contains information about all line/bar elements at the current mouse position.
+   * @param {MouseEvent} event The mouse event recorded on the `<svg/>` element.
+   * @param {null | AxisData} data The data about the clicked axis and items associated with it.
+   */
+  onAxisClick: PropTypes.func
+} : void 0;
+export { ChartsOnAxisClickHandler };

package/legacy/ChartsOnAxisClickHandler/index.js

@@ -0,0 +1 @@
+export * from './ChartsOnAxisClickHandler';

package/legacy/ChartsReferenceLine/ChartsReferenceLine.js

@@ -8,7 +8,7 @@ function ChartsReferenceLine(props) {
   var x = props.x,
     y = props.y;
   if (x !== undefined && y !== undefined) {
-    throw new Error('MUI X Charts: The ChartsReferenceLine can not have both `x` and `y` props set.');
+    throw new Error('MUI X Charts: The ChartsReferenceLine cannot have both `x` and `y` props set.');
   }
   if (x === undefined && y === undefined) {
     throw new Error('MUI X Charts: The ChartsReferenceLine should have a value in `x` or `y` prop.');
@@ -27,7 +27,7 @@ process.env.NODE_ENV !== "production" ? ChartsReferenceLine.propTypes = {
    * The id of the axis used for the reference value.
    * @default The `id` of the first defined axis.
    */
-  axisId: PropTypes.string,
+  axisId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
   /**
    * Override or extend the styles applied to the component.
    */

package/legacy/ChartsReferenceLine/ChartsXReferenceLine.js

@@ -70,7 +70,7 @@ function ChartsXReferenceLine(props) {
     if (process.env.NODE_ENV !== 'production') {
       if (!warnedOnce) {
         warnedOnce = true;
-        console.error("MUI X: the value ".concat(x, " does not exist in the data of x axis with id ").concat(axisId, "."));
+        console.error("MUI X Charts: the value ".concat(x, " does not exist in the data of x axis with id ").concat(axisId, "."));
       }
     }
     return null;

package/legacy/ChartsReferenceLine/ChartsYReferenceLine.js

@@ -70,7 +70,7 @@ function ChartsYReferenceLine(props) {
     if (process.env.NODE_ENV !== 'production') {
       if (!warnedOnce) {
         warnedOnce = true;
-        console.error("MUI X: the value ".concat(y, " does not exist in the data of y axis with id ").concat(axisId, "."));
+        console.error("MUI X Charts: the value ".concat(y, " does not exist in the data of y axis with id ").concat(axisId, "."));
       }
     }
     return null;

package/legacy/ChartsTooltip/ChartsAxisTooltipContent.js

@@ -5,6 +5,7 @@ import { useSlotProps } from '@mui/base/utils';
 import { SeriesContext } from '../context/SeriesContextProvider';
 import { CartesianContext } from '../context/CartesianContextProvider';
 import { DefaultChartsAxisTooltipContent } from './DefaultChartsAxisTooltipContent';
+import { isCartesianSeriesType } from './utils';
 import { jsx as _jsx } from "react/jsx-runtime";
 function ChartsAxisTooltipContent(props) {
   var content = props.content,
@@ -24,9 +25,7 @@ function ChartsAxisTooltipContent(props) {
   var USED_AXIS_ID = isXaxis ? xAxisIds[0] : yAxisIds[0];
   var relevantSeries = React.useMemo(function () {
     var rep = [];
-    Object.keys(series).filter(function (seriesType) {
-      return ['bar', 'line', 'scatter'].includes(seriesType);
-    }).forEach(function (seriesType) {
+    Object.keys(series).filter(isCartesianSeriesType).forEach(function (seriesType) {
       series[seriesType].seriesOrder.forEach(function (seriesId) {
         var item = series[seriesType].series[seriesId];
         var axisKey = isXaxis ? item.xAxisKey : item.yAxisKey;
@@ -65,11 +64,11 @@ process.env.NODE_ENV !== "production" ? ChartsAxisTooltipContent.propTypes = {
   axisData: PropTypes.shape({
     x: PropTypes.shape({
       index: PropTypes.number,
-      value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired
+      value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.string]).isRequired
     }),
     y: PropTypes.shape({
       index: PropTypes.number,
-      value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired
+      value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.string]).isRequired
     })
   }).isRequired,
   classes: PropTypes.object.isRequired,
@@ -79,11 +78,11 @@ process.env.NODE_ENV !== "production" ? ChartsAxisTooltipContent.propTypes = {
     axisData: PropTypes.shape({
       x: PropTypes.shape({
         index: PropTypes.number,
-        value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired
+        value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.string]).isRequired
       }),
       y: PropTypes.shape({
         index: PropTypes.number,
-        value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired
+        value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.string]).isRequired
       })
     }),
     axisValue: PropTypes.any,

package/legacy/ChartsTooltip/ChartsItemTooltipContent.js

@@ -37,7 +37,7 @@ process.env.NODE_ENV !== "production" ? ChartsItemTooltipContent.propTypes = {
     classes: PropTypes.object,
     itemData: PropTypes.shape({
       dataIndex: PropTypes.number,
-      seriesId: PropTypes.string.isRequired,
+      seriesId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
       type: PropTypes.oneOf(['bar', 'line', 'pie', 'scatter']).isRequired
     }),
     series: PropTypes.object,
@@ -45,7 +45,7 @@ process.env.NODE_ENV !== "production" ? ChartsItemTooltipContent.propTypes = {
   }),
   itemData: PropTypes.shape({
     dataIndex: PropTypes.number,
-    seriesId: PropTypes.string.isRequired,
+    seriesId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
     type: PropTypes.oneOf(['bar', 'line', 'pie', 'scatter']).isRequired
   }).isRequired,
   sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])

package/legacy/ChartsTooltip/DefaultChartsAxisTooltipContent.js

@@ -3,6 +3,7 @@ import PropTypes from 'prop-types';
 import clsx from 'clsx';
 import Typography from '@mui/material/Typography';
 import { ChartsTooltipCell, ChartsTooltipPaper, ChartsTooltipTable, ChartsTooltipMark, ChartsTooltipRow } from './ChartsTooltipTable';
+import { isCartesianSeries, utcFormatter } from './utils';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 function DefaultChartsAxisTooltipContent(props) {
@@ -17,7 +18,7 @@ function DefaultChartsAxisTooltipContent(props) {
     return null;
   }
   var axisFormatter = (_axis$valueFormatter = axis.valueFormatter) != null ? _axis$valueFormatter : function (v) {
-    return v.toLocaleString();
+    return axis.scaleType === 'utc' ? utcFormatter(v) : v.toLocaleString();
   };
   return /*#__PURE__*/_jsx(ChartsTooltipPaper, {
     sx: sx,
@@ -34,13 +35,15 @@ function DefaultChartsAxisTooltipContent(props) {
           })
         })
       }), /*#__PURE__*/_jsx("tbody", {
-        children: series.map(function (_ref) {
+        children: series.filter(isCartesianSeries).map(function (_ref) {
+          var _data$dataIndex;
           var color = _ref.color,
             id = _ref.id,
             label = _ref.label,
             valueFormatter = _ref.valueFormatter,
             data = _ref.data;
-          var formattedValue = valueFormatter(data[dataIndex]);
+          // @ts-ignore
+          var formattedValue = valueFormatter((_data$dataIndex = data[dataIndex]) != null ? _data$dataIndex : null);
           if (formattedValue == null) {
             return null;
           }
@@ -87,11 +90,11 @@ process.env.NODE_ENV !== "production" ? DefaultChartsAxisTooltipContent.propType
   axisData: PropTypes.shape({
     x: PropTypes.shape({
       index: PropTypes.number,
-      value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired
+      value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.string]).isRequired
     }),
     y: PropTypes.shape({
       index: PropTypes.number,
-      value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired
+      value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.string]).isRequired
     })
   }).isRequired,
   /**

package/legacy/ChartsTooltip/DefaultChartsItemTooltipContent.js

@@ -66,7 +66,7 @@ process.env.NODE_ENV !== "production" ? DefaultChartsItemTooltipContent.propType
    */
   itemData: PropTypes.shape({
     dataIndex: PropTypes.number,
-    seriesId: PropTypes.string.isRequired,
+    seriesId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
     type: PropTypes.oneOf(['bar', 'line', 'pie', 'scatter']).isRequired
   }).isRequired,
   /**

package/legacy/ChartsTooltip/utils.js

@@ -88,4 +88,16 @@ export function getTooltipHasData(trigger, displayedData) {
   var hasAxisXData = displayedData.x !== null;
   var hasAxisYData = displayedData.y !== null;
   return hasAxisXData || hasAxisYData;
+}
+export function isCartesianSeriesType(seriesType) {
+  return ['bar', 'line', 'scatter'].includes(seriesType);
+}
+export function isCartesianSeries(series) {
+  return isCartesianSeriesType(series.type);
+}
+export function utcFormatter(v) {
+  if (v instanceof Date) {
+    return v.toUTCString();
+  }
+  return v.toLocaleString();
 }

package/legacy/ChartsVoronoiHandler/ChartsVoronoiHandler.js

@@ -11,7 +11,8 @@ import { getSVGPoint } from '../internals/utils';
 import { jsx as _jsx } from "react/jsx-runtime";
 function ChartsVoronoiHandler(props) {
   var _React$useContext$sca;
-  var voronoiMaxRadius = props.voronoiMaxRadius;
+  var voronoiMaxRadius = props.voronoiMaxRadius,
+    onItemClick = props.onItemClick;
   var svgRef = React.useContext(SVGContext);
   var _React$useContext = React.useContext(DrawingContext),
     width = _React$useContext.width,
@@ -44,6 +45,8 @@ function ChartsVoronoiHandler(props) {
     };
   }, [dispatch]);
   useEnhancedEffect(function () {
+    // This effect generate and store the Delaunay object that's used to map coordinate to closest point.
+
     if (seriesOrder === undefined || series === undefined) {
       // If there is no scatter chart series
       return;
@@ -77,81 +80,122 @@ function ChartsVoronoiHandler(props) {
     if (element === null) {
       return undefined;
     }
-    var handleMouseOut = function handleMouseOut() {
-      dispatch({
-        type: 'exitChart'
-      });
-    };
 
     // TODO: A perf optimisation of voronoi could be to use the last point as the intial point for the next search.
-    var handleMouseMove = function handleMouseMove(event) {
+    function getClosestPoint(event) {
       var _voronoiRef$current$d;
       // Get mouse coordinate in global SVG space
       var svgPoint = getSVGPoint(svgRef.current, event);
       var outsideX = svgPoint.x < left || svgPoint.x > left + width;
       var outsideY = svgPoint.y < top || svgPoint.y > top + height;
       if (outsideX || outsideY) {
-        dispatch({
-          type: 'exitChart'
-        });
-        return;
+        return 'outside-chart';
       }
       if (!voronoiRef.current.delauney) {
-        return;
+        return 'no-point-found';
       }
       var closestPointIndex = (_voronoiRef$current$d = voronoiRef.current.delauney) == null ? void 0 : _voronoiRef$current$d.find(svgPoint.x, svgPoint.y);
-      if (closestPointIndex !== undefined) {
-        var seriesId = Object.keys(voronoiRef.current).find(function (id) {
-          if (id === 'delauney') {
-            return false;
-          }
-          return 2 * closestPointIndex >= voronoiRef.current[id].startIndex && 2 * closestPointIndex < voronoiRef.current[id].endIndex;
-        });
-        if (seriesId === undefined) {
-          return;
+      if (closestPointIndex === undefined) {
+        return 'no-point-found';
+      }
+      var seriesId = Object.keys(voronoiRef.current).find(function (id) {
+        if (id === 'delauney') {
+          return false;
         }
-        var dataIndex = (2 * closestPointIndex - voronoiRef.current[seriesId].startIndex) / 2;
-        if (voronoiMaxRadius !== undefined) {
-          var pointX = voronoiRef.current.delauney.points[2 * closestPointIndex];
-          var pointY = voronoiRef.current.delauney.points[2 * closestPointIndex + 1];
-          var dist2 = Math.pow(pointX - svgPoint.x, 2) + Math.pow(pointY - svgPoint.y, 2);
-          if (dist2 > Math.pow(voronoiMaxRadius, 2)) {
-            // The closest point is too far to be considered.
-            dispatch({
-              type: 'leaveItem',
-              data: {
-                type: 'scatter',
-                seriesId: seriesId,
-                dataIndex: dataIndex
-              }
-            });
-            return;
-          }
+        return 2 * closestPointIndex >= voronoiRef.current[id].startIndex && 2 * closestPointIndex < voronoiRef.current[id].endIndex;
+      });
+      if (seriesId === undefined) {
+        return 'no-point-found';
+      }
+      var dataIndex = (2 * closestPointIndex - voronoiRef.current[seriesId].startIndex) / 2;
+      if (voronoiMaxRadius !== undefined) {
+        var pointX = voronoiRef.current.delauney.points[2 * closestPointIndex];
+        var pointY = voronoiRef.current.delauney.points[2 * closestPointIndex + 1];
+        var dist2 = Math.pow(pointX - svgPoint.x, 2) + Math.pow(pointY - svgPoint.y, 2);
+        if (dist2 > Math.pow(voronoiMaxRadius, 2)) {
+          // The closest point is too far to be considered.
+          return 'outside-voronoi-max-radius';
         }
+      }
+      return {
+        seriesId: seriesId,
+        dataIndex: dataIndex
+      };
+    }
+    var handleMouseOut = function handleMouseOut() {
+      dispatch({
+        type: 'exitChart'
+      });
+    };
+    var handleMouseMove = function handleMouseMove(event) {
+      var closestPoint = getClosestPoint(event);
+      if (closestPoint === 'outside-chart') {
         dispatch({
-          type: 'enterItem',
+          type: 'exitChart'
+        });
+        return;
+      }
+      if (closestPoint === 'outside-voronoi-max-radius' || closestPoint === 'no-point-found') {
+        dispatch({
+          type: 'leaveItem',
           data: {
-            type: 'scatter',
-            seriesId: seriesId,
-            dataIndex: dataIndex
+            type: 'scatter'
           }
         });
+        return;
+      }
+      var seriesId = closestPoint.seriesId,
+        dataIndex = closestPoint.dataIndex;
+      dispatch({
+        type: 'enterItem',
+        data: {
+          type: 'scatter',
+          seriesId: seriesId,
+          dataIndex: dataIndex
+        }
+      });
+    };
+    var handleMouseClick = function handleMouseClick(event) {
+      if (!onItemClick) {
+        return;
       }
+      var closestPoint = getClosestPoint(event);
+      if (typeof closestPoint === 'string') {
+        // No point fond for any reason
+        return;
+      }
+      var seriesId = closestPoint.seriesId,
+        dataIndex = closestPoint.dataIndex;
+      onItemClick(event, {
+        type: 'scatter',
+        seriesId: seriesId,
+        dataIndex: dataIndex
+      });
     };
     element.addEventListener('mouseout', handleMouseOut);
     element.addEventListener('mousemove', handleMouseMove);
+    element.addEventListener('click', handleMouseClick);
     return function () {
       element.removeEventListener('mouseout', handleMouseOut);
       element.removeEventListener('mousemove', handleMouseMove);
+      element.removeEventListener('click', handleMouseClick);
     };
-  }, [svgRef, dispatch, left, width, top, height, yAxis, xAxis, voronoiMaxRadius]);
-  return /*#__PURE__*/_jsx("g", {}); // Workaround to fix docs scripts
+  }, [svgRef, dispatch, left, width, top, height, yAxis, xAxis, voronoiMaxRadius, onItemClick]);
+
+  // eslint-disable-next-line react/jsx-no-useless-fragment
+  return /*#__PURE__*/_jsx(React.Fragment, {});
 }
 process.env.NODE_ENV !== "production" ? ChartsVoronoiHandler.propTypes = {
   // ----------------------------- Warning --------------------------------
   // | These PropTypes are generated from the TypeScript type definitions |
   // | To update them edit the TypeScript types and run "yarn proptypes"  |
   // ----------------------------------------------------------------------
+  /**
+   * Callback fired when clicking on a scatter item.
+   * @param {MouseEvent} event Mouse event catched at the svg level
+   * @param {ScatterItemIdentifier} scatterItemIdentifier Identify whihc item got clicked
+   */
+  onItemClick: PropTypes.func,
   /**
    * Defines the maximal distance between a scatter point and the pointer that triggers the interaction.
    * If `undefined`, the radius is assumed to be infinite.

package/legacy/ChartsXAxis/ChartsXAxis.js

@@ -1,7 +1,7 @@
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _extends from "@babel/runtime/helpers/esm/extends";
-var _excluded = ["scale", "tickNumber"];
+var _excluded = ["scale", "tickNumber", "reverse"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { useSlotProps } from '@mui/base/utils';
@@ -34,6 +34,7 @@ var useUtilityClasses = function useUtilityClasses(ownerState) {
 function addLabelDimension(xTicks, _ref) {
   var style = _ref.tickLabelStyle,
     tickLabelInterval = _ref.tickLabelInterval,
+    reverse = _ref.reverse,
     isMounted = _ref.isMounted;
   var withDimension = xTicks.map(function (tick) {
     if (!isMounted || tick.formattedValue === undefined) {
@@ -63,8 +64,9 @@ function addLabelDimension(xTicks, _ref) {
   }
 
   // Filter label to avoid overlap
-  var textStart = 0;
-  var textEnd = 0;
+  var currentTextLimit = 0;
+  var previouseTextLimit = 0;
+  var direction = reverse ? -1 : 1;
   return withDimension.map(function (item, labelIndex) {
     var width = item.width,
       offset = item.offset,
@@ -74,15 +76,15 @@ function addLabelDimension(xTicks, _ref) {
     var textPosition = offset + labelOffset;
     var gapRatio = 1.2; // Ratio applied to the minimal distance to add some margin.
 
-    textStart = textPosition - gapRatio * distance / 2;
-    if (labelIndex > 0 && textStart < textEnd) {
+    currentTextLimit = textPosition - direction * (gapRatio * distance) / 2;
+    if (labelIndex > 0 && direction * currentTextLimit < direction * previouseTextLimit) {
       // Except for the first label, we skip all label that overlap with the last accepted.
-      // Notice that the early return prevents `textEnd` from being updated.
+      // Notice that the early return prevents `previouseTextLimit` from being updated.
       return _extends({}, item, {
         skipLabel: true
       });
     }
-    textEnd = textPosition + gapRatio * distance / 2;
+    previouseTextLimit = textPosition + direction * (gapRatio * distance) / 2;
     return item;
   });
 }
@@ -114,6 +116,7 @@ function ChartsXAxis(inProps) {
     _React$useContext2$xA = _React$useContext2.xAxis[(_props$axisId = props.axisId) != null ? _props$axisId : xAxisIds[0]],
     xScale = _React$useContext2$xA.scale,
     tickNumber = _React$useContext2$xA.tickNumber,
+    reverse = _React$useContext2$xA.reverse,
     settings = _objectWithoutProperties(_React$useContext2$xA, _excluded);
   var isMounted = useMounted();
   var defaultizedProps = _extends({}, defaultProps, settings, props);
@@ -169,6 +172,7 @@ function ChartsXAxis(inProps) {
   var xTicksWithDimension = addLabelDimension(xTicks, {
     tickLabelStyle: axisTickLabelProps.style,
     tickLabelInterval: tickLabelInterval,
+    reverse: reverse,
     isMounted: isMounted
   });
   var labelRefPoint = {
@@ -231,7 +235,7 @@ process.env.NODE_ENV !== "production" ? ChartsXAxis.propTypes = {
    * The id of the axis to render.
    * If undefined, it will be the first defined axis.
    */
-  axisId: PropTypes.string,
+  axisId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
   /**
    * Override or extend the styles applied to the component.
    */

package/legacy/ChartsYAxis/ChartsYAxis.js

@@ -163,7 +163,7 @@ process.env.NODE_ENV !== "production" ? ChartsYAxis.propTypes = {
    * The id of the axis to render.
    * If undefined, it will be the first defined axis.
    */
-  axisId: PropTypes.string,
+  axisId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
   /**
    * Override or extend the styles applied to the component.
    */

package/legacy/LineChart/AnimatedArea.js

@@ -0,0 +1,102 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["d", "skipAnimation", "ownerState"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { styled } from '@mui/material/styles';
+import { color as d3Color } from 'd3-color';
+import { animated, useSpring } from '@react-spring/web';
+import { useAnimatedPath } from '../internals/useAnimatedPath';
+import { DrawingContext } from '../context/DrawingProvider';
+import { cleanId } from '../internals/utils';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export var AreaElementPath = styled(animated.path, {
+  name: 'MuiAreaElement',
+  slot: 'Root',
+  overridesResolver: function overridesResolver(_, styles) {
+    return styles.root;
+  }
+})(function (_ref) {
+  var ownerState = _ref.ownerState;
+  return {
+    stroke: 'none',
+    fill: ownerState.isHighlighted ? d3Color(ownerState.color).brighter(1).formatHex() : d3Color(ownerState.color).brighter(0.5).formatHex(),
+    transition: 'opacity 0.2s ease-in, fill 0.2s ease-in',
+    opacity: ownerState.isFaded ? 0.3 : 1
+  };
+});
+/**
+ * Demos:
+ *
+ * - [Lines](https://mui.com/x/react-charts/lines/)
+ * - [Areas demonstration](https://mui.com/x/react-charts/areas-demo/)
+ *
+ * API:
+ *
+ * - [AreaElement API](https://mui.com/x/api/charts/animated-area/)
+ */
+function AnimatedArea(props) {
+  var d = props.d,
+    skipAnimation = props.skipAnimation,
+    ownerState = props.ownerState,
+    other = _objectWithoutProperties(props, _excluded);
+  var _React$useContext = React.useContext(DrawingContext),
+    left = _React$useContext.left,
+    top = _React$useContext.top,
+    right = _React$useContext.right,
+    bottom = _React$useContext.bottom,
+    width = _React$useContext.width,
+    height = _React$useContext.height,
+    chartId = _React$useContext.chartId;
+  var path = useAnimatedPath(d, skipAnimation);
+  var _useSpring = useSpring({
+      from: {
+        animatedWidth: left
+      },
+      to: {
+        animatedWidth: width + left + right
+      },
+      reset: false,
+      immediate: skipAnimation
+    }),
+    animatedWidth = _useSpring.animatedWidth;
+  var clipId = cleanId("".concat(chartId, "-").concat(ownerState.id, "-area-clip"));
+  return /*#__PURE__*/_jsxs(React.Fragment, {
+    children: [/*#__PURE__*/_jsx("clipPath", {
+      id: clipId,
+      children: /*#__PURE__*/_jsx(animated.rect, {
+        x: 0,
+        y: 0,
+        width: animatedWidth,
+        height: top + height + bottom
+      })
+    }), /*#__PURE__*/_jsx("g", {
+      clipPath: "url(#".concat(clipId, ")"),
+      children: /*#__PURE__*/_jsx(AreaElementPath, _extends({}, other, {
+        ownerState: ownerState,
+        d: path
+      }))
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" ? AnimatedArea.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  d: PropTypes.string.isRequired,
+  ownerState: PropTypes.shape({
+    classes: PropTypes.object,
+    color: PropTypes.string.isRequired,
+    id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
+    isFaded: PropTypes.bool.isRequired,
+    isHighlighted: PropTypes.bool.isRequired
+  }).isRequired,
+  /**
+   * If `true`, animations are skipped.
+   * @default false
+   */
+  skipAnimation: PropTypes.bool
+} : void 0;
+export { AnimatedArea };