@mui/x-charts 6.0.0-alpha.8 → 6.18.0

package/legacy/LineChart/LineChart.js

@@ -13,8 +13,19 @@ import { ChartsTooltip } from '../ChartsTooltip';
 import { ChartsLegend } from '../ChartsLegend';
 import { ChartsAxisHighlight } from '../ChartsAxisHighlight';
 import { ChartsClipPath } from '../ChartsClipPath';
+import { LineHighlightPlot } from './LineHighlightPlot';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Demos:
+ *
+ * - [Lines](https://mui.com/x/react-charts/lines/)
+ * - [Line demonstration](https://mui.com/x/react-charts/line-demo/)
+ *
+ * API:
+ *
+ * - [LineChart API](https://mui.com/x/api/charts/line-chart/)
+ */
 var LineChart = /*#__PURE__*/React.forwardRef(function LineChart(props, ref) {
   var xAxis = props.xAxis,
     yAxis = props.yAxis,
@@ -30,6 +41,7 @@ var LineChart = /*#__PURE__*/React.forwardRef(function LineChart(props, ref) {
     axisHighlight = _props$axisHighlight === void 0 ? {
       x: 'line'
     } : _props$axisHighlight,
+    disableLineItemHighlight = props.disableLineItemHighlight,
     legend = props.legend,
     topAxis = props.topAxis,
     leftAxis = props.leftAxis,
@@ -44,6 +56,7 @@ var LineChart = /*#__PURE__*/React.forwardRef(function LineChart(props, ref) {
     ref: ref,
     series: series.map(function (s) {
       return _extends({
+        disableHighlight: !!disableLineItemHighlight,
         type: 'line'
       }, s);
     }),
@@ -83,13 +96,19 @@ var LineChart = /*#__PURE__*/React.forwardRef(function LineChart(props, ref) {
       bottomAxis: bottomAxis,
       slots: slots,
       slotProps: slotProps
-    }), /*#__PURE__*/_jsx(MarkPlot, {
+    }), /*#__PURE__*/_jsx(ChartsAxisHighlight, _extends({}, axisHighlight)), /*#__PURE__*/_jsx(MarkPlot, {
+      slots: slots,
+      slotProps: slotProps
+    }), /*#__PURE__*/_jsx(LineHighlightPlot, {
       slots: slots,
       slotProps: slotProps
     }), /*#__PURE__*/_jsx(ChartsLegend, _extends({}, legend, {
       slots: slots,
       slotProps: slotProps
-    })), /*#__PURE__*/_jsx(ChartsAxisHighlight, _extends({}, axisHighlight)), /*#__PURE__*/_jsx(ChartsTooltip, _extends({}, tooltip)), /*#__PURE__*/_jsx(ChartsClipPath, {
+    })), /*#__PURE__*/_jsx(ChartsTooltip, _extends({}, tooltip, {
+      slots: slots,
+      slotProps: slotProps
+    })), /*#__PURE__*/_jsx(ChartsClipPath, {
       id: clipPathId
     }), children]
   });
@@ -116,11 +135,15 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     fill: PropTypes.string,
     label: PropTypes.string,
     labelFontSize: PropTypes.number,
+    labelStyle: PropTypes.object,
     position: PropTypes.oneOf(['bottom', 'top']),
     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,
@@ -135,6 +158,10 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
   dataset: PropTypes.arrayOf(PropTypes.object),
   desc: PropTypes.string,
   disableAxisListener: PropTypes.bool,
+  /**
+   * If `true`, render the line highlight item.
+   */
+  disableLineItemHighlight: PropTypes.bool,
   height: PropTypes.number,
   /**
    * Indicate which axis to display the left of the charts.
@@ -149,33 +176,33 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     fill: PropTypes.string,
     label: PropTypes.string,
     labelFontSize: PropTypes.number,
+    labelStyle: PropTypes.object,
     position: PropTypes.oneOf(['left', 'right']),
     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,
     tickSize: PropTypes.number
   }), PropTypes.string]),
+  /**
+   * @deprecated Consider using `slotProps.legend` instead.
+   */
   legend: PropTypes.shape({
     classes: PropTypes.object,
     direction: PropTypes.oneOf(['column', 'row']),
     hidden: PropTypes.bool,
-    itemWidth: PropTypes.number,
-    markSize: PropTypes.number,
-    offset: PropTypes.shape({
-      x: PropTypes.number,
-      y: PropTypes.number
-    }),
     position: PropTypes.shape({
       horizontal: PropTypes.oneOf(['left', 'middle', 'right']).isRequired,
       vertical: PropTypes.oneOf(['bottom', 'middle', 'top']).isRequired
     }),
     slotProps: PropTypes.object,
-    slots: PropTypes.object,
-    spacing: PropTypes.number
+    slots: PropTypes.object
   }),
   margin: PropTypes.shape({
     bottom: PropTypes.number,
@@ -196,11 +223,15 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     fill: PropTypes.string,
     label: PropTypes.string,
     labelFontSize: PropTypes.number,
+    labelStyle: PropTypes.object,
     position: PropTypes.oneOf(['left', 'right']),
     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,
@@ -209,15 +240,18 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
   series: PropTypes.arrayOf(PropTypes.shape({
     area: PropTypes.bool,
     color: PropTypes.string,
+    connectNulls: PropTypes.bool,
     curve: PropTypes.oneOf(['catmullRom', 'linear', 'monotoneX', 'monotoneY', 'natural', 'step', 'stepAfter', 'stepBefore']),
     data: PropTypes.arrayOf(PropTypes.number),
     dataKey: PropTypes.string,
+    disableHighlight: PropTypes.bool,
     highlightScope: PropTypes.shape({
       faded: PropTypes.oneOf(['global', 'none', 'series']),
       highlighted: PropTypes.oneOf(['item', 'none', 'series'])
     }),
     id: PropTypes.string,
     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']),
@@ -242,6 +276,8 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     axisContent: PropTypes.elementType,
     classes: PropTypes.object,
     itemContent: PropTypes.elementType,
+    slotProps: PropTypes.object,
+    slots: PropTypes.object,
     trigger: PropTypes.oneOf(['axis', 'item', 'none'])
   }),
   /**
@@ -257,11 +293,15 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     fill: PropTypes.string,
     label: PropTypes.string,
     labelFontSize: PropTypes.number,
+    labelStyle: PropTypes.object,
     position: PropTypes.oneOf(['bottom', 'top']),
     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,
@@ -286,6 +326,7 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     id: PropTypes.string,
     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']),
@@ -294,6 +335,9 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     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,
@@ -312,6 +356,7 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     id: PropTypes.string,
     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']),
@@ -320,6 +365,9 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     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,

package/legacy/LineChart/LineElement.js

@@ -58,6 +58,16 @@ LineElementPath.propTypes = {
   }).isRequired,
   sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
 };
+/**
+ * Demos:
+ *
+ * - [Lines](https://mui.com/x/react-charts/lines/)
+ * - [Line demonstration](https://mui.com/x/react-charts/line-demo/)
+ *
+ * API:
+ *
+ * - [LineElement API](https://mui.com/x/api/charts/line-element/)
+ */
 function LineElement(props) {
   var _slots$line;
   var id = props.id,

package/legacy/LineChart/LineHighlightElement.js

@@ -0,0 +1,77 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["x", "y", "id", "classes", "color"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import composeClasses from '@mui/utils/composeClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+import { styled } from '@mui/material/styles';
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import { jsx as _jsx } from "react/jsx-runtime";
+export function getHighlightElementUtilityClass(slot) {
+  return generateUtilityClass('MuiHighlightElement', slot);
+}
+export var lineHighlightElementClasses = generateUtilityClasses('MuiHighlightElement', ['root']);
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var classes = ownerState.classes,
+    id = ownerState.id;
+  var slots = {
+    root: ['root', "series-".concat(id)]
+  };
+  return composeClasses(slots, getHighlightElementUtilityClass, classes);
+};
+var HighlightElement = styled('circle', {
+  name: 'MuiHighlightElement',
+  slot: 'Root',
+  overridesResolver: function overridesResolver(_, styles) {
+    return styles.root;
+  }
+})(function (_ref) {
+  var ownerState = _ref.ownerState;
+  return {
+    transform: "translate(".concat(ownerState.x, "px, ").concat(ownerState.y, "px)"),
+    transformOrigin: "".concat(ownerState.x, "px ").concat(ownerState.y, "px"),
+    fill: ownerState.color
+  };
+});
+/**
+ * Demos:
+ *
+ * - [Lines](https://mui.com/x/react-charts/lines/)
+ * - [Line demonstration](https://mui.com/x/react-charts/line-demo/)
+ *
+ * API:
+ *
+ * - [LineHighlightElement API](https://mui.com/x/api/charts/line-highlight-element/)
+ */
+function LineHighlightElement(props) {
+  var x = props.x,
+    y = props.y,
+    id = props.id,
+    innerClasses = props.classes,
+    color = props.color,
+    other = _objectWithoutProperties(props, _excluded);
+  var ownerState = {
+    id: id,
+    classes: innerClasses,
+    color: color,
+    x: x,
+    y: y
+  };
+  var classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(HighlightElement, _extends({}, other, {
+    ownerState: ownerState,
+    className: classes.root,
+    cx: 0,
+    cy: 0,
+    r: other.r === undefined ? 5 : other.r
+  }));
+}
+process.env.NODE_ENV !== "production" ? LineHighlightElement.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  classes: PropTypes.object
+} : void 0;
+export { LineHighlightElement };

package/legacy/LineChart/LineHighlightPlot.js

@@ -0,0 +1,96 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["slots", "slotProps"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { SeriesContext } from '../context/SeriesContextProvider';
+import { CartesianContext } from '../context/CartesianContextProvider';
+import { LineHighlightElement } from './LineHighlightElement';
+import { getValueToPositionMapper } from '../hooks/useScale';
+import { InteractionContext } from '../context/InteractionProvider';
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Demos:
+ *
+ * - [Lines](https://mui.com/x/react-charts/lines/)
+ * - [Line demonstration](https://mui.com/x/react-charts/line-demo/)
+ *
+ * API:
+ *
+ * - [LineHighlightPlot API](https://mui.com/x/api/charts/line-highlight-plot/)
+ */
+function LineHighlightPlot(props) {
+  var _axis$x, _slots$lineHighlight;
+  var slots = props.slots,
+    slotProps = props.slotProps,
+    other = _objectWithoutProperties(props, _excluded);
+  var seriesData = React.useContext(SeriesContext).line;
+  var axisData = React.useContext(CartesianContext);
+  var _React$useContext = React.useContext(InteractionContext),
+    axis = _React$useContext.axis;
+  var highlightedIndex = (_axis$x = axis.x) == null ? void 0 : _axis$x.index;
+  if (highlightedIndex === undefined) {
+    return null;
+  }
+  if (seriesData === undefined) {
+    return null;
+  }
+  var series = seriesData.series,
+    stackingGroups = seriesData.stackingGroups;
+  var xAxis = axisData.xAxis,
+    yAxis = axisData.yAxis,
+    xAxisIds = axisData.xAxisIds,
+    yAxisIds = axisData.yAxisIds;
+  var defaultXAxisId = xAxisIds[0];
+  var defaultYAxisId = yAxisIds[0];
+  var Element = (_slots$lineHighlight = slots == null ? void 0 : slots.lineHighlight) != null ? _slots$lineHighlight : LineHighlightElement;
+  return /*#__PURE__*/_jsx("g", _extends({}, other, {
+    children: stackingGroups.flatMap(function (_ref) {
+      var groupIds = _ref.ids;
+      return groupIds.flatMap(function (seriesId) {
+        var _series$seriesId = series[seriesId],
+          _series$seriesId$xAxi = _series$seriesId.xAxisKey,
+          xAxisKey = _series$seriesId$xAxi === void 0 ? defaultXAxisId : _series$seriesId$xAxi,
+          _series$seriesId$yAxi = _series$seriesId.yAxisKey,
+          yAxisKey = _series$seriesId$yAxi === void 0 ? defaultYAxisId : _series$seriesId$yAxi,
+          stackedData = _series$seriesId.stackedData,
+          data = _series$seriesId.data,
+          disableHighlight = _series$seriesId.disableHighlight;
+        if (disableHighlight || data[highlightedIndex] == null) {
+          return null;
+        }
+        var xScale = getValueToPositionMapper(xAxis[xAxisKey].scale);
+        var yScale = yAxis[yAxisKey].scale;
+        var xData = xAxis[xAxisKey].data;
+        if (xData === undefined) {
+          throw new Error("Axis of id \"".concat(xAxisKey, "\" should have data property to be able to display a line plot."));
+        }
+        var x = xScale(xData[highlightedIndex]);
+        var y = yScale(stackedData[highlightedIndex][1]);
+        return /*#__PURE__*/_jsx(Element, _extends({
+          id: seriesId,
+          color: series[seriesId].color,
+          x: x,
+          y: y
+        }, slotProps == null ? void 0 : slotProps.lineHighlight), "".concat(seriesId));
+      });
+    })
+  }));
+}
+process.env.NODE_ENV !== "production" ? LineHighlightPlot.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: PropTypes.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: PropTypes.object
+} : void 0;
+export { LineHighlightPlot };

package/legacy/LineChart/LinePlot.js

@@ -10,6 +10,16 @@ import { LineElement } from './LineElement';
 import { getValueToPositionMapper } from '../hooks/useScale';
 import getCurveFactory from '../internals/getCurve';
 import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Demos:
+ *
+ * - [Lines](https://mui.com/x/react-charts/lines/)
+ * - [Line demonstration](https://mui.com/x/react-charts/line-demo/)
+ *
+ * API:
+ *
+ * - [LinePlot API](https://mui.com/x/api/charts/line-plot/)
+ */
 function LinePlot(props) {
   var slots = props.slots,
     slotProps = props.slotProps,
@@ -31,36 +41,43 @@ function LinePlot(props) {
     children: stackingGroups.flatMap(function (_ref) {
       var groupIds = _ref.ids;
       return groupIds.flatMap(function (seriesId) {
+        var _xData$map;
         var _series$seriesId = series[seriesId],
           _series$seriesId$xAxi = _series$seriesId.xAxisKey,
           xAxisKey = _series$seriesId$xAxi === void 0 ? defaultXAxisId : _series$seriesId$xAxi,
           _series$seriesId$yAxi = _series$seriesId.yAxisKey,
           yAxisKey = _series$seriesId$yAxi === void 0 ? defaultYAxisId : _series$seriesId$yAxi,
-          stackedData = _series$seriesId.stackedData;
+          stackedData = _series$seriesId.stackedData,
+          data = _series$seriesId.data,
+          connectNulls = _series$seriesId.connectNulls;
         var xScale = getValueToPositionMapper(xAxis[xAxisKey].scale);
         var yScale = yAxis[yAxisKey].scale;
         var xData = xAxis[xAxisKey].data;
-        if (xData === undefined) {
-          throw new Error("Axis of id \"".concat(xAxisKey, "\" should have data property to be able to display a line plot"));
+        if (process.env.NODE_ENV !== 'production') {
+          if (xData === undefined) {
+            throw new Error("Axis of id \"".concat(xAxisKey, "\" should have data property to be able to display a line plot"));
+          }
+          if (xData.length < stackedData.length) {
+            throw new Error("MUI: data length of the x axis (".concat(xData.length, " items) is lower than the length of series (").concat(stackedData.length, " items)"));
+          }
         }
         var linePath = d3Line().x(function (d) {
           return xScale(d.x);
+        }).defined(function (_, i) {
+          return connectNulls || data[i] != null;
         }).y(function (d) {
           return yScale(d.y[1]);
         });
-        if (process.env.NODE_ENV !== 'production') {
-          if (xData.length !== stackedData.length) {
-            throw new Error("MUI: data length of the x axis (".concat(xData.length, " items) does not match length of series (").concat(stackedData.length, " items)"));
-          }
-        }
         var curve = getCurveFactory(series[seriesId].curve);
-        var d3Data = xData == null ? void 0 : xData.map(function (x, index) {
-          var _stackedData$index;
+        var formattedData = (_xData$map = xData == null ? void 0 : xData.map(function (x, index) {
           return {
             x: x,
-            y: (_stackedData$index = stackedData[index]) != null ? _stackedData$index : [0, 0]
+            y: stackedData[index]
           };
-        });
+        })) != null ? _xData$map : [];
+        var d3Data = connectNulls ? formattedData.filter(function (_, i) {
+          return data[i] != null;
+        }) : formattedData;
         return /*#__PURE__*/_jsx(LineElement, {
           id: seriesId,
           d: linePath.curve(curve)(d3Data) || undefined,

package/legacy/LineChart/MarkElement.js

@@ -38,12 +38,9 @@ var MarkElementPath = styled('path', {
   return {
     transform: "translate(".concat(ownerState.x, "px, ").concat(ownerState.y, "px)"),
     transformOrigin: "".concat(ownerState.x, "px ").concat(ownerState.y, "px"),
-    fill: theme.palette.background.paper,
+    fill: (theme.vars || theme).palette.background.paper,
     stroke: ownerState.color,
-    strokeWidth: 2,
-    '&.MuiMarkElement-highlighted': {
-      fill: ownerState.color
-    }
+    strokeWidth: 2
   };
 });
 MarkElementPath.propTypes = {
@@ -63,6 +60,16 @@ MarkElementPath.propTypes = {
   }).isRequired,
   sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
 };
+/**
+ * Demos:
+ *
+ * - [Lines](https://mui.com/x/react-charts/lines/)
+ * - [Line demonstration](https://mui.com/x/react-charts/line-demo/)
+ *
+ * API:
+ *
+ * - [MarkElement API](https://mui.com/x/api/charts/mark-element/)
+ */
 function MarkElement(props) {
   var _axis$x;
   var x = props.x,

package/legacy/LineChart/MarkPlot.js

@@ -9,6 +9,16 @@ import { CartesianContext } from '../context/CartesianContextProvider';
 import { MarkElement } from './MarkElement';
 import { getValueToPositionMapper } from '../hooks/useScale';
 import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Demos:
+ *
+ * - [Lines](https://mui.com/x/react-charts/lines/)
+ * - [Line demonstration](https://mui.com/x/react-charts/line-demo/)
+ *
+ * API:
+ *
+ * - [MarkPlot API](https://mui.com/x/api/charts/mark-plot/)
+ */
 function MarkPlot(props) {
   var _slots$mark;
   var slots = props.slots,
@@ -37,7 +47,13 @@ function MarkPlot(props) {
           xAxisKey = _series$seriesId$xAxi === void 0 ? defaultXAxisId : _series$seriesId$xAxi,
           _series$seriesId$yAxi = _series$seriesId.yAxisKey,
           yAxisKey = _series$seriesId$yAxi === void 0 ? defaultYAxisId : _series$seriesId$yAxi,
-          stackedData = _series$seriesId.stackedData;
+          stackedData = _series$seriesId.stackedData,
+          data = _series$seriesId.data,
+          _series$seriesId$show = _series$seriesId.showMark,
+          showMark = _series$seriesId$show === void 0 ? true : _series$seriesId$show;
+        if (showMark === false) {
+          return null;
+        }
         var xScale = getValueToPositionMapper(xAxis[xAxisKey].scale);
         var yScale = yAxis[yAxisKey].scale;
         var xData = xAxis[xAxisKey].data;
@@ -58,16 +74,45 @@ function MarkPlot(props) {
           throw new Error("Axis of id \"".concat(xAxisKey, "\" should have data property to be able to display a line plot"));
         }
         return xData == null ? void 0 : xData.map(function (x, index) {
-          var y = stackedData[index][1];
+          var value = data[index] == null ? null : stackedData[index][1];
           return {
             x: xScale(x),
-            y: yScale(y),
+            y: value === null ? null : yScale(value),
+            position: x,
+            value: value,
             index: index
           };
-        }).filter(isInRange).map(function (_ref3) {
+        }).filter(function (_ref3) {
           var x = _ref3.x,
             y = _ref3.y,
-            index = _ref3.index;
+            index = _ref3.index,
+            position = _ref3.position,
+            value = _ref3.value;
+          if (value === null || y === null) {
+            // Remove missing data point
+            return false;
+          }
+          if (!isInRange({
+            x: x,
+            y: y
+          })) {
+            // Remove out of range
+            return false;
+          }
+          if (showMark === true) {
+            return true;
+          }
+          return showMark({
+            x: x,
+            y: y,
+            index: index,
+            position: position,
+            value: value
+          });
+        }).map(function (_ref4) {
+          var x = _ref4.x,
+            y = _ref4.y,
+            index = _ref4.index;
           return /*#__PURE__*/_jsx(Mark, _extends({
             id: seriesId,
             dataIndex: index,

package/legacy/LineChart/formatter.js

@@ -22,7 +22,7 @@ var formatter = function formatter(params, dataset) {
           d3Dataset[index][id] = value;
         }
       });
-    } else if (dataset === undefined) {
+    } else if (dataset === undefined && process.env.NODE_ENV !== 'production') {
       throw new Error(["MUI: line series with id='".concat(id, "' has no data."), 'Either provide a data property to the series or use the dataset prop.'].join('\n'));
     }
   });
@@ -36,7 +36,11 @@ var formatter = function formatter(params, dataset) {
       // Use dataKey if needed and available
       var dataKey = series[id].dataKey;
       return series[id].data === undefined && dataKey !== undefined ? dataKey : id;
-    })).order(stackingOrder).offset(stackingOffset)(d3Dataset);
+    })).value(function (d, key) {
+      var _d$key;
+      return (_d$key = d[key]) != null ? _d$key : 0;
+    }) // defaultize null value to 0
+    .order(stackingOrder).offset(stackingOffset)(d3Dataset);
     ids.forEach(function (id, index) {
       var dataKey = series[id].dataKey;
       completedSeries[id] = _extends({}, series[id], {
@@ -56,7 +60,7 @@ var formatter = function formatter(params, dataset) {
     seriesOrder: seriesOrder,
     stackingGroups: stackingGroups,
     series: defaultizeValueFormatter(completedSeries, function (v) {
-      return v.toLocaleString();
+      return v == null ? void 0 : v.toLocaleString();
     })
   };
 };

package/legacy/LineChart/index.js

@@ -1,7 +1,9 @@
 export { LinePlot } from './LinePlot';
 export { AreaPlot } from './AreaPlot';
 export { MarkPlot } from './MarkPlot';
+export { LineHighlightPlot } from './LineHighlightPlot';
 export { LineChart } from './LineChart';
 export * from './AreaElement';
 export * from './LineElement';
-export * from './MarkElement';
+export * from './MarkElement';
+export * from './LineHighlightElement';