@mui/x-charts 7.7.0 → 7.8.0

package/ScatterChart/useScatterChartProps.js

@@ -0,0 +1,116 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useScatterChartProps = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/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
+ */
+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 => (0, _extends2.default)({
+      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 = (0, _extends2.default)({}, legend, {
+    slots,
+    slotProps
+  });
+  const axisHighlightProps = (0, _extends2.default)({
+    y: 'none',
+    x: 'none'
+  }, axisHighlight);
+  const tooltipProps = (0, _extends2.default)({
+    trigger: 'item'
+  }, tooltip, {
+    slots,
+    slotProps
+  });
+  return {
+    chartContainerProps,
+    zAxisProps,
+    voronoiHandlerProps,
+    chartsAxisProps,
+    gridProps,
+    scatterPlotProps,
+    overlayProps,
+    legendProps,
+    axisHighlightProps,
+    tooltipProps,
+    children
+  };
+};
+exports.useScatterChartProps = useScatterChartProps;

package/context/CartesianProvider/CartesianContext.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { Initializable } from '../context.types';
+import { AxisDefaultized, ScaleName, ChartsXAxisProps, ChartsYAxisProps, AxisId } from '../../models/axis';
+export type DefaultizedAxisConfig<AxisProps> = {
+    [axisKey: AxisId]: AxisDefaultized<ScaleName, any, AxisProps>;
+};
+export type CartesianContextState = {
+    /**
+     * Mapping from x-axis key to scaling configuration.
+     */
+    xAxis: DefaultizedAxisConfig<ChartsXAxisProps>;
+    /**
+     * Mapping from y-axis key to scaling configuration.
+     */
+    yAxis: DefaultizedAxisConfig<ChartsYAxisProps>;
+    /**
+     * The x-axes IDs sorted by order they got provided.
+     */
+    xAxisIds: AxisId[];
+    /**
+     * The y-axes IDs sorted by order they got provided.
+     */
+    yAxisIds: AxisId[];
+};
+export declare const CartesianContext: React.Context<Initializable<CartesianContextState>>;

package/context/CartesianProvider/CartesianContext.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CartesianContext = void 0;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const CartesianContext = exports.CartesianContext = /*#__PURE__*/React.createContext({
+  isInitialized: false,
+  data: {
+    xAxis: {},
+    yAxis: {},
+    xAxisIds: [],
+    yAxisIds: []
+  }
+});
+if (process.env.NODE_ENV !== 'production') {
+  CartesianContext.displayName = 'CartesianContext';
+}

package/context/CartesianProvider/CartesianProvider.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { AxisConfig, ChartsXAxisProps, ChartsYAxisProps, ScaleName } from '../../models/axis';
+import { DatasetType } from '../../models/seriesType/config';
+import { MakeOptional } from '../../models/helpers';
+import { ExtremumGettersConfig } from '../../models';
+export type CartesianContextProviderProps = {
+    /**
+     * The configuration of the x-axes.
+     * If not provided, a default axis config is used.
+     * An array of [[AxisConfig]] objects.
+     */
+    xAxis?: MakeOptional<AxisConfig<ScaleName, any, ChartsXAxisProps>, 'id'>[];
+    /**
+     * The configuration of the y-axes.
+     * If not provided, a default axis config is used.
+     * An array of [[AxisConfig]] objects.
+     */
+    yAxis?: MakeOptional<AxisConfig<ScaleName, any, ChartsYAxisProps>, 'id'>[];
+    /**
+     * An array of objects that can be used to populate series and axes data using their `dataKey` property.
+     */
+    dataset?: DatasetType;
+    /**
+     * An object with x-axis extremum getters per series type.
+     */
+    xExtremumGetters: ExtremumGettersConfig;
+    /**
+     * An object with y-axis extremum getters per series type.
+     */
+    yExtremumGetters: ExtremumGettersConfig;
+    children: React.ReactNode;
+};
+declare function CartesianContextProvider(props: CartesianContextProviderProps): React.JSX.Element;
+export { CartesianContextProvider };

package/context/CartesianProvider/CartesianProvider.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CartesianContextProvider = CartesianContextProvider;
+var React = _interopRequireWildcard(require("react"));
+var _useDrawingArea = require("../../hooks/useDrawingArea");
+var _useSeries = require("../../hooks/useSeries");
+var _CartesianContext = require("./CartesianContext");
+var _normalizeAxis = require("./normalizeAxis");
+var _computeValue = require("./computeValue");
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function CartesianContextProvider(props) {
+  const {
+    xAxis: inXAxis,
+    yAxis: inYAxis,
+    dataset,
+    xExtremumGetters,
+    yExtremumGetters,
+    children
+  } = props;
+  const formattedSeries = (0, _useSeries.useSeries)();
+  const drawingArea = (0, _useDrawingArea.useDrawingArea)();
+  const xAxis = React.useMemo(() => (0, _normalizeAxis.normalizeAxis)(inXAxis, dataset, 'x'), [inXAxis, dataset]);
+  const yAxis = React.useMemo(() => (0, _normalizeAxis.normalizeAxis)(inYAxis, dataset, 'y'), [inYAxis, dataset]);
+  const xValues = React.useMemo(() => (0, _computeValue.computeValue)(drawingArea, formattedSeries, xAxis, xExtremumGetters, 'x'), [drawingArea, formattedSeries, xAxis, xExtremumGetters]);
+  const yValues = React.useMemo(() => (0, _computeValue.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__*/(0, _jsxRuntime.jsx)(_CartesianContext.CartesianContext.Provider, {
+    value: value,
+    children: children
+  });
+}

package/context/CartesianProvider/computeValue.d.ts

@@ -0,0 +1,19 @@
+import { AxisConfig, ScaleName } from '../../models';
+import { ChartsXAxisProps, ChartsAxisProps, ChartsYAxisProps } from '../../models/axis';
+import { CartesianChartSeriesType, ExtremumGetter } from '../../models/seriesType/config';
+import { DefaultizedAxisConfig } from './CartesianContext';
+import { DrawingArea } from '../DrawingProvider';
+import { FormattedSeries } from '../SeriesContextProvider';
+import { MakeOptional } from '../../models/helpers';
+export declare function computeValue(drawingArea: DrawingArea, formattedSeries: FormattedSeries, axis: MakeOptional<AxisConfig<ScaleName, any, ChartsYAxisProps>, 'id'>[] | undefined, extremumGetters: {
+    [K in CartesianChartSeriesType]?: ExtremumGetter<K>;
+}, axisName: 'y'): {
+    axis: DefaultizedAxisConfig<ChartsYAxisProps>;
+    axisIds: string[];
+};
+export declare function computeValue(drawingArea: DrawingArea, formattedSeries: FormattedSeries, inAxis: MakeOptional<AxisConfig<ScaleName, any, ChartsXAxisProps>, 'id'>[] | undefined, extremumGetters: {
+    [K in CartesianChartSeriesType]?: ExtremumGetter<K>;
+}, axisName: 'x'): {
+    axis: DefaultizedAxisConfig<ChartsAxisProps>;
+    axisIds: string[];
+};

package/context/CartesianProvider/computeValue.js

@@ -0,0 +1,104 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeValue = computeValue;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _d3Scale = require("d3-scale");
+var _constants = require("../../constants");
+var _axis = require("../../models/axis");
+var _colorScale = require("../../internals/colorScale");
+var _useTicks = require("../../hooks/useTicks");
+var _getScale = require("../../internals/getScale");
+var _getAxisExtremum = require("./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 = (0, _d3Scale.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;
+function computeValue(drawingArea, formattedSeries, inAxis, extremumGetters, axisName) {
+  const DEFAULT_AXIS_KEY = axisName === 'x' ? _constants.DEFAULT_X_AXIS_KEY : _constants.DEFAULT_Y_AXIS_KEY;
+  const allAxis = [...(inAxis?.map((axis, index) => (0, _extends2.default)({
+    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] = (0, _getAxisExtremum.getAxisExtremum)(axis, extremumGetters, isDefaultAxis, formattedSeries);
+    const range = getRange(drawingArea, axisName, axis.reverse);
+    if ((0, _axis.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] = (0, _extends2.default)({
+        categoryGapRatio,
+        barGapRatio
+      }, axis, {
+        scale: (0, _d3Scale.scaleBand)(axis.data, scaleRange).paddingInner(categoryGapRatio).paddingOuter(categoryGapRatio / 2),
+        tickNumber: axis.data.length,
+        colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? (0, _colorScale.getOrdinalColorScale)((0, _extends2.default)({
+          values: axis.data
+        }, axis.colorMap)) : (0, _colorScale.getColorScale)(axis.colorMap))
+      });
+      if (isDateData(axis.data)) {
+        const dateFormatter = createDateFormatter(axis, scaleRange);
+        completeAxis[axis.id].valueFormatter = axis.valueFormatter ?? dateFormatter;
+      }
+    }
+    if ((0, _axis.isPointScaleConfig)(axis)) {
+      const scaleRange = axisName === 'x' ? range : [...range].reverse();
+      completeAxis[axis.id] = (0, _extends2.default)({}, axis, {
+        scale: (0, _d3Scale.scalePoint)(axis.data, scaleRange),
+        tickNumber: axis.data.length,
+        colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? (0, _colorScale.getOrdinalColorScale)((0, _extends2.default)({
+          values: axis.data
+        }, axis.colorMap)) : (0, _colorScale.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 = (0, _useTicks.getTickNumber)((0, _extends2.default)({}, axis, {
+      range,
+      domain: extremums
+    }));
+    const scale = (0, _getScale.getScale)(scaleType, extremums, range).nice(tickNumber);
+    const [minDomain, maxDomain] = scale.domain();
+    const domain = [axis.min ?? minDomain, axis.max ?? maxDomain];
+    completeAxis[axis.id] = (0, _extends2.default)({}, axis, {
+      scaleType: scaleType,
+      scale: scale.domain(domain),
+      tickNumber,
+      colorScale: axis.colorMap && (0, _colorScale.getColorScale)(axis.colorMap)
+    });
+  });
+  return {
+    axis: completeAxis,
+    axisIds: allAxis.map(({
+      id
+    }) => id)
+  };
+}

package/context/CartesianProvider/getAxisExtremum.d.ts

@@ -0,0 +1,4 @@
+import { AxisConfig, ExtremumGettersConfig } from '../../models';
+import { ExtremumGetterResult } from '../../models/seriesType/config';
+import { FormattedSeries } from '../SeriesContextProvider';
+export declare const getAxisExtremum: (axis: AxisConfig, getters: ExtremumGettersConfig, isDefaultAxis: boolean, formattedSeries: FormattedSeries) => ExtremumGetterResult;

package/context/CartesianProvider/getAxisExtremum.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAxisExtremum = void 0;
+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)];
+};
+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]);
+};
+exports.getAxisExtremum = getAxisExtremum;

package/context/CartesianProvider/index.d.ts

@@ -0,0 +1,9 @@
+import { computeValue } from './computeValue';
+export * from './CartesianProvider';
+export * from './CartesianContext';
+export * from './useCartesianContext';
+declare const cartesianProviderUtils: {
+    computeValue: typeof computeValue;
+    normalizeAxis: <T extends import("../../internals").ChartsAxisProps, R extends import("../../internals").MakeOptional<import("../..").AxisConfig<import("../..").ScaleName, any, T>, "id">>(axis: R[] | undefined, dataset: import("../../internals").DatasetType | undefined, axisName: "x" | "y") => R[] | undefined;
+};
+export { cartesianProviderUtils };

package/context/CartesianProvider/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  cartesianProviderUtils: true
+};
+exports.cartesianProviderUtils = void 0;
+var _computeValue = require("./computeValue");
+var _normalizeAxis = require("./normalizeAxis");
+var _CartesianProvider = require("./CartesianProvider");
+Object.keys(_CartesianProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _CartesianProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _CartesianProvider[key];
+    }
+  });
+});
+var _CartesianContext = require("./CartesianContext");
+Object.keys(_CartesianContext).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _CartesianContext[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _CartesianContext[key];
+    }
+  });
+});
+var _useCartesianContext = require("./useCartesianContext");
+Object.keys(_useCartesianContext).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useCartesianContext[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useCartesianContext[key];
+    }
+  });
+});
+const cartesianProviderUtils = exports.cartesianProviderUtils = {
+  computeValue: _computeValue.computeValue,
+  normalizeAxis: _normalizeAxis.normalizeAxis
+};

package/context/CartesianProvider/normalizeAxis.d.ts

@@ -0,0 +1,5 @@
+import type { AxisConfig, ScaleName } from '../../models';
+import { ChartsAxisProps } from '../../models/axis';
+import { MakeOptional } from '../../models/helpers';
+import { DatasetType } from '../../models/seriesType/config';
+export declare const normalizeAxis: <T extends ChartsAxisProps, R extends MakeOptional<AxisConfig<ScaleName, any, T>, "id">>(axis: R[] | undefined, dataset: DatasetType | undefined, axisName: "x" | "y") => R[] | undefined;

package/context/CartesianProvider/normalizeAxis.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeAxis = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+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 (0, _extends2.default)({}, axisConfig, {
+      data: dataset.map(d => d[dataKey])
+    });
+  });
+};
+exports.normalizeAxis = normalizeAxis;

package/context/CartesianProvider/useCartesianContext.d.ts

@@ -0,0 +1,2 @@
+import { CartesianContextState } from './CartesianContext';
+export declare const useCartesianContext: () => CartesianContextState;

package/context/CartesianProvider/useCartesianContext.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCartesianContext = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _CartesianContext = require("./CartesianContext");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const useCartesianContext = () => {
+  const {
+    data
+  } = React.useContext(_CartesianContext.CartesianContext);
+  return data;
+};
+exports.useCartesianContext = useCartesianContext;

package/context/ColorProvider.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { ColorProcessorsConfig } from '../models';
-import { ChartSeriesType } from '../internals';
+import { ChartSeriesType } from '../models/seriesType/config';
 export interface ColorProviderProps {
     children: React.ReactNode;
     /**
@@ -8,5 +8,5 @@ export interface ColorProviderProps {
      */
     colorProcessors: ColorProcessorsConfig<ChartSeriesType>;
 }
-export declare const ColorContext: React.Context<ColorProcessorsConfig<keyof import("../internals").ChartsSeriesConfig>>;
+export declare const ColorContext: React.Context<ColorProcessorsConfig<keyof import("../models/seriesType/config").ChartsSeriesConfig>>;
 export declare function ColorProvider(props: ColorProviderProps): React.JSX.Element;