@mui/x-charts 7.1.1 → 7.3.0

package/esm/ScatterChart/ScatterChart.js

@@ -328,11 +328,26 @@ process.env.NODE_ENV !== "production" ? ScatterChart.propTypes = {
   width: PropTypes.number,
   /**
    * The configuration of the x-axes.
-   * If not provided, a default axis config is used with id set to `DEFAULT_X_AXIS_KEY`.
+   * If not provided, a default axis config is used.
    */
   xAxis: PropTypes.arrayOf(PropTypes.shape({
     axisId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
     classes: PropTypes.object,
+    colorMap: PropTypes.oneOfType([PropTypes.shape({
+      color: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string.isRequired), PropTypes.func]).isRequired,
+      max: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
+      min: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
+      type: PropTypes.oneOf(['continuous']).isRequired
+    }), PropTypes.shape({
+      colors: PropTypes.arrayOf(PropTypes.string).isRequired,
+      thresholds: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired).isRequired,
+      type: PropTypes.oneOf(['piecewise']).isRequired
+    }), PropTypes.shape({
+      colors: PropTypes.arrayOf(PropTypes.string).isRequired,
+      type: PropTypes.oneOf(['ordinal']).isRequired,
+      unknownColor: PropTypes.string,
+      values: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.string]).isRequired)
+    })]),
     data: PropTypes.array,
     dataKey: PropTypes.string,
     disableLine: PropTypes.bool,
@@ -365,11 +380,26 @@ process.env.NODE_ENV !== "production" ? ScatterChart.propTypes = {
   })),
   /**
    * The configuration of the y-axes.
-   * If not provided, a default axis config is used with id set to `DEFAULT_Y_AXIS_KEY`.
+   * If not provided, a default axis config is used.
    */
   yAxis: PropTypes.arrayOf(PropTypes.shape({
     axisId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
     classes: PropTypes.object,
+    colorMap: PropTypes.oneOfType([PropTypes.shape({
+      color: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string.isRequired), PropTypes.func]).isRequired,
+      max: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
+      min: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
+      type: PropTypes.oneOf(['continuous']).isRequired
+    }), PropTypes.shape({
+      colors: PropTypes.arrayOf(PropTypes.string).isRequired,
+      thresholds: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired).isRequired,
+      type: PropTypes.oneOf(['piecewise']).isRequired
+    }), PropTypes.shape({
+      colors: PropTypes.arrayOf(PropTypes.string).isRequired,
+      type: PropTypes.oneOf(['ordinal']).isRequired,
+      unknownColor: PropTypes.string,
+      values: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.string]).isRequired)
+    })]),
     data: PropTypes.array,
     dataKey: PropTypes.string,
     disableLine: PropTypes.bool,

package/esm/ScatterChart/ScatterPlot.js

@@ -4,6 +4,7 @@ import PropTypes from 'prop-types';
 import { Scatter } from './Scatter';
 import { SeriesContext } from '../context/SeriesContextProvider';
 import { CartesianContext } from '../context/CartesianContextProvider';
+import getColor from './getColor';
 import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * Demos:
@@ -48,12 +49,14 @@ function ScatterPlot(props) {
         markerSize,
         color
       } = series[seriesId];
+      const colorGetter = getColor(series[seriesId], xAxis[xAxisKey ?? defaultXAxisId], yAxis[yAxisKey ?? defaultYAxisId]);
       const xScale = xAxis[xAxisKey ?? defaultXAxisId].scale;
       const yScale = yAxis[yAxisKey ?? defaultYAxisId].scale;
       return /*#__PURE__*/_jsx(ScatterItems, _extends({
         xScale: xScale,
         yScale: yScale,
         color: color,
+        colorGetter: colorGetter,
         markerSize: markerSize ?? 4,
         series: series[seriesId],
         onItemClick: onItemClick

package/esm/ScatterChart/getColor.js

@@ -0,0 +1,25 @@
+export default function getColor(series, xAxis, yAxis) {
+  const yColorScale = yAxis.colorScale;
+  const xColorScale = xAxis.colorScale;
+  if (yColorScale) {
+    return dataIndex => {
+      const value = series.data[dataIndex];
+      const color = value === null ? series.color : yColorScale(value.y);
+      if (color === null) {
+        return series.color;
+      }
+      return color;
+    };
+  }
+  if (xColorScale) {
+    return dataIndex => {
+      const value = series.data[dataIndex];
+      const color = value === null ? series.color : xColorScale(value.x);
+      if (color === null) {
+        return series.color;
+      }
+      return color;
+    };
+  }
+  return () => series.color;
+}

package/esm/SparkLineChart/SparkLineChart.js

@@ -226,6 +226,21 @@ process.env.NODE_ENV !== "production" ? SparkLineChart.propTypes = {
   xAxis: PropTypes.shape({
     axisId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
     classes: PropTypes.object,
+    colorMap: PropTypes.oneOfType([PropTypes.shape({
+      color: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string.isRequired), PropTypes.func]).isRequired,
+      max: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
+      min: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
+      type: PropTypes.oneOf(['continuous']).isRequired
+    }), PropTypes.shape({
+      colors: PropTypes.arrayOf(PropTypes.string).isRequired,
+      thresholds: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired).isRequired,
+      type: PropTypes.oneOf(['piecewise']).isRequired
+    }), PropTypes.shape({
+      colors: PropTypes.arrayOf(PropTypes.string).isRequired,
+      type: PropTypes.oneOf(['ordinal']).isRequired,
+      unknownColor: PropTypes.string,
+      values: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.string]).isRequired)
+    })]),
     data: PropTypes.array,
     dataKey: PropTypes.string,
     disableLine: PropTypes.bool,

package/esm/context/CartesianContextProvider.js

@@ -6,10 +6,11 @@ import { getExtremumX as getScatterExtremumX, getExtremumY as getScatterExtremum
 import { getExtremumX as getLineExtremumX, getExtremumY as getLineExtremumY } from '../LineChart/extremums';
 import { isBandScaleConfig, isPointScaleConfig } from '../models/axis';
 import { getScale } from '../internals/getScale';
-import { DrawingContext } from './DrawingProvider';
 import { SeriesContext } from './SeriesContextProvider';
 import { DEFAULT_X_AXIS_KEY, DEFAULT_Y_AXIS_KEY } from '../constants';
 import { getTickNumber } from '../hooks/useTicks';
+import { useDrawingArea } from '../hooks/useDrawingArea';
+import { getColorScale, getOrdinalColorScale } from '../internals/colorScale';
 import { jsx as _jsx } from "react/jsx-runtime";
 const DEFAULT_CATEGORY_GAP_RATIO = 0.2;
 const DEFAULT_BAR_GAP_RATIO = 0.1;
@@ -42,7 +43,7 @@ function CartesianContextProvider(props) {
     children
   } = props;
   const formattedSeries = React.useContext(SeriesContext);
-  const drawingArea = React.useContext(DrawingContext);
+  const drawingArea = useDrawingArea();
   const xAxis = React.useMemo(() => inXAxis?.map(axisConfig => {
     const dataKey = axisConfig.dataKey;
     if (dataKey === undefined || axisConfig.data !== undefined) {
@@ -112,13 +113,19 @@ function CartesianContextProvider(props) {
           barGapRatio
         }, axis, {
           scale: scaleBand(axis.data, range).paddingInner(categoryGapRatio).paddingOuter(categoryGapRatio / 2),
-          tickNumber: axis.data.length
+          tickNumber: axis.data.length,
+          colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? getOrdinalColorScale(_extends({
+            values: axis.data
+          }, axis.colorMap)) : getColorScale(axis.colorMap))
         });
       }
       if (isPointScaleConfig(axis)) {
         completedXAxis[axis.id] = _extends({}, axis, {
           scale: scalePoint(axis.data, range),
-          tickNumber: axis.data.length
+          tickNumber: axis.data.length,
+          colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? getOrdinalColorScale(_extends({
+            values: axis.data
+          }, axis.colorMap)) : getColorScale(axis.colorMap))
         });
       }
       if (axis.scaleType === 'band' || axis.scaleType === 'point') {
@@ -137,7 +144,8 @@ function CartesianContextProvider(props) {
       completedXAxis[axis.id] = _extends({}, axis, {
         scaleType,
         scale: niceScale.domain(domain),
-        tickNumber
+        tickNumber,
+        colorScale: axis.colorMap && getColorScale(axis.colorMap)
       });
     });
     const allYAxis = [...(yAxis?.map((axis, index) => _extends({
@@ -160,13 +168,19 @@ function CartesianContextProvider(props) {
           barGapRatio: 0
         }, axis, {
           scale: scaleBand(axis.data, [range[1], range[0]]).paddingInner(categoryGapRatio).paddingOuter(categoryGapRatio / 2),
-          tickNumber: axis.data.length
+          tickNumber: axis.data.length,
+          colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? getOrdinalColorScale(_extends({
+            values: axis.data
+          }, axis.colorMap)) : getColorScale(axis.colorMap))
         });
       }
       if (isPointScaleConfig(axis)) {
         completedYAxis[axis.id] = _extends({}, axis, {
           scale: scalePoint(axis.data, [range[1], range[0]]),
-          tickNumber: axis.data.length
+          tickNumber: axis.data.length,
+          colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? getOrdinalColorScale(_extends({
+            values: axis.data
+          }, axis.colorMap)) : getColorScale(axis.colorMap))
         });
       }
       if (axis.scaleType === 'band' || axis.scaleType === 'point') {
@@ -185,7 +199,8 @@ function CartesianContextProvider(props) {
       completedYAxis[axis.id] = _extends({}, axis, {
         scaleType,
         scale: niceScale.domain(domain),
-        tickNumber
+        tickNumber,
+        colorScale: axis.colorMap && getColorScale(axis.colorMap)
       });
     });
     return {

package/esm/hooks/index.js

@@ -1,2 +1,5 @@
 export * from './useDrawingArea';
-export * from './useScale';
+export * from './useChartId';
+export * from './useScale';
+export * from './useSvgRef';
+export { useSeries as unstable_useSeries, usePieSeries as unstable_usePieSeries, useLineSeries as unstable_useLineSeries, useBarSeries as unstable_useBarSeries, useScatterSeries as unstable_useScatterSeries } from './useSeries';

package/esm/hooks/useAxisEvents.js

@@ -1,20 +1,21 @@
 import * as React from 'react';
 import { InteractionContext } from '../context/InteractionProvider';
 import { CartesianContext } from '../context/CartesianContextProvider';
-import { SvgContext, DrawingContext } from '../context/DrawingProvider';
 import { isBandScale } from '../internals/isBandScale';
 import { getSVGPoint } from '../internals/utils';
+import { useSvgRef } from './useSvgRef';
+import { useDrawingArea } from './useDrawingArea';
 function getAsANumber(value) {
   return value instanceof Date ? value.getTime() : value;
 }
 export const useAxisEvents = disableAxisListener => {
-  const svgRef = React.useContext(SvgContext);
+  const svgRef = useSvgRef();
   const {
-    width,
-    height,
+    left,
     top,
-    left
-  } = React.useContext(DrawingContext);
+    width,
+    height
+  } = useDrawingArea();
   const {
     xAxis,
     yAxis,

package/esm/hooks/useChartId.js

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { DrawingContext } from '../context/DrawingProvider';
+export function useChartId() {
+  const {
+    chartId
+  } = React.useContext(DrawingContext);
+  return React.useMemo(() => chartId, [chartId]);
+}

package/esm/hooks/useSeries.js

@@ -0,0 +1,64 @@
+import * as React from 'react';
+import { SeriesContext } from '../context/SeriesContextProvider';
+
+/**
+ * Get access to the internal state of series.
+ * Structured by type of series:
+ * { seriesType?: { series: { id1: precessedValue, ... }, seriesOrder: [id1, ...] } }
+ * @returns FormattedSeries series
+ */
+export function useSeries() {
+  const series = React.useContext(SeriesContext);
+  if (series === undefined) {
+    throw new Error(['MUI X: Could not find the series ref context.', 'It looks like you rendered your component outside of a ChartsContainer parent component.'].join('\n'));
+  }
+  return series;
+}
+
+/**
+ * Get access to the internal state of pie series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * @returns { series: Record<SeriesId, DefaultizedPieSeriesType>; seriesOrder: SeriesId[]; } | undefined pieSeries
+ */
+export function usePieSeries() {
+  const series = useSeries();
+  return React.useMemo(() => series.pie, [series.pie]);
+}
+
+/**
+ * Get access to the internal state of line series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * @returns { series: Record<SeriesId, DefaultizedLineSeriesType>; seriesOrder: SeriesId[]; } | undefined lineSeries
+ */
+export function useLineSeries() {
+  const series = useSeries();
+  return React.useMemo(() => series.line, [series.line]);
+}
+
+/**
+ * Get access to the internal state of bar series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * @returns { series: Record<SeriesId, DefaultizedBarSeriesType>; seriesOrder: SeriesId[]; } | undefined barSeries
+ */
+export function useBarSeries() {
+  const series = useSeries();
+  return React.useMemo(() => series.bar, [series.bar]);
+}
+
+/**
+ * Get access to the internal state of scatter series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * @returns { series: Record<SeriesId, DefaultizedScatterSeriesType>; seriesOrder: SeriesId[]; } | undefined scatterSeries
+ */
+export function useScatterSeries() {
+  const series = useSeries();
+  return React.useMemo(() => series.scatter, [series.scatter]);
+}

package/esm/hooks/useSvgRef.js

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { SvgContext } from '../context/DrawingProvider';
+export function useSvgRef() {
+  const svgRef = React.useContext(SvgContext);
+  if (svgRef === undefined) {
+    throw new Error(['MUI X: Could not find the svg ref context.', 'It looks like you rendered your component outside of a ChartsContainer parent component.'].join('\n'));
+  }
+  return svgRef;
+}

package/esm/internals/colorGetter.js

@@ -0,0 +1,22 @@
+import getBarColor from '../BarChart/getColor';
+import getLineColor from '../LineChart/getColor';
+import getScatterColor from '../ScatterChart/getColor';
+import getPieColor from '../PieChart/getColor';
+function getColor(series, xAxis, yAxis) {
+  if (xAxis !== undefined && yAxis !== undefined) {
+    if (series.type === 'bar') {
+      return getBarColor(series, xAxis, yAxis);
+    }
+    if (series.type === 'line') {
+      return getLineColor(series, xAxis, yAxis);
+    }
+    if (series.type === 'scatter') {
+      return getScatterColor(series, xAxis, yAxis);
+    }
+  }
+  if (series.type === 'pie') {
+    return getPieColor(series);
+  }
+  throw Error(`MUI X Charts: getColor called with unexpected arguments for series with id "${series.id}"`);
+}
+export default getColor;

package/esm/internals/colorScale.js

@@ -0,0 +1,16 @@
+import { scaleOrdinal, scaleThreshold, scaleSequential } from 'd3-scale';
+export function getSequentialColorScale(config) {
+  if (config.type === 'piecewise') {
+    return scaleThreshold(config.thresholds, config.colors);
+  }
+  return scaleSequential([config.min ?? 0, config.max ?? 100], config.color);
+}
+export function getOrdinalColorScale(config) {
+  if (config.values) {
+    return scaleOrdinal(config.values, config.colors).unknown(config.unknownColor ?? null);
+  }
+  return scaleOrdinal(config.colors.map((_, index) => index), config.colors).unknown(config.unknownColor ?? null);
+}
+export function getColorScale(config) {
+  return config.type === 'ordinal' ? getOrdinalColorScale(config) : getSequentialColorScale(config);
+}

package/esm/internals/components/ChartsAxesGradients/ChartsAxesGradients.js

@@ -0,0 +1,96 @@
+import * as React from 'react';
+import { CartesianContext } from '../../../context/CartesianContextProvider';
+import { DrawingContext } from '../../../context/DrawingProvider';
+import { useDrawingArea } from '../../../hooks';
+import ChartsPiecewiseGradient from './ChartsPiecewiseGradient';
+import ChartsContinuousGradient from './ChartsContinuousGradient';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export function useChartGradient() {
+  const {
+    chartId
+  } = React.useContext(DrawingContext);
+  return React.useCallback((axisId, direction) => `${chartId}-graient-${direction}-${axisId}`, [chartId]);
+}
+export function ChartsAxesGradients() {
+  const {
+    top,
+    height,
+    bottom,
+    left,
+    width,
+    right
+  } = useDrawingArea();
+  const svgHeight = top + height + bottom;
+  const svgWidth = left + width + right;
+  const getGradientId = useChartGradient();
+  const {
+    xAxisIds,
+    xAxis,
+    yAxisIds,
+    yAxis
+  } = React.useContext(CartesianContext);
+  return /*#__PURE__*/_jsxs("defs", {
+    children: [yAxisIds.filter(axisId => yAxis[axisId].colorMap !== undefined).map(axisId => {
+      const gradientId = getGradientId(axisId, 'y');
+      const {
+        colorMap,
+        scale,
+        colorScale,
+        reverse
+      } = yAxis[axisId];
+      if (colorMap?.type === 'piecewise') {
+        return /*#__PURE__*/_jsx(ChartsPiecewiseGradient, {
+          isReveresed: !reverse,
+          scale: scale,
+          colorMap: colorMap,
+          size: svgHeight,
+          gradientId: gradientId,
+          direction: "y"
+        }, gradientId);
+      }
+      if (colorMap?.type === 'continuous') {
+        return /*#__PURE__*/_jsx(ChartsContinuousGradient, {
+          isReveresed: !reverse,
+          scale: scale,
+          colorScale: colorScale,
+          colorMap: colorMap,
+          size: svgHeight,
+          gradientId: gradientId,
+          direction: "y"
+        }, gradientId);
+      }
+      return null;
+    }), xAxisIds.filter(axisId => xAxis[axisId].colorMap !== undefined).map(axisId => {
+      const gradientId = getGradientId(axisId, 'x');
+      const {
+        colorMap,
+        scale,
+        reverse,
+        colorScale
+      } = xAxis[axisId];
+      if (colorMap?.type === 'piecewise') {
+        return /*#__PURE__*/_jsx(ChartsPiecewiseGradient, {
+          isReveresed: reverse,
+          scale: scale,
+          colorMap: colorMap,
+          size: svgWidth,
+          gradientId: gradientId,
+          direction: "x"
+        }, gradientId);
+      }
+      if (colorMap?.type === 'continuous') {
+        return /*#__PURE__*/_jsx(ChartsContinuousGradient, {
+          isReveresed: reverse,
+          scale: scale,
+          colorScale: colorScale,
+          colorMap: colorMap,
+          size: svgWidth,
+          gradientId: gradientId,
+          direction: "x"
+        }, gradientId);
+      }
+      return null;
+    })]
+  });
+}

package/esm/internals/components/ChartsAxesGradients/ChartsContinuousGradient.js

@@ -0,0 +1,55 @@
+import * as React from 'react';
+import { interpolateDate, interpolateNumber } from 'd3-interpolate';
+import { jsx as _jsx } from "react/jsx-runtime";
+const PX_PRECISION = 10;
+export default function ChartsContinuousGradient(props) {
+  const {
+    isReveresed,
+    gradientId,
+    size,
+    direction,
+    scale,
+    colorScale,
+    colorMap
+  } = props;
+  const extremValues = [colorMap.min ?? 0, colorMap.max ?? 100];
+  const extremPositions = extremValues.map(scale).filter(p => p !== undefined);
+  if (extremPositions.length !== 2) {
+    return null;
+  }
+  const interpolator = typeof extremValues[0] === 'number' ? interpolateNumber(extremValues[0], extremValues[1]) : interpolateDate(extremValues[0], extremValues[1]);
+  const numberOfPoints = Math.round((Math.max(...extremPositions) - Math.min(...extremPositions)) / PX_PRECISION);
+  const keyPrefix = `${extremValues[0]}-${extremValues[1]}-`;
+  return /*#__PURE__*/_jsx("linearGradient", {
+    id: gradientId,
+    x1: "0",
+    x2: "0",
+    y1: "0",
+    y2: "0",
+    [`${direction}${isReveresed ? 1 : 2}`]: `${size}px`,
+    gradientUnits: "userSpaceOnUse" // Use the SVG coordinate instead of the component ones.
+    ,
+    children: Array.from({
+      length: numberOfPoints + 1
+    }, (_, index) => {
+      const value = interpolator(index / numberOfPoints);
+      if (value === undefined) {
+        return null;
+      }
+      const x = scale(value);
+      if (x === undefined) {
+        return null;
+      }
+      const offset = isReveresed ? 1 - x / size : x / size;
+      const color = colorScale(value);
+      if (color === null) {
+        return null;
+      }
+      return /*#__PURE__*/_jsx("stop", {
+        offset: offset,
+        stopColor: color,
+        stopOpacity: 1
+      }, keyPrefix + index);
+    })
+  });
+}

package/esm/internals/components/ChartsAxesGradients/ChartsPiecewiseGradient.js

@@ -0,0 +1,41 @@
+import * as React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export default function ChartsPiecewiseGradient(props) {
+  const {
+    isReveresed,
+    gradientId,
+    size,
+    direction,
+    scale,
+    colorMap
+  } = props;
+  return /*#__PURE__*/_jsx("linearGradient", {
+    id: gradientId,
+    x1: "0",
+    x2: "0",
+    y1: "0",
+    y2: "0",
+    [`${direction}${isReveresed ? 1 : 2}`]: `${size}px`,
+    gradientUnits: "userSpaceOnUse" // Use the SVG coordinate instead of the component ones.
+    ,
+    children: colorMap.thresholds.map((threshold, index) => {
+      const x = scale(threshold);
+      if (x === undefined) {
+        return null;
+      }
+      const offset = isReveresed ? 1 - x / size : x / size;
+      return /*#__PURE__*/_jsxs(React.Fragment, {
+        children: [/*#__PURE__*/_jsx("stop", {
+          offset: offset,
+          stopColor: colorMap.colors[index],
+          stopOpacity: 1
+        }), /*#__PURE__*/_jsx("stop", {
+          offset: offset,
+          stopColor: colorMap.colors[index + 1],
+          stopOpacity: 1
+        })]
+      }, threshold.toString() + index);
+    })
+  });
+}

package/esm/internals/components/ChartsAxesGradients/index.js

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

package/esm/models/colorMapping.js

@@ -0,0 +1 @@
+export {};

package/esm/models/seriesType/index.js

@@ -2,4 +2,9 @@ export * from './line';
 export * from './bar';
 export * from './scatter';
 export * from './pie';
-export {};
+export function isDefaultizedBarSeries(series) {
+  return series.type === 'bar';
+}
+export function isBarSeries(series) {
+  return series.type === 'bar';
+}

package/hooks/index.d.ts

@@ -1,2 +1,5 @@
 export * from './useDrawingArea';
+export * from './useChartId';
 export * from './useScale';
+export * from './useSvgRef';
+export { useSeries as unstable_useSeries, usePieSeries as unstable_usePieSeries, useLineSeries as unstable_useLineSeries, useBarSeries as unstable_useBarSeries, useScatterSeries as unstable_useScatterSeries, } from './useSeries';