@mui/x-charts 8.0.0-alpha.8 → 8.0.0-beta.0

package/internals/plugins/featurePlugins/useChartCartesianAxis/useChartCartesianAxis.selectors.js

@@ -1,87 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { selectorChartDrawingArea } from "../../corePlugins/useChartDimensions/index.js";
-import { selectorChartSeriesConfig, selectorChartSeriesProcessed } from "../../corePlugins/useChartSeries/index.js";
-import { createSelector } from "../../utils/selectors.js";
-import { computeAxisValue } from "./computeAxisValue.js";
-import { createAxisFilterMapper, createGetAxisFilters } from "./createAxisFilterMapper.js";
-export const createZoomMap = zoom => {
-  const zoomItemMap = new Map();
-  zoom.forEach(zoomItem => {
-    zoomItemMap.set(zoomItem.axisId, zoomItem);
-  });
-  return zoomItemMap;
-};
-export const selectorChartCartesianAxisState = state => state.cartesianAxis;
-const selectorChartZoomState = state => state.zoom;
-export const selectorChartRawXAxis = createSelector(selectorChartCartesianAxisState, axis => axis?.x);
-export const selectorChartRawYAxis = createSelector(selectorChartCartesianAxisState, axis => axis?.y);
-
-/**
- * Following selectors are not exported because they exist in the MIT chart only to ba able to reuse the Zoom state from the pro.
- */
-
-const selectorChartZoomMap = createSelector(selectorChartZoomState, zoom => zoom?.zoomData && createZoomMap(zoom?.zoomData));
-const selectorChartZoomOptionsLookup = createSelector(selectorChartZoomState, zoom => zoom?.optionsLookup);
-const selectorChartXFilter = createSelector([selectorChartZoomMap, selectorChartZoomOptionsLookup, selectorChartSeriesConfig, selectorChartSeriesProcessed], (zoomMap, zoomOptions, seriesConfig, formattedSeries) => zoomMap && zoomOptions && createAxisFilterMapper({
-  zoomMap,
-  zoomOptions,
-  seriesConfig,
-  formattedSeries,
-  direction: 'x'
-}));
-const selectorChartYFilter = createSelector([selectorChartZoomMap, selectorChartZoomOptionsLookup, selectorChartSeriesConfig, selectorChartSeriesProcessed], (zoomMap, zoomOptions, seriesConfig, formattedSeries) => zoomMap && zoomOptions && createAxisFilterMapper({
-  zoomMap,
-  zoomOptions,
-  seriesConfig,
-  formattedSeries,
-  direction: 'y'
-}));
-const selectorChartZoomAxisFilters = createSelector([selectorChartXFilter, selectorChartYFilter, selectorChartRawXAxis, selectorChartRawYAxis], (xMapper, yMapper, xAxis, yAxis) => {
-  if (xMapper === undefined || yMapper === undefined) {
-    // Early return if there is no zoom.
-    return undefined;
-  }
-  const xFilters = xAxis.reduce((acc, axis, index) => {
-    const filter = xMapper(axis, index);
-    if (filter !== null) {
-      acc[axis.id] = filter;
-    }
-    return acc;
-  }, {});
-  const yFilters = yAxis.reduce((acc, axis, index) => {
-    const filter = yMapper(axis, index);
-    if (filter !== null) {
-      acc[axis.id] = filter;
-    }
-    return acc;
-  }, {});
-  if (Object.keys(xFilters).length === 0 && Object.keys(yFilters).length === 0) {
-    return undefined;
-  }
-  return createGetAxisFilters(_extends({}, xFilters, yFilters));
-});
-
-/**
- * The only interesting selectors that merge axis data and zoom if provided.
- */
-
-export const selectorChartXAxis = createSelector([selectorChartRawXAxis, selectorChartDrawingArea, selectorChartSeriesProcessed, selectorChartSeriesConfig, selectorChartZoomMap, selectorChartZoomOptionsLookup, selectorChartZoomAxisFilters], (axis, drawingArea, formattedSeries, seriesConfig, zoomMap, zoomOptions, getFilters) => computeAxisValue({
-  drawingArea,
-  formattedSeries,
-  axis,
-  seriesConfig,
-  axisDirection: 'x',
-  zoomMap,
-  zoomOptions,
-  getFilters
-}));
-export const selectorChartYAxis = createSelector([selectorChartRawYAxis, selectorChartDrawingArea, selectorChartSeriesProcessed, selectorChartSeriesConfig, selectorChartZoomMap, selectorChartZoomOptionsLookup, selectorChartZoomAxisFilters], (axis, drawingArea, formattedSeries, seriesConfig, zoomMap, zoomOptions, getFilters) => computeAxisValue({
-  drawingArea,
-  formattedSeries,
-  axis,
-  seriesConfig,
-  axisDirection: 'y',
-  zoomMap,
-  zoomOptions,
-  getFilters
-}));

package/internals/plugins/models/seriesConfig/extremumGetter.types.d.ts

@@ -1,22 +0,0 @@
-import type { CartesianChartSeriesType, ChartSeriesDefaultized } from '../../../../models/seriesType/config';
-import type { AxisConfig, AxisId } from '../../../../models/axis';
-import type { SeriesId } from '../../../../models/seriesType/common';
-type CartesianExtremumGetterParams<TSeriesType extends CartesianChartSeriesType> = {
-    series: Record<SeriesId, ChartSeriesDefaultized<TSeriesType>>;
-    axis: AxisConfig;
-    axisIndex: number;
-    isDefaultAxis: boolean;
-    getFilters?: (params: {
-        currentAxisId: AxisId | undefined;
-        seriesXAxisId?: AxisId;
-        seriesYAxisId?: AxisId;
-        isDefaultAxis: boolean;
-    }) => CartesianExtremumFilter;
-};
-export type CartesianExtremumGetterResult = [number, number];
-export type CartesianExtremumGetter<TSeriesType extends CartesianChartSeriesType> = (params: CartesianExtremumGetterParams<TSeriesType>) => CartesianExtremumGetterResult;
-export type CartesianExtremumFilter = (value: {
-    x: number | Date | string | null;
-    y: number | Date | string | null;
-}, dataIndex: number) => boolean;
-export {};

package/models/layout.d.ts

@@ -1,18 +0,0 @@
-import { ChartMargin } from '../internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types';
-export interface CardinalDirections<T> {
-    top?: T;
-    bottom?: T;
-    left?: T;
-    right?: T;
-}
-export type LayoutConfig = {
-    width: number;
-    height: number;
-    /**
-     * The margin between the SVG and the drawing area.
-     * It's used for leaving some space for extra information such as the x- and y-axis or legend.
-     * Accepts an object with the optional properties: `top`, `bottom`, `left`, and `right`.
-     * @default object Depends on the charts type.
-     */
-    margin?: Partial<ChartMargin>;
-};

package/models/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": false,
-  "module": "./index.js",
-  "main": "../node/models/index.js",
-  "types": "./index.d.ts"
-}

package/modern/BarChart/formatter.js

@@ -1,73 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { stack as d3Stack } from '@mui/x-charts-vendor/d3-shape';
-import { warnOnce } from '@mui/x-internals/warning';
-import { getStackingGroups } from "../internals/stackSeries.js";
-import { defaultizeValueFormatter } from "../internals/defaultizeValueFormatter.js";
-const formatter = (params, dataset) => {
-  const {
-    seriesOrder,
-    series
-  } = params;
-  const stackingGroups = getStackingGroups(params);
-
-  // Create a data set with format adapted to d3
-  const d3Dataset = dataset ?? [];
-  seriesOrder.forEach(id => {
-    const data = series[id].data;
-    if (data !== undefined) {
-      data.forEach((value, index) => {
-        if (d3Dataset.length <= index) {
-          d3Dataset.push({
-            [id]: value
-          });
-        } else {
-          d3Dataset[index][id] = value;
-        }
-      });
-    } else if (dataset === undefined) {
-      throw new Error([`MUI X: bar series with id='${id}' has no data.`, 'Either provide a data property to the series or use the dataset prop.'].join('\n'));
-    }
-  });
-  const completedSeries = {};
-  stackingGroups.forEach(stackingGroup => {
-    const {
-      ids,
-      stackingOffset,
-      stackingOrder
-    } = stackingGroup;
-    // Get stacked values, and derive the domain
-    const stackedSeries = d3Stack().keys(ids.map(id => {
-      // Use dataKey if needed and available
-      const dataKey = series[id].dataKey;
-      return series[id].data === undefined && dataKey !== undefined ? dataKey : id;
-    })).value((d, key) => d[key] ?? 0) // defaultize null value to 0
-    .order(stackingOrder).offset(stackingOffset)(d3Dataset);
-    ids.forEach((id, index) => {
-      const dataKey = series[id].dataKey;
-      completedSeries[id] = _extends({
-        layout: 'vertical',
-        labelMarkType: 'square'
-      }, series[id], {
-        data: dataKey ? dataset.map(data => {
-          const value = data[dataKey];
-          if (typeof value !== 'number') {
-            if (process.env.NODE_ENV !== 'production') {
-              if (value !== null) {
-                warnOnce([`MUI X: your dataset key "${dataKey}" is used for plotting bars, but contains nonnumerical elements.`, 'Bar plots only support numbers and null values.']);
-              }
-            }
-            return 0;
-          }
-          return value;
-        }) : series[id].data,
-        stackedData: stackedSeries[index].map(([a, b]) => [a, b])
-      });
-    });
-  });
-  return {
-    seriesOrder,
-    stackingGroups,
-    series: defaultizeValueFormatter(completedSeries, v => v == null ? '' : v.toLocaleString())
-  };
-};
-export default formatter;

package/modern/BarChart/legend.js

@@ -1,22 +0,0 @@
-import { getLabel } from "../internals/getLabel.js";
-const legendGetter = params => {
-  const {
-    seriesOrder,
-    series
-  } = params;
-  return seriesOrder.reduce((acc, seriesId) => {
-    const formattedLabel = getLabel(series[seriesId].label, 'legend');
-    if (formattedLabel === undefined) {
-      return acc;
-    }
-    acc.push({
-      markType: series[seriesId].labelMarkType,
-      id: seriesId,
-      seriesId,
-      color: series[seriesId].color,
-      label: formattedLabel
-    });
-    return acc;
-  }, []);
-};
-export default legendGetter;

package/modern/BarChart/plugin.js

@@ -1,9 +0,0 @@
-import { getExtremumX, getExtremumY } from "./extremums.js";
-import formatter from "./formatter.js";
-import getColor from "./getColor.js";
-export const plugin = {
-  seriesProcessor: formatter,
-  colorProcessor: getColor,
-  xExtremumGetter: getExtremumX,
-  yExtremumGetter: getExtremumY
-};

package/modern/ChartsOnAxisClickHandler/ChartsOnAxisClickHandler.js

@@ -1,82 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import { useSeries } from "../hooks/useSeries.js";
-import { useSvgRef, useXAxes, useYAxes } from "../hooks/index.js";
-import { useStore } from "../internals/store/useStore.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-function ChartsOnAxisClickHandler(props) {
-  const {
-    onAxisClick
-  } = props;
-  const svgRef = useSvgRef();
-  const series = useSeries();
-  const store = useStore();
-  const {
-    xAxis,
-    xAxisIds
-  } = useXAxes();
-  const {
-    yAxis,
-    yAxisIds
-  } = useYAxes();
-  React.useEffect(() => {
-    const element = svgRef.current;
-    if (element === null || !onAxisClick) {
-      return () => {};
-    }
-    const handleMouseClick = event => {
-      event.preventDefault();
-      const {
-        x: axisX,
-        y: axisY
-      } = store.value.interaction.axis;
-      const isXaxis = axisX && axisX.index !== -1;
-      const USED_AXIS_ID = isXaxis ? xAxisIds[0] : yAxisIds[0];
-      const dataIndex = isXaxis ? axisX && axisX.index : axisY && axisY.index;
-      if (dataIndex == null) {
-        return;
-      }
-      const seriesValues = {};
-      Object.keys(series).filter(seriesType => ['bar', 'line'].includes(seriesType)).forEach(seriesType => {
-        series[seriesType]?.seriesOrder.forEach(seriesId => {
-          const seriesItem = series[seriesType].series[seriesId];
-          const providedXAxisId = seriesItem.xAxisId;
-          const providedYAxisId = seriesItem.yAxisId;
-          const axisKey = isXaxis ? providedXAxisId : providedYAxisId;
-          if (axisKey === undefined || axisKey === USED_AXIS_ID) {
-            seriesValues[seriesId] = seriesItem.data[dataIndex];
-          }
-        });
-      });
-      const axisValue = (isXaxis ? xAxis : yAxis)[USED_AXIS_ID].data?.[dataIndex];
-      onAxisClick(event, {
-        dataIndex,
-        axisValue,
-        seriesValues
-      });
-    };
-    element.addEventListener('click', handleMouseClick);
-    return () => {
-      element.removeEventListener('click', handleMouseClick);
-    };
-  }, [onAxisClick, series, store, 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 "pnpm 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/modern/ChartsOnAxisClickHandler/index.js

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

package/modern/ChartsVoronoiHandler/ChartsVoronoiHandler.js

@@ -1,254 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import { Delaunay } from '@mui/x-charts-vendor/d3-delaunay';
-import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
-import { getValueToPositionMapper } from "../hooks/useScale.js";
-import { useStore } from "../internals/store/useStore.js";
-import { getSVGPoint } from "../internals/getSVGPoint.js";
-import { useHighlighted } from "../context/HighlightedProvider/index.js";
-import { useScatterSeries } from "../hooks/useSeries.js";
-import { useChartContext } from "../context/ChartProvider/useChartContext.js";
-import { useDrawingArea } from "../hooks/useDrawingArea.js";
-import { useSvgRef } from "../hooks/useSvgRef.js";
-import { useXAxes, useYAxes } from "../hooks/index.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-function ChartsVoronoiHandler(props) {
-  const {
-    voronoiMaxRadius,
-    onItemClick
-  } = props;
-  const svgRef = useSvgRef();
-  const drawingArea = useDrawingArea();
-  const {
-    instance
-  } = useChartContext();
-  const {
-    xAxis,
-    xAxisIds
-  } = useXAxes();
-  const {
-    yAxis,
-    yAxisIds
-  } = useYAxes();
-  const store = useStore();
-  const {
-    series,
-    seriesOrder
-  } = useScatterSeries() ?? {};
-  const voronoiRef = React.useRef({});
-  const delauneyRef = React.useRef(undefined);
-  const lastFind = React.useRef(undefined);
-  const {
-    setHighlighted,
-    clearHighlighted
-  } = useHighlighted();
-  const defaultXAxisId = xAxisIds[0];
-  const defaultYAxisId = yAxisIds[0];
-  useEnhancedEffect(() => {
-    store.update(prev => _extends({}, prev, {
-      interaction: _extends({}, prev.interaction, {
-        useVoronoiInteraction: true
-      })
-    }));
-    return () => {
-      store.update(prev => _extends({}, prev, {
-        interaction: _extends({}, prev.interaction, {
-          useVoronoiInteraction: false
-        })
-      }));
-    };
-  }, [store]);
-  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;
-    }
-    voronoiRef.current = {};
-    let points = [];
-    seriesOrder.forEach(seriesId => {
-      const {
-        data,
-        xAxisId,
-        yAxisId
-      } = series[seriesId];
-      const xScale = xAxis[xAxisId ?? defaultXAxisId].scale;
-      const yScale = yAxis[yAxisId ?? defaultYAxisId].scale;
-      const getXPosition = getValueToPositionMapper(xScale);
-      const getYPosition = getValueToPositionMapper(yScale);
-      const seriesPoints = data.flatMap(({
-        x,
-        y
-      }) => {
-        const pointX = getXPosition(x);
-        const pointY = getYPosition(y);
-        if (!instance.isPointInside({
-          x: pointX,
-          y: pointY
-        })) {
-          // If the point is not displayed we move them to a trash coordinate.
-          // This avoids managing index mapping before/after filtering.
-          // The trash point is far enough such that any point in the drawing area will be closer to the mouse than the trash coordinate.
-          return [-drawingArea.width, -drawingArea.height];
-        }
-        return [pointX, pointY];
-      });
-      voronoiRef.current[seriesId] = {
-        seriesId,
-        startIndex: points.length,
-        endIndex: points.length + seriesPoints.length
-      };
-      points = points.concat(seriesPoints);
-    });
-    delauneyRef.current = new Delaunay(points);
-    lastFind.current = undefined;
-  }, [defaultXAxisId, defaultYAxisId, series, seriesOrder, xAxis, yAxis, drawingArea, instance]);
-  React.useEffect(() => {
-    if (svgRef.current === null) {
-      return undefined;
-    }
-    const element = svgRef.current;
-    function getClosestPoint(event) {
-      // Get mouse coordinate in global SVG space
-      const svgPoint = getSVGPoint(element, event);
-      if (!instance.isPointInside(svgPoint)) {
-        lastFind.current = undefined;
-        return 'outside-chart';
-      }
-      if (!delauneyRef.current) {
-        return 'no-point-found';
-      }
-      const closestPointIndex = delauneyRef.current.find(svgPoint.x, svgPoint.y, lastFind.current);
-      if (closestPointIndex === undefined) {
-        return 'no-point-found';
-      }
-      lastFind.current = closestPointIndex;
-      const closestSeries = Object.values(voronoiRef.current).find(value => {
-        return 2 * closestPointIndex >= value.startIndex && 2 * closestPointIndex < value.endIndex;
-      });
-      if (closestSeries === undefined) {
-        return 'no-point-found';
-      }
-      const dataIndex = (2 * closestPointIndex - voronoiRef.current[closestSeries.seriesId].startIndex) / 2;
-      if (voronoiMaxRadius !== undefined) {
-        const pointX = delauneyRef.current.points[2 * closestPointIndex];
-        const pointY = delauneyRef.current.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: closestSeries.seriesId,
-        dataIndex
-      };
-    }
-    const handleMouseLeave = () => {
-      store.update(prev => _extends({}, prev, {
-        interaction: _extends({}, prev.interaction, {
-          axis: {
-            x: null,
-            y: null
-          },
-          item: null
-        })
-      }));
-      clearHighlighted();
-    };
-    const handleMouseMove = event => {
-      const closestPoint = getClosestPoint(event);
-      if (closestPoint === 'outside-chart') {
-        store.update(prev => _extends({}, prev, {
-          interaction: _extends({}, prev.interaction, {
-            axis: {
-              x: null,
-              y: null
-            },
-            item: null
-          })
-        }));
-        clearHighlighted();
-        return;
-      }
-      if (closestPoint === 'outside-voronoi-max-radius' || closestPoint === 'no-point-found') {
-        store.update(prev => _extends({}, prev, {
-          interaction: _extends({}, prev.interaction, {
-            item: null
-          })
-        }));
-        clearHighlighted();
-        return;
-      }
-      const {
-        seriesId,
-        dataIndex
-      } = closestPoint;
-      store.update(prev => _extends({}, prev, {
-        interaction: _extends({}, prev.interaction, {
-          item: {
-            type: 'scatter',
-            seriesId,
-            dataIndex
-          }
-        })
-      }));
-      setHighlighted({
-        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('pointerleave', handleMouseLeave);
-    element.addEventListener('pointermove', handleMouseMove);
-    element.addEventListener('click', handleMouseClick);
-    return () => {
-      element.removeEventListener('pointerleave', handleMouseLeave);
-      element.removeEventListener('pointermove', handleMouseMove);
-      element.removeEventListener('click', handleMouseClick);
-    };
-  }, [svgRef, yAxis, xAxis, voronoiMaxRadius, onItemClick, setHighlighted, clearHighlighted, drawingArea, store, instance]);
-
-  // 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 "pnpm proptypes"  |
-  // ----------------------------------------------------------------------
-  /**
-   * Callback fired when clicking on a scatter item.
-   * @param {MouseEvent} event Mouse event caught at the svg level
-   * @param {ScatterItemIdentifier} scatterItemIdentifier Identify which 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.
-   */
-  voronoiMaxRadius: PropTypes.number
-} : void 0;
-export { ChartsVoronoiHandler };

package/modern/ChartsVoronoiHandler/index.js

@@ -1 +0,0 @@
-export * from "./ChartsVoronoiHandler.js";

package/modern/LineChart/formatter.js

@@ -1,77 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { stack as d3Stack } from '@mui/x-charts-vendor/d3-shape';
-import { warnOnce } from '@mui/x-internals/warning';
-import { getStackingGroups } from "../internals/stackSeries.js";
-import { defaultizeValueFormatter } from "../internals/defaultizeValueFormatter.js";
-// For now it's a copy past of bar charts formatter, but maybe will diverge later
-const formatter = (params, dataset) => {
-  const {
-    seriesOrder,
-    series
-  } = params;
-  const stackingGroups = getStackingGroups(_extends({}, params, {
-    defaultStrategy: {
-      stackOffset: 'none'
-    }
-  }));
-
-  // Create a data set with format adapted to d3
-  const d3Dataset = dataset ?? [];
-  seriesOrder.forEach(id => {
-    const data = series[id].data;
-    if (data !== undefined) {
-      data.forEach((value, index) => {
-        if (d3Dataset.length <= index) {
-          d3Dataset.push({
-            [id]: value
-          });
-        } else {
-          d3Dataset[index][id] = value;
-        }
-      });
-    } else if (dataset === undefined && process.env.NODE_ENV !== 'production') {
-      throw new Error([`MUI X: line series with id='${id}' has no data.`, 'Either provide a data property to the series or use the dataset prop.'].join('\n'));
-    }
-  });
-  const completedSeries = {};
-  stackingGroups.forEach(stackingGroup => {
-    // Get stacked values, and derive the domain
-    const {
-      ids,
-      stackingOrder,
-      stackingOffset
-    } = stackingGroup;
-    const stackedSeries = d3Stack().keys(ids.map(id => {
-      // Use dataKey if needed and available
-      const dataKey = series[id].dataKey;
-      return series[id].data === undefined && dataKey !== undefined ? dataKey : id;
-    })).value((d, key) => d[key] ?? 0) // defaultize null value to 0
-    .order(stackingOrder).offset(stackingOffset)(d3Dataset);
-    ids.forEach((id, index) => {
-      const dataKey = series[id].dataKey;
-      completedSeries[id] = _extends({
-        labelMarkType: 'line'
-      }, series[id], {
-        data: dataKey ? dataset.map(data => {
-          const value = data[dataKey];
-          if (typeof value !== 'number') {
-            if (process.env.NODE_ENV !== 'production') {
-              if (value !== null) {
-                warnOnce([`MUI X: Your dataset key "${dataKey}" is used for plotting line, but contains nonnumerical elements.`, 'Line plots only support numbers and null values.']);
-              }
-            }
-            return null;
-          }
-          return value;
-        }) : series[id].data,
-        stackedData: stackedSeries[index].map(([a, b]) => [a, b])
-      });
-    });
-  });
-  return {
-    seriesOrder,
-    stackingGroups,
-    series: defaultizeValueFormatter(completedSeries, v => v == null ? '' : v.toLocaleString())
-  };
-};
-export default formatter;

package/modern/LineChart/legend.js

@@ -1,22 +0,0 @@
-import { getLabel } from "../internals/getLabel.js";
-const legendGetter = params => {
-  const {
-    seriesOrder,
-    series
-  } = params;
-  return seriesOrder.reduce((acc, seriesId) => {
-    const formattedLabel = getLabel(series[seriesId].label, 'legend');
-    if (formattedLabel === undefined) {
-      return acc;
-    }
-    acc.push({
-      markType: series[seriesId].labelMarkType,
-      id: seriesId,
-      seriesId,
-      color: series[seriesId].color,
-      label: formattedLabel
-    });
-    return acc;
-  }, []);
-};
-export default legendGetter;