@mui/x-charts 7.0.0-alpha.9 → 7.0.0-beta.1

package/modern/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 } from './utils';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 function DefaultChartsAxisTooltipContent(props) {
@@ -33,14 +34,15 @@ function DefaultChartsAxisTooltipContent(props) {
           })
         })
       }), /*#__PURE__*/_jsx("tbody", {
-        children: series.map(({
+        children: series.filter(isCartesianSeries).map(({
           color,
           id,
           label,
           valueFormatter,
           data
         }) => {
-          const formattedValue = valueFormatter(data[dataIndex]);
+          // @ts-ignore
+          const formattedValue = valueFormatter(data[dataIndex] ?? null);
           if (formattedValue == null) {
             return null;
           }
@@ -80,48 +82,18 @@ process.env.NODE_ENV !== "production" ? DefaultChartsAxisTooltipContent.propType
   /**
    * The properties of the triggered axis.
    */
-  axis: PropTypes.shape({
-    axisId: PropTypes.string,
-    classes: PropTypes.object,
-    data: PropTypes.array,
-    dataKey: PropTypes.string,
-    disableLine: PropTypes.bool,
-    disableTicks: PropTypes.bool,
-    fill: PropTypes.string,
-    hideTooltip: PropTypes.bool,
-    id: PropTypes.string.isRequired,
-    label: PropTypes.string,
-    labelFontSize: PropTypes.number,
-    labelStyle: PropTypes.object,
-    max: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
-    min: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
-    position: PropTypes.oneOf(['bottom', 'left', 'right', 'top']),
-    scale: PropTypes.func.isRequired,
-    scaleType: PropTypes.oneOf(['time']).isRequired,
-    slotProps: PropTypes.object,
-    slots: PropTypes.object,
-    stroke: PropTypes.string,
-    tickFontSize: PropTypes.number,
-    tickInterval: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.array, PropTypes.func]),
-    tickLabelInterval: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.func]),
-    tickLabelStyle: PropTypes.object,
-    tickMaxStep: PropTypes.number,
-    tickMinStep: PropTypes.number,
-    tickNumber: PropTypes.number.isRequired,
-    tickSize: PropTypes.number,
-    valueFormatter: PropTypes.func
-  }).isRequired,
+  axis: PropTypes.object.isRequired,
   /**
    * Data identifying the triggered axis.
    */
   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,
   /**
@@ -139,29 +111,7 @@ process.env.NODE_ENV !== "production" ? DefaultChartsAxisTooltipContent.propType
   /**
    * The series linked to the triggered axis.
    */
-  series: PropTypes.arrayOf(PropTypes.shape({
-    area: PropTypes.bool,
-    color: PropTypes.string.isRequired,
-    connectNulls: PropTypes.bool,
-    curve: PropTypes.oneOf(['catmullRom', 'linear', 'monotoneX', 'monotoneY', 'natural', 'step', 'stepAfter', 'stepBefore']),
-    data: PropTypes.arrayOf(PropTypes.number).isRequired,
-    dataKey: PropTypes.string,
-    disableHighlight: PropTypes.bool,
-    highlightScope: PropTypes.shape({
-      faded: PropTypes.oneOf(['global', 'none', 'series']),
-      highlighted: PropTypes.oneOf(['item', 'none', 'series'])
-    }),
-    id: PropTypes.string.isRequired,
-    label: PropTypes.string,
-    showMark: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),
-    stack: PropTypes.string,
-    stackOffset: PropTypes.oneOf(['diverging', 'expand', 'none', 'silhouette', 'wiggle']),
-    stackOrder: PropTypes.oneOf(['appearance', 'ascending', 'descending', 'insideOut', 'none', 'reverse']),
-    type: PropTypes.oneOf(['line']).isRequired,
-    valueFormatter: PropTypes.func.isRequired,
-    xAxisKey: PropTypes.string,
-    yAxisKey: PropTypes.string
-  })).isRequired,
+  series: PropTypes.arrayOf(PropTypes.object).isRequired,
   sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
 } : void 0;
 export { DefaultChartsAxisTooltipContent };

package/modern/ChartsTooltip/DefaultChartsItemTooltipContent.js

@@ -74,17 +74,7 @@ process.env.NODE_ENV !== "production" ? DefaultChartsItemTooltipContent.propType
   /**
    * The series linked to the triggered axis.
    */
-  series: PropTypes.shape({
-    color: PropTypes.string,
-    data: PropTypes.arrayOf(PropTypes.number).isRequired,
-    highlightScope: PropTypes.shape({
-      faded: PropTypes.oneOf(['global', 'none', 'series']),
-      highlighted: PropTypes.oneOf(['item', 'none', 'series'])
-    }),
-    id: PropTypes.string.isRequired,
-    type: PropTypes.oneOf(['bar', 'line', 'pie', 'scatter']).isRequired,
-    valueFormatter: PropTypes.func.isRequired
-  }).isRequired,
+  series: PropTypes.object.isRequired,
   sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
 } : void 0;
 export { DefaultChartsItemTooltipContent };

package/modern/ChartsTooltip/utils.js

@@ -78,4 +78,10 @@ export function getTooltipHasData(trigger, displayedData) {
   const hasAxisXData = displayedData.x !== null;
   const 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);
 }

package/modern/ChartsVoronoiHandler/ChartsVoronoiHandler.js

@@ -11,7 +11,8 @@ import { getSVGPoint } from '../internals/utils';
 import { jsx as _jsx } from "react/jsx-runtime";
 function ChartsVoronoiHandler(props) {
   const {
-    voronoiMaxRadius
+    voronoiMaxRadius,
+    onItemClick
   } = props;
   const svgRef = React.useContext(SVGContext);
   const {
@@ -49,6 +50,8 @@ function ChartsVoronoiHandler(props) {
     };
   }, [dispatch]);
   useEnhancedEffect(() => {
+    // 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;
@@ -82,80 +85,125 @@ function ChartsVoronoiHandler(props) {
     if (element === null) {
       return undefined;
     }
-    const 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.
-    const handleMouseMove = event => {
+    function getClosestPoint(event) {
       // Get mouse coordinate in global SVG space
       const svgPoint = getSVGPoint(svgRef.current, event);
       const outsideX = svgPoint.x < left || svgPoint.x > left + width;
       const 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';
       }
       const closestPointIndex = voronoiRef.current.delauney?.find(svgPoint.x, svgPoint.y);
-      if (closestPointIndex !== undefined) {
-        const seriesId = Object.keys(voronoiRef.current).find(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';
+      }
+      const seriesId = Object.keys(voronoiRef.current).find(id => {
+        if (id === 'delauney') {
+          return false;
         }
-        const dataIndex = (2 * closestPointIndex - voronoiRef.current[seriesId].startIndex) / 2;
-        if (voronoiMaxRadius !== undefined) {
-          const pointX = voronoiRef.current.delauney.points[2 * closestPointIndex];
-          const pointY = voronoiRef.current.delauney.points[2 * closestPointIndex + 1];
-          const dist2 = (pointX - svgPoint.x) ** 2 + (pointY - svgPoint.y) ** 2;
-          if (dist2 > voronoiMaxRadius ** 2) {
-            // The closest point is too far to be considered.
-            dispatch({
-              type: 'leaveItem',
-              data: {
-                type: 'scatter',
-                seriesId,
-                dataIndex
-              }
-            });
-            return;
-          }
+        return 2 * closestPointIndex >= voronoiRef.current[id].startIndex && 2 * closestPointIndex < voronoiRef.current[id].endIndex;
+      });
+      if (seriesId === undefined) {
+        return 'no-point-found';
+      }
+      const dataIndex = (2 * closestPointIndex - voronoiRef.current[seriesId].startIndex) / 2;
+      if (voronoiMaxRadius !== undefined) {
+        const pointX = voronoiRef.current.delauney.points[2 * closestPointIndex];
+        const pointY = voronoiRef.current.delauney.points[2 * closestPointIndex + 1];
+        const dist2 = (pointX - svgPoint.x) ** 2 + (pointY - svgPoint.y) ** 2;
+        if (dist2 > voronoiMaxRadius ** 2) {
+          // The closest point is too far to be considered.
+          return 'outside-voronoi-max-radius';
         }
+      }
+      return {
+        seriesId,
+        dataIndex
+      };
+    }
+    const handleMouseOut = () => {
+      dispatch({
+        type: 'exitChart'
+      });
+    };
+    const handleMouseMove = event => {
+      const closestPoint = getClosestPoint(event);
+      if (closestPoint === 'outside-chart') {
+        dispatch({
+          type: 'exitChart'
+        });
+        return;
+      }
+      if (closestPoint === 'outside-voronoi-max-radius' || closestPoint === 'no-point-found') {
         dispatch({
-          type: 'enterItem',
+          type: 'leaveItem',
           data: {
-            type: 'scatter',
-            seriesId,
-            dataIndex
+            type: 'scatter'
           }
         });
+        return;
       }
+      const {
+        seriesId,
+        dataIndex
+      } = closestPoint;
+      dispatch({
+        type: 'enterItem',
+        data: {
+          type: 'scatter',
+          seriesId,
+          dataIndex
+        }
+      });
+    };
+    const handleMouseClick = event => {
+      if (!onItemClick) {
+        return;
+      }
+      const closestPoint = getClosestPoint(event);
+      if (typeof closestPoint === 'string') {
+        // No point fond for any reason
+        return;
+      }
+      const {
+        seriesId,
+        dataIndex
+      } = closestPoint;
+      onItemClick(event, {
+        type: 'scatter',
+        seriesId,
+        dataIndex
+      });
     };
     element.addEventListener('mouseout', handleMouseOut);
     element.addEventListener('mousemove', handleMouseMove);
+    element.addEventListener('click', handleMouseClick);
     return () => {
       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/modern/LineChart/AnimatedArea.js

@@ -0,0 +1,103 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _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 const AreaElementPath = styled(animated.path, {
+  name: 'MuiAreaElement',
+  slot: 'Root',
+  overridesResolver: (_, styles) => styles.root
+})(({
+  ownerState
+}) => ({
+  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) {
+  const {
+      d,
+      skipAnimation,
+      ownerState
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const {
+    left,
+    top,
+    right,
+    bottom,
+    width,
+    height,
+    chartId
+  } = React.useContext(DrawingContext);
+  const path = useAnimatedPath(d, skipAnimation);
+  const {
+    animatedWidth
+  } = useSpring({
+    from: {
+      animatedWidth: left
+    },
+    to: {
+      animatedWidth: width + left + right
+    },
+    reset: false,
+    immediate: skipAnimation
+  });
+  const clipId = cleanId(`${chartId}-${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(#${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.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 };

package/modern/LineChart/AnimatedLine.js

@@ -0,0 +1,105 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["d", "skipAnimation", "ownerState"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { animated, useSpring } from '@react-spring/web';
+import { color as d3Color } from 'd3-color';
+import { styled } from '@mui/material/styles';
+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 const LineElementPath = styled(animated.path, {
+  name: 'MuiLineElement',
+  slot: 'Root',
+  overridesResolver: (_, styles) => styles.root
+})(({
+  ownerState
+}) => ({
+  strokeWidth: 2,
+  strokeLinejoin: 'round',
+  fill: 'none',
+  stroke: ownerState.isHighlighted ? d3Color(ownerState.color).brighter(0.5).formatHex() : ownerState.color,
+  transition: 'opacity 0.2s ease-in, stroke 0.2s ease-in',
+  opacity: ownerState.isFaded ? 0.3 : 1
+}));
+/**
+ * Demos:
+ *
+ * - [Lines](https://mui.com/x/react-charts/lines/)
+ * - [Line demonstration](https://mui.com/x/react-charts/line-demo/)
+ *
+ * API:
+ *
+ * - [AnimatedLine API](https://mui.com/x/api/charts/animated-line/)
+ */
+function AnimatedLine(props) {
+  const {
+      d,
+      skipAnimation,
+      ownerState
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const {
+    left,
+    top,
+    bottom,
+    width,
+    height,
+    right,
+    chartId
+  } = React.useContext(DrawingContext);
+  const path = useAnimatedPath(d, skipAnimation);
+  const {
+    animatedWidth
+  } = useSpring({
+    from: {
+      animatedWidth: left
+    },
+    to: {
+      animatedWidth: width + left + right
+    },
+    reset: false,
+    immediate: skipAnimation
+  });
+  const clipId = cleanId(`${chartId}-${ownerState.id}-line-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(#${clipId})`,
+      children: /*#__PURE__*/_jsx(LineElementPath, _extends({}, other, {
+        ownerState: ownerState,
+        d: path
+      }))
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" ? AnimatedLine.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.string.isRequired,
+    isFaded: PropTypes.bool.isRequired,
+    isHighlighted: PropTypes.bool.isRequired
+  }).isRequired,
+  /**
+   * If `true`, animations are skipped.
+   * @default false
+   */
+  skipAnimation: PropTypes.bool
+} : void 0;
+export { AnimatedLine };

package/modern/LineChart/AreaElement.js

@@ -1,16 +1,15 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["id", "classes", "color", "highlightScope", "slots", "slotProps"];
+const _excluded = ["id", "classes", "color", "highlightScope", "slots", "slotProps", "onClick"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import composeClasses from '@mui/utils/composeClasses';
 import { useSlotProps } from '@mui/base/utils';
 import generateUtilityClass from '@mui/utils/generateUtilityClass';
-import { styled } from '@mui/material/styles';
 import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
-import { color as d3Color } from 'd3-color';
 import { getIsFaded, getIsHighlighted, useInteractionItemProps } from '../hooks/useInteractionItemProps';
 import { InteractionContext } from '../context/InteractionProvider';
+import { AnimatedArea } from './AnimatedArea';
 import { jsx as _jsx } from "react/jsx-runtime";
 export function getAreaElementUtilityClass(slot) {
   return generateUtilityClass('MuiAreaElement', slot);
@@ -28,33 +27,6 @@ const useUtilityClasses = ownerState => {
   };
   return composeClasses(slots, getAreaElementUtilityClass, classes);
 };
-export const AreaElementPath = styled('path', {
-  name: 'MuiAreaElement',
-  slot: 'Root',
-  overridesResolver: (_, styles) => styles.root
-})(({
-  ownerState
-}) => ({
-  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
-}));
-AreaElementPath.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "yarn proptypes"  |
-  // ----------------------------------------------------------------------
-  as: PropTypes.elementType,
-  ownerState: PropTypes.shape({
-    classes: PropTypes.object,
-    color: PropTypes.string.isRequired,
-    id: PropTypes.string.isRequired,
-    isFaded: PropTypes.bool.isRequired,
-    isHighlighted: PropTypes.bool.isRequired
-  }).isRequired,
-  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
-};
 /**
  * Demos:
  *
@@ -72,7 +44,8 @@ function AreaElement(props) {
       color,
       highlightScope,
       slots,
-      slotProps
+      slotProps,
+      onClick
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
   const getInteractionItemProps = useInteractionItemProps(highlightScope);
@@ -95,7 +68,7 @@ function AreaElement(props) {
     isHighlighted
   };
   const classes = useUtilityClasses(ownerState);
-  const Area = slots?.area ?? AreaElementPath;
+  const Area = slots?.area ?? AnimatedArea;
   const areaProps = useSlotProps({
     elementType: Area,
     externalSlotProps: slotProps?.area,
@@ -103,7 +76,9 @@ function AreaElement(props) {
       type: 'line',
       seriesId: id
     }), {
-      className: classes.root
+      className: classes.root,
+      onClick,
+      cursor: onClick ? 'pointer' : 'unset'
     }),
     ownerState
   });
@@ -115,10 +90,18 @@ process.env.NODE_ENV !== "production" ? AreaElement.propTypes = {
   // | To update them edit the TypeScript types and run "yarn proptypes"  |
   // ----------------------------------------------------------------------
   classes: PropTypes.object,
+  color: PropTypes.string.isRequired,
+  d: PropTypes.string.isRequired,
   highlightScope: PropTypes.shape({
     faded: PropTypes.oneOf(['global', 'none', 'series']),
     highlighted: PropTypes.oneOf(['item', 'none', 'series'])
   }),
+  id: PropTypes.string.isRequired,
+  /**
+   * If `true`, animations are skipped.
+   * @default false
+   */
+  skipAnimation: PropTypes.bool,
   /**
    * The props used for each component slot.
    * @default {}