@mui/x-charts 7.7.0 → 7.8.0

package/modern/LineChart/useLineChartProps.js

@@ -0,0 +1,144 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import useId from '@mui/utils/useId';
+import { DEFAULT_X_AXIS_KEY } from '../constants';
+/**
+ * A helper function that extracts LineChartProps from the input props
+ * and returns an object with props for the children components of LineChart.
+ *
+ * @param props The input props for LineChart
+ * @returns An object with props for the children components of LineChart
+ */
+export const useLineChartProps = props => {
+  const {
+    xAxis,
+    yAxis,
+    series,
+    width,
+    height,
+    margin,
+    colors,
+    dataset,
+    sx,
+    tooltip,
+    onAxisClick,
+    onAreaClick,
+    onLineClick,
+    onMarkClick,
+    axisHighlight,
+    disableLineItemHighlight,
+    legend,
+    grid,
+    topAxis,
+    leftAxis,
+    rightAxis,
+    bottomAxis,
+    children,
+    slots,
+    slotProps,
+    skipAnimation,
+    loading,
+    highlightedItem,
+    onHighlightChange
+  } = props;
+  const id = useId();
+  const clipPathId = `${id}-clip-path`;
+  const chartContainerProps = {
+    series: series.map(s => _extends({
+      disableHighlight: !!disableLineItemHighlight,
+      type: 'line'
+    }, s)),
+    width,
+    height,
+    margin,
+    colors,
+    dataset,
+    xAxis: xAxis ?? [{
+      id: DEFAULT_X_AXIS_KEY,
+      scaleType: 'point',
+      data: Array.from({
+        length: Math.max(...series.map(s => (s.data ?? dataset ?? []).length))
+      }, (_, index) => index)
+    }],
+    yAxis,
+    sx,
+    highlightedItem,
+    onHighlightChange,
+    disableAxisListener: tooltip?.trigger !== 'axis' && axisHighlight?.x === 'none' && axisHighlight?.y === 'none' && !onAxisClick
+  };
+  const axisClickHandlerProps = {
+    onAxisClick
+  };
+  const gridProps = {
+    vertical: grid?.vertical,
+    horizontal: grid?.horizontal
+  };
+  const clipPathGroupProps = {
+    clipPath: `url(#${clipPathId})`
+  };
+  const clipPathProps = {
+    id: clipPathId
+  };
+  const areaPlotProps = {
+    slots,
+    slotProps,
+    onItemClick: onAreaClick,
+    skipAnimation
+  };
+  const linePlotProps = {
+    slots,
+    slotProps,
+    onItemClick: onLineClick,
+    skipAnimation
+  };
+  const markPlotProps = {
+    slots,
+    slotProps,
+    onItemClick: onMarkClick,
+    skipAnimation
+  };
+  const overlayProps = {
+    slots,
+    slotProps,
+    loading
+  };
+  const chartsAxisProps = {
+    topAxis,
+    leftAxis,
+    rightAxis,
+    bottomAxis,
+    slots,
+    slotProps
+  };
+  const axisHighlightProps = _extends({
+    x: 'line'
+  }, axisHighlight);
+  const lineHighlightPlotProps = {
+    slots,
+    slotProps
+  };
+  const legendProps = _extends({}, legend, {
+    slots,
+    slotProps
+  });
+  const tooltipProps = _extends({}, tooltip, {
+    slots,
+    slotProps
+  });
+  return {
+    chartContainerProps,
+    axisClickHandlerProps,
+    gridProps,
+    clipPathProps,
+    clipPathGroupProps,
+    areaPlotProps,
+    linePlotProps,
+    markPlotProps,
+    overlayProps,
+    chartsAxisProps,
+    axisHighlightProps,
+    lineHighlightPlotProps,
+    legendProps,
+    tooltipProps,
+    children
+  };
+};

package/modern/ScatterChart/ScatterChart.js

@@ -11,6 +11,7 @@ import { ChartsAxisHighlight } from '../ChartsAxisHighlight';
 import { ChartsVoronoiHandler } from '../ChartsVoronoiHandler/ChartsVoronoiHandler';
 import { ChartsGrid } from '../ChartsGrid';
 import { ZAxisContextProvider } from '../context/ZAxisContextProvider';
+import { useScatterChartProps } from './useScatterChartProps';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * Demos:
@@ -24,81 +25,25 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 const ScatterChart = /*#__PURE__*/React.forwardRef(function ScatterChart(props, ref) {
   const {
-    xAxis,
-    yAxis,
-    zAxis,
-    series,
-    tooltip,
-    axisHighlight,
-    voronoiMaxRadius,
-    disableVoronoi,
-    legend,
-    width,
-    height,
-    margin,
-    colors,
-    sx,
-    grid,
-    topAxis,
-    leftAxis,
-    rightAxis,
-    bottomAxis,
-    onItemClick,
-    children,
-    slots,
-    slotProps,
-    loading,
-    highlightedItem,
-    onHighlightChange
-  } = props;
-  return /*#__PURE__*/_jsx(ResponsiveChartContainer, {
-    ref: ref,
-    series: series.map(s => _extends({
-      type: 'scatter'
-    }, s)),
-    width: width,
-    height: height,
-    margin: margin,
-    colors: colors,
-    xAxis: xAxis,
-    yAxis: yAxis,
-    sx: sx,
-    highlightedItem: highlightedItem,
-    onHighlightChange: onHighlightChange,
-    children: /*#__PURE__*/_jsxs(ZAxisContextProvider, {
-      zAxis: zAxis,
-      children: [!disableVoronoi && /*#__PURE__*/_jsx(ChartsVoronoiHandler, {
-        voronoiMaxRadius: voronoiMaxRadius,
-        onItemClick: onItemClick
-      }), /*#__PURE__*/_jsx(ChartsAxis, {
-        topAxis: topAxis,
-        leftAxis: leftAxis,
-        rightAxis: rightAxis,
-        bottomAxis: bottomAxis,
-        slots: slots,
-        slotProps: slotProps
-      }), grid && /*#__PURE__*/_jsx(ChartsGrid, {
-        vertical: grid.vertical,
-        horizontal: grid.horizontal
-      }), /*#__PURE__*/_jsx(ScatterPlot, {
-        slots: slots,
-        slotProps: slotProps,
-        onItemClick: disableVoronoi ? onItemClick : undefined
-      }), /*#__PURE__*/_jsx(ChartsOverlay, {
-        loading: loading,
-        slots: slots,
-        slotProps: slotProps
-      }), /*#__PURE__*/_jsx(ChartsLegend, _extends({}, legend, {
-        slots: slots,
-        slotProps: slotProps
-      })), /*#__PURE__*/_jsx(ChartsAxisHighlight, _extends({
-        x: "none",
-        y: "none"
-      }, axisHighlight)), !loading && /*#__PURE__*/_jsx(ChartsTooltip, _extends({
-        trigger: "item"
-      }, tooltip)), children]
-    })
-  });
+    chartContainerProps,
+    zAxisProps,
+    voronoiHandlerProps,
+    chartsAxisProps,
+    gridProps,
+    scatterPlotProps,
+    overlayProps,
+    legendProps,
+    axisHighlightProps,
+    tooltipProps,
+    children
+  } = useScatterChartProps(props);
+  return /*#__PURE__*/_jsx(ResponsiveChartContainer, _extends({
+    ref: ref
+  }, chartContainerProps, {
+    children: /*#__PURE__*/_jsxs(ZAxisContextProvider, _extends({}, zAxisProps, {
+      children: [!props.disableVoronoi && /*#__PURE__*/_jsx(ChartsVoronoiHandler, _extends({}, voronoiHandlerProps)), /*#__PURE__*/_jsx(ChartsAxis, _extends({}, chartsAxisProps)), props.grid && /*#__PURE__*/_jsx(ChartsGrid, _extends({}, gridProps)), /*#__PURE__*/_jsx(ScatterPlot, _extends({}, scatterPlotProps)), /*#__PURE__*/_jsx(ChartsOverlay, _extends({}, overlayProps)), /*#__PURE__*/_jsx(ChartsLegend, _extends({}, legendProps)), /*#__PURE__*/_jsx(ChartsAxisHighlight, _extends({}, axisHighlightProps)), !props.loading && /*#__PURE__*/_jsx(ChartsTooltip, _extends({}, tooltipProps)), children]
+    }))
+  }));
 });
 process.env.NODE_ENV !== "production" ? ScatterChart.propTypes = {
   // ----------------------------- Warning --------------------------------

package/modern/ScatterChart/ScatterPlot.js

@@ -2,7 +2,7 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { Scatter } from './Scatter';
-import { CartesianContext } from '../context/CartesianContextProvider';
+import { useCartesianContext } from '../context/CartesianProvider';
 import getColor from './getColor';
 import { ZAxisContext } from '../context/ZAxisContextProvider';
 import { useScatterSeries } from '../hooks/useSeries';
@@ -24,7 +24,7 @@ function ScatterPlot(props) {
     onItemClick
   } = props;
   const seriesData = useScatterSeries();
-  const axisData = React.useContext(CartesianContext);
+  const axisData = useCartesianContext();
   const {
     zAxis,
     zAxisIds

package/modern/ScatterChart/useScatterChartProps.js

@@ -0,0 +1,108 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+/**
+ * A helper function that extracts ScatterChartProps from the input props
+ * and returns an object with props for the children components of ScatterChart.
+ *
+ * @param props The input props for ScatterChart
+ * @returns An object with props for the children components of ScatterChart
+ */
+export const useScatterChartProps = props => {
+  const {
+    xAxis,
+    yAxis,
+    zAxis,
+    series,
+    tooltip,
+    axisHighlight,
+    voronoiMaxRadius,
+    disableVoronoi,
+    legend,
+    width,
+    height,
+    margin,
+    colors,
+    sx,
+    grid,
+    topAxis,
+    leftAxis,
+    rightAxis,
+    bottomAxis,
+    onItemClick,
+    children,
+    slots,
+    slotProps,
+    loading,
+    highlightedItem,
+    onHighlightChange
+  } = props;
+  const chartContainerProps = {
+    series: series.map(s => _extends({
+      type: 'scatter'
+    }, s)),
+    width,
+    height,
+    margin,
+    colors,
+    xAxis,
+    yAxis,
+    sx,
+    highlightedItem,
+    onHighlightChange
+  };
+  const zAxisProps = {
+    zAxis
+  };
+  const voronoiHandlerProps = {
+    voronoiMaxRadius,
+    onItemClick: onItemClick
+  };
+  const chartsAxisProps = {
+    topAxis,
+    leftAxis,
+    rightAxis,
+    bottomAxis,
+    slots,
+    slotProps
+  };
+  const gridProps = {
+    vertical: grid?.vertical,
+    horizontal: grid?.horizontal
+  };
+  const scatterPlotProps = {
+    onItemClick: disableVoronoi ? onItemClick : undefined,
+    slots,
+    slotProps
+  };
+  const overlayProps = {
+    loading,
+    slots,
+    slotProps
+  };
+  const legendProps = _extends({}, legend, {
+    slots,
+    slotProps
+  });
+  const axisHighlightProps = _extends({
+    y: 'none',
+    x: 'none'
+  }, axisHighlight);
+  const tooltipProps = _extends({
+    trigger: 'item'
+  }, tooltip, {
+    slots,
+    slotProps
+  });
+  return {
+    chartContainerProps,
+    zAxisProps,
+    voronoiHandlerProps,
+    chartsAxisProps,
+    gridProps,
+    scatterPlotProps,
+    overlayProps,
+    legendProps,
+    axisHighlightProps,
+    tooltipProps,
+    children
+  };
+};

package/modern/context/CartesianProvider/CartesianContext.js

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export const CartesianContext = /*#__PURE__*/React.createContext({
+  isInitialized: false,
+  data: {
+    xAxis: {},
+    yAxis: {},
+    xAxisIds: [],
+    yAxisIds: []
+  }
+});
+if (process.env.NODE_ENV !== 'production') {
+  CartesianContext.displayName = 'CartesianContext';
+}

package/modern/context/CartesianProvider/CartesianProvider.js

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { useDrawingArea } from '../../hooks/useDrawingArea';
+import { useSeries } from '../../hooks/useSeries';
+import { CartesianContext } from './CartesianContext';
+import { normalizeAxis } from './normalizeAxis';
+import { computeValue } from './computeValue';
+import { jsx as _jsx } from "react/jsx-runtime";
+function CartesianContextProvider(props) {
+  const {
+    xAxis: inXAxis,
+    yAxis: inYAxis,
+    dataset,
+    xExtremumGetters,
+    yExtremumGetters,
+    children
+  } = props;
+  const formattedSeries = useSeries();
+  const drawingArea = useDrawingArea();
+  const xAxis = React.useMemo(() => normalizeAxis(inXAxis, dataset, 'x'), [inXAxis, dataset]);
+  const yAxis = React.useMemo(() => normalizeAxis(inYAxis, dataset, 'y'), [inYAxis, dataset]);
+  const xValues = React.useMemo(() => computeValue(drawingArea, formattedSeries, xAxis, xExtremumGetters, 'x'), [drawingArea, formattedSeries, xAxis, xExtremumGetters]);
+  const yValues = React.useMemo(() => computeValue(drawingArea, formattedSeries, yAxis, yExtremumGetters, 'y'), [drawingArea, formattedSeries, yAxis, yExtremumGetters]);
+  const value = React.useMemo(() => ({
+    isInitialized: true,
+    data: {
+      xAxis: xValues.axis,
+      yAxis: yValues.axis,
+      xAxisIds: xValues.axisIds,
+      yAxisIds: yValues.axisIds
+    }
+  }), [xValues, yValues]);
+  return /*#__PURE__*/_jsx(CartesianContext.Provider, {
+    value: value,
+    children: children
+  });
+}
+export { CartesianContextProvider };

package/modern/context/CartesianProvider/computeValue.js

@@ -0,0 +1,97 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { scaleBand, scalePoint, scaleTime } from 'd3-scale';
+import { DEFAULT_X_AXIS_KEY, DEFAULT_Y_AXIS_KEY } from '../../constants';
+import { isBandScaleConfig, isPointScaleConfig } from '../../models/axis';
+import { getColorScale, getOrdinalColorScale } from '../../internals/colorScale';
+import { getTickNumber } from '../../hooks/useTicks';
+import { getScale } from '../../internals/getScale';
+import { getAxisExtremum } from './getAxisExtremum';
+const getRange = (drawingArea, axisName, isReverse) => {
+  const range = axisName === 'x' ? [drawingArea.left, drawingArea.left + drawingArea.width] : [drawingArea.top + drawingArea.height, drawingArea.top];
+  return isReverse ? range.reverse() : range;
+};
+const isDateData = data => data?.[0] instanceof Date;
+function createDateFormatter(axis, range) {
+  const timeScale = scaleTime(axis.data, range);
+  return (v, {
+    location
+  }) => location === 'tick' ? timeScale.tickFormat(axis.tickNumber)(v) : `${v.toLocaleString()}`;
+}
+const DEFAULT_CATEGORY_GAP_RATIO = 0.2;
+const DEFAULT_BAR_GAP_RATIO = 0.1;
+export function computeValue(drawingArea, formattedSeries, inAxis, extremumGetters, axisName) {
+  const DEFAULT_AXIS_KEY = axisName === 'x' ? DEFAULT_X_AXIS_KEY : DEFAULT_Y_AXIS_KEY;
+  const allAxis = [...(inAxis?.map((axis, index) => _extends({
+    id: `defaultized-${axisName}-axis-${index}`
+  }, axis)) ?? []), ...(inAxis === undefined || inAxis.findIndex(({
+    id
+  }) => id === DEFAULT_AXIS_KEY) === -1 ? [{
+    id: DEFAULT_AXIS_KEY,
+    scaleType: 'linear'
+  }] : [])];
+  const completeAxis = {};
+  allAxis.forEach((axis, axisIndex) => {
+    const isDefaultAxis = axisIndex === 0;
+    const [minData, maxData] = getAxisExtremum(axis, extremumGetters, isDefaultAxis, formattedSeries);
+    const range = getRange(drawingArea, axisName, axis.reverse);
+    if (isBandScaleConfig(axis)) {
+      const categoryGapRatio = axis.categoryGapRatio ?? DEFAULT_CATEGORY_GAP_RATIO;
+      const barGapRatio = axis.barGapRatio ?? DEFAULT_BAR_GAP_RATIO;
+      // Reverse range because ordinal scales are presented from top to bottom on y-axis
+      const scaleRange = axisName === 'x' ? range : [range[1], range[0]];
+      completeAxis[axis.id] = _extends({
+        categoryGapRatio,
+        barGapRatio
+      }, axis, {
+        scale: scaleBand(axis.data, scaleRange).paddingInner(categoryGapRatio).paddingOuter(categoryGapRatio / 2),
+        tickNumber: axis.data.length,
+        colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? getOrdinalColorScale(_extends({
+          values: axis.data
+        }, axis.colorMap)) : getColorScale(axis.colorMap))
+      });
+      if (isDateData(axis.data)) {
+        const dateFormatter = createDateFormatter(axis, scaleRange);
+        completeAxis[axis.id].valueFormatter = axis.valueFormatter ?? dateFormatter;
+      }
+    }
+    if (isPointScaleConfig(axis)) {
+      const scaleRange = axisName === 'x' ? range : [...range].reverse();
+      completeAxis[axis.id] = _extends({}, axis, {
+        scale: scalePoint(axis.data, scaleRange),
+        tickNumber: axis.data.length,
+        colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? getOrdinalColorScale(_extends({
+          values: axis.data
+        }, axis.colorMap)) : getColorScale(axis.colorMap))
+      });
+      if (isDateData(axis.data)) {
+        const dateFormatter = createDateFormatter(axis, scaleRange);
+        completeAxis[axis.id].valueFormatter = axis.valueFormatter ?? dateFormatter;
+      }
+    }
+    if (axis.scaleType === 'band' || axis.scaleType === 'point') {
+      // Could be merged with the two previous "if conditions" but then TS does not get that `axis.scaleType` can't be `band` or `point`.
+      return;
+    }
+    const scaleType = axis.scaleType ?? 'linear';
+    const extremums = [axis.min ?? minData, axis.max ?? maxData];
+    const tickNumber = getTickNumber(_extends({}, axis, {
+      range,
+      domain: extremums
+    }));
+    const scale = getScale(scaleType, extremums, range).nice(tickNumber);
+    const [minDomain, maxDomain] = scale.domain();
+    const domain = [axis.min ?? minDomain, axis.max ?? maxDomain];
+    completeAxis[axis.id] = _extends({}, axis, {
+      scaleType: scaleType,
+      scale: scale.domain(domain),
+      tickNumber,
+      colorScale: axis.colorMap && getColorScale(axis.colorMap)
+    });
+  });
+  return {
+    axis: completeAxis,
+    axisIds: allAxis.map(({
+      id
+    }) => id)
+  };
+}

package/modern/context/CartesianProvider/getAxisExtremum.js

@@ -0,0 +1,21 @@
+const axisExtremumCallback = (acc, chartType, axis, getters, isDefaultAxis, formattedSeries) => {
+  const getter = getters[chartType];
+  const series = formattedSeries[chartType]?.series ?? {};
+  const [minChartTypeData, maxChartTypeData] = getter?.({
+    series,
+    axis,
+    isDefaultAxis
+  }) ?? [null, null];
+  const [minData, maxData] = acc;
+  if (minData === null || maxData === null) {
+    return [minChartTypeData, maxChartTypeData];
+  }
+  if (minChartTypeData === null || maxChartTypeData === null) {
+    return [minData, maxData];
+  }
+  return [Math.min(minChartTypeData, minData), Math.max(maxChartTypeData, maxData)];
+};
+export const getAxisExtremum = (axis, getters, isDefaultAxis, formattedSeries) => {
+  const charTypes = Object.keys(getters);
+  return charTypes.reduce((acc, charType) => axisExtremumCallback(acc, charType, axis, getters, isDefaultAxis, formattedSeries), [null, null]);
+};

package/modern/context/CartesianProvider/index.js

@@ -0,0 +1,10 @@
+import { computeValue } from './computeValue';
+import { normalizeAxis } from './normalizeAxis';
+export * from './CartesianProvider';
+export * from './CartesianContext';
+export * from './useCartesianContext';
+const cartesianProviderUtils = {
+  computeValue,
+  normalizeAxis
+};
+export { cartesianProviderUtils };

package/modern/context/CartesianProvider/normalizeAxis.js

@@ -0,0 +1,15 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+export const normalizeAxis = (axis, dataset, axisName) => {
+  return axis?.map(axisConfig => {
+    const dataKey = axisConfig.dataKey;
+    if (dataKey === undefined || axisConfig.data !== undefined) {
+      return axisConfig;
+    }
+    if (dataset === undefined) {
+      throw Error(`MUI X Charts: ${axisName}-axis uses \`dataKey\` but no \`dataset\` is provided.`);
+    }
+    return _extends({}, axisConfig, {
+      data: dataset.map(d => d[dataKey])
+    });
+  });
+};

package/modern/context/CartesianProvider/useCartesianContext.js

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { CartesianContext } from './CartesianContext';
+export const useCartesianContext = () => {
+  const {
+    data
+  } = React.useContext(CartesianContext);
+  return data;
+};

package/modern/hooks/useAxisEvents.js

@@ -1,8 +1,8 @@
 import * as React from 'react';
 import { InteractionContext } from '../context/InteractionProvider';
-import { CartesianContext } from '../context/CartesianContextProvider';
+import { useCartesianContext } from '../context/CartesianProvider';
 import { isBandScale } from '../internals/isBandScale';
-import { getSVGPoint } from '../internals/utils';
+import { getSVGPoint } from '../internals/getSVGPoint';
 import { useSvgRef } from './useSvgRef';
 import { useDrawingArea } from './useDrawingArea';
 function getAsANumber(value) {
@@ -21,7 +21,7 @@ export const useAxisEvents = disableAxisListener => {
     yAxis,
     xAxisIds,
     yAxisIds
-  } = React.useContext(CartesianContext);
+  } = useCartesianContext();
   const {
     dispatch
   } = React.useContext(InteractionContext);
@@ -38,10 +38,7 @@ export const useAxisEvents = disableAxisListener => {
     if (element === null || disableAxisListener) {
       return () => {};
     }
-    const getUpdate = (axisConfig, mouseValue) => {
-      if (usedXAxis === null) {
-        return null;
-      }
+    function getNewAxisState(axisConfig, mouseValue) {
       const {
         scale,
         data: axisData,
@@ -89,7 +86,7 @@ export const useAxisEvents = disableAxisListener => {
         index: dataIndex,
         value: axisData[dataIndex]
       };
-    };
+    }
     const handleOut = () => {
       mousePosition.current = {
         x: -1,
@@ -114,8 +111,8 @@ export const useAxisEvents = disableAxisListener => {
         });
         return;
       }
-      const newStateX = getUpdate(xAxis[usedXAxis], svgPoint.x);
-      const newStateY = getUpdate(yAxis[usedYAxis], svgPoint.y);
+      const newStateX = getNewAxisState(xAxis[usedXAxis], svgPoint.x);
+      const newStateY = getNewAxisState(yAxis[usedYAxis], svgPoint.y);
       dispatch({
         type: 'updateAxis',
         data: {

package/modern/hooks/useColorScale.js

@@ -1,11 +1,11 @@
 import * as React from 'react';
-import { CartesianContext } from '../context/CartesianContextProvider';
+import { useCartesianContext } from '../context/CartesianProvider';
 import { ZAxisContext } from '../context/ZAxisContextProvider';
 export function useXColorScale(identifier) {
   const {
     xAxis,
     xAxisIds
-  } = React.useContext(CartesianContext);
+  } = useCartesianContext();
   const id = typeof identifier === 'string' ? identifier : xAxisIds[identifier ?? 0];
   return xAxis[id].colorScale;
 }
@@ -13,7 +13,7 @@ export function useYColorScale(identifier) {
   const {
     yAxis,
     yAxisIds
-  } = React.useContext(CartesianContext);
+  } = useCartesianContext();
   const id = typeof identifier === 'string' ? identifier : yAxisIds[identifier ?? 0];
   return yAxis[id].colorScale;
 }