@mui/x-charts 7.13.0 → 7.15.0

package/context/CartesianProvider/Cartesian.types.d.ts

@@ -0,0 +1,59 @@
+import { DatasetType } from '../../models/seriesType/config';
+import { AxisDefaultized, ScaleName, ChartsXAxisProps, ChartsYAxisProps, AxisId, AxisConfig } from '../../models/axis';
+import { ExtremumFilter } from '../PluginProvider';
+export type CartesianProviderProps = {
+    /**
+     * The configuration of the x-axes.
+     * If not provided, a default axis config is used.
+     * An array of [[AxisConfig]] objects.
+     */
+    xAxis: AxisConfig<ScaleName, any, ChartsXAxisProps>[];
+    /**
+     * The configuration of the y-axes.
+     * If not provided, a default axis config is used.
+     * An array of [[AxisConfig]] objects.
+     */
+    yAxis: AxisConfig<ScaleName, any, ChartsYAxisProps>[];
+    /**
+     * An array of objects that can be used to populate series and axes data using their `dataKey` property.
+     */
+    dataset?: DatasetType;
+    children: React.ReactNode;
+};
+export type DefaultizedAxisConfig<AxisProps> = {
+    [axisId: 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 type ZoomData = {
+    axisId: AxisId;
+    start: number;
+    end: number;
+};
+export type ZoomFilterMode = 'keep' | 'discard' | 'empty';
+export type ZoomOptions = Record<AxisId, {
+    filterMode: ZoomFilterMode;
+}>;
+export type ZoomAxisFilters = Record<AxisId, ExtremumFilter>;
+export type GetZoomAxisFilters = (params: {
+    currentAxisId: AxisId | undefined;
+    seriesXAxisId?: AxisId;
+    seriesYAxisId?: AxisId;
+    isDefaultAxis: boolean;
+}) => ExtremumFilter;

package/context/CartesianProvider/CartesianContext.d.ts

@@ -1,25 +1,4 @@
 import * as React from 'react';
 import { Initializable } from '../context.types';
-import { AxisDefaultized, ScaleName, ChartsXAxisProps, ChartsYAxisProps, AxisId } from '../../models/axis';
-export type DefaultizedAxisConfig<AxisProps> = {
-    [axisId: 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[];
-};
+import { CartesianContextState } from './Cartesian.types';
 export declare const CartesianContext: React.Context<Initializable<CartesianContextState>>;

package/context/CartesianProvider/CartesianContext.js

@@ -1,13 +1,5 @@
-"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({
+import * as React from 'react';
+export const CartesianContext = /*#__PURE__*/React.createContext({
   isInitialized: false,
   data: {
     xAxis: {},

package/context/CartesianProvider/CartesianProvider.d.ts

@@ -1,24 +1,4 @@
 import * as React from 'react';
-import { AxisConfig, ChartsXAxisProps, ChartsYAxisProps, ScaleName } from '../../models/axis';
-import { DatasetType } from '../../models/seriesType/config';
-export type CartesianProviderProps = {
-    /**
-     * The configuration of the x-axes.
-     * If not provided, a default axis config is used.
-     * An array of [[AxisConfig]] objects.
-     */
-    xAxis: AxisConfig<ScaleName, any, ChartsXAxisProps>[];
-    /**
-     * The configuration of the y-axes.
-     * If not provided, a default axis config is used.
-     * An array of [[AxisConfig]] objects.
-     */
-    yAxis: AxisConfig<ScaleName, any, ChartsYAxisProps>[];
-    /**
-     * An array of objects that can be used to populate series and axes data using their `dataKey` property.
-     */
-    dataset?: DatasetType;
-    children: React.ReactNode;
-};
+import { CartesianProviderProps } from './Cartesian.types';
 declare function CartesianProvider(props: CartesianProviderProps): React.JSX.Element;
 export { CartesianProvider };

package/context/CartesianProvider/CartesianProvider.js

@@ -1,46 +1,35 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CartesianProvider = CartesianProvider;
-var React = _interopRequireWildcard(require("react"));
-var _useDrawingArea = require("../../hooks/useDrawingArea");
-var _useSeries = require("../../hooks/useSeries");
-var _CartesianContext = require("./CartesianContext");
-var _computeValue = require("./computeValue");
-var _useXExtremumGetter = require("../PluginProvider/useXExtremumGetter");
-var _PluginProvider = require("../PluginProvider");
-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; }
+import * as React from 'react';
+import { useDrawingArea } from '../../hooks/useDrawingArea';
+import { useSeries } from '../../hooks/useSeries';
+import { CartesianContext } from './CartesianContext';
+import { computeValue } from './computeValue';
+import { useXExtremumGetter } from '../PluginProvider/useXExtremumGetter';
+import { useYExtremumGetter } from '../PluginProvider';
+import { jsx as _jsx } from "react/jsx-runtime";
 function CartesianProvider(props) {
   const {
     xAxis,
     yAxis,
-    dataset,
     children
   } = props;
-  const formattedSeries = (0, _useSeries.useSeries)();
-  const drawingArea = (0, _useDrawingArea.useDrawingArea)();
-  const xExtremumGetters = (0, _useXExtremumGetter.useXExtremumGetter)();
-  const yExtremumGetters = (0, _PluginProvider.useYExtremumGetter)();
-  const xValues = React.useMemo(() => (0, _computeValue.computeValue)({
+  const formattedSeries = useSeries();
+  const drawingArea = useDrawingArea();
+  const xExtremumGetters = useXExtremumGetter();
+  const yExtremumGetters = useYExtremumGetter();
+  const xValues = React.useMemo(() => computeValue({
     drawingArea,
     formattedSeries,
     axis: xAxis,
     extremumGetters: xExtremumGetters,
-    dataset,
     axisDirection: 'x'
-  }), [drawingArea, formattedSeries, xAxis, xExtremumGetters, dataset]);
-  const yValues = React.useMemo(() => (0, _computeValue.computeValue)({
+  }), [drawingArea, formattedSeries, xAxis, xExtremumGetters]);
+  const yValues = React.useMemo(() => computeValue({
     drawingArea,
     formattedSeries,
     axis: yAxis,
     extremumGetters: yExtremumGetters,
-    dataset,
     axisDirection: 'y'
-  }), [drawingArea, formattedSeries, yAxis, yExtremumGetters, dataset]);
+  }), [drawingArea, formattedSeries, yAxis, yExtremumGetters]);
   const value = React.useMemo(() => ({
     isInitialized: true,
     data: {
@@ -50,8 +39,9 @@ function CartesianProvider(props) {
       yAxisIds: yValues.axisIds
     }
   }), [xValues, yValues]);
-  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_CartesianContext.CartesianContext.Provider, {
+  return /*#__PURE__*/_jsx(CartesianContext.Provider, {
     value: value,
     children: children
   });
-}
+}
+export { CartesianProvider };

package/context/CartesianProvider/computeValue.d.ts

@@ -1,43 +1,30 @@
 import { AxisConfig, ScaleName } from '../../models';
-import { ChartsXAxisProps, ChartsAxisProps, ChartsYAxisProps, AxisId } from '../../models/axis';
-import { CartesianChartSeriesType, DatasetType } from '../../models/seriesType/config';
-import { DefaultizedAxisConfig } from './CartesianContext';
+import { ChartsXAxisProps, ChartsAxisProps, ChartsYAxisProps } from '../../models/axis';
+import { CartesianChartSeriesType } from '../../models/seriesType/config';
 import { DrawingArea } from '../DrawingProvider';
 import { FormattedSeries } from '../SeriesProvider';
 import { ExtremumGetter } from '../PluginProvider';
-export declare function computeValue(options: {
-    drawingArea: DrawingArea;
-    formattedSeries: FormattedSeries;
-    axis: AxisConfig<ScaleName, any, ChartsYAxisProps>[] | undefined;
-    extremumGetters: {
-        [K in CartesianChartSeriesType]?: ExtremumGetter<K>;
-    };
-    axisDirection: 'y';
-    dataset: DatasetType | undefined;
-    zoomData?: {
-        axisId: AxisId;
-        start: number;
-        end: number;
-    }[];
-}): {
-    axis: DefaultizedAxisConfig<ChartsYAxisProps>;
+import { DefaultizedAxisConfig, ZoomData, ZoomOptions, GetZoomAxisFilters } from './Cartesian.types';
+type ComputeResult<T extends ChartsAxisProps> = {
+    axis: DefaultizedAxisConfig<T>;
     axisIds: string[];
 };
-export declare function computeValue(options: {
+type ComputeCommonParams = {
     drawingArea: DrawingArea;
     formattedSeries: FormattedSeries;
-    axis: AxisConfig<ScaleName, any, ChartsXAxisProps>[] | undefined;
     extremumGetters: {
         [K in CartesianChartSeriesType]?: ExtremumGetter<K>;
     };
-    axisDirection: 'x';
-    dataset: DatasetType | undefined;
-    zoomData?: {
-        axisId: AxisId;
-        start: number;
-        end: number;
-    }[];
-}): {
-    axis: DefaultizedAxisConfig<ChartsAxisProps>;
-    axisIds: string[];
+    zoomData?: ZoomData[];
+    zoomOptions?: ZoomOptions;
+    getFilters?: GetZoomAxisFilters;
 };
+export declare function computeValue(options: ComputeCommonParams & {
+    axis: AxisConfig<ScaleName, any, ChartsYAxisProps>[];
+    axisDirection: 'y';
+}): ComputeResult<ChartsYAxisProps>;
+export declare function computeValue(options: ComputeCommonParams & {
+    axis: AxisConfig<ScaleName, any, ChartsXAxisProps>[];
+    axisDirection: 'x';
+}): ComputeResult<ChartsAxisProps>;
+export {};

package/context/CartesianProvider/computeValue.js

@@ -1,90 +1,79 @@
-"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("@mui/x-charts-vendor/d3-scale");
-var _axis = require("../../models/axis");
-var _colorScale = require("../../internals/colorScale");
-var _useTicks = require("../../hooks/useTicks");
-var _getScale = require("../../internals/getScale");
-var _getAxisExtremum = require("./getAxisExtremum");
-var _normalizeAxis = require("./normalizeAxis");
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { scaleBand, scalePoint, scaleTime } from '@mui/x-charts-vendor/d3-scale';
+import { isBandScaleConfig, isPointScaleConfig } from '../../models/axis';
+import { getColorScale, getOrdinalColorScale } from '../../internals/colorScale';
+import { getTickNumber } from '../../hooks/useTicks';
+import { getScale } from '../../internals/getScale';
+import { zoomScaleRange } from './zoom';
+import { getAxisExtremum } from './getAxisExtremum';
 const getRange = (drawingArea, axisDirection, isReverse) => {
   const range = axisDirection === 'x' ? [drawingArea.left, drawingArea.left + drawingArea.width] : [drawingArea.top + drawingArea.height, drawingArea.top];
   return isReverse ? range.reverse() : range;
 };
-const zoomedScaleRange = (scaleRange, zoomRange) => {
-  const rangeGap = scaleRange[1] - scaleRange[0];
-  const zoomGap = zoomRange[1] - zoomRange[0];
-
-  // If current zoom show the scale between p1 and p2 percents
-  // The range should be extended by adding [0, p1] and [p2, 100] segments
-  const min = scaleRange[0] - zoomRange[0] * rangeGap / zoomGap;
-  const max = scaleRange[1] + (100 - zoomRange[1]) * rangeGap / zoomGap;
-  return [min, max];
-};
 const isDateData = data => data?.[0] instanceof Date;
 function createDateFormatter(axis, range) {
-  const timeScale = (0, _d3Scale.scaleTime)(axis.data, 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;
-function computeValue({
+export function computeValue({
   drawingArea,
   formattedSeries,
-  axis: inAxis,
+  axis: allAxis,
   extremumGetters,
-  dataset,
   axisDirection,
-  zoomData
+  zoomData,
+  zoomOptions,
+  getFilters
 }) {
-  const allAxis = (0, _normalizeAxis.normalizeAxis)(inAxis, dataset, axisDirection);
   const completeAxis = {};
-  allAxis.forEach((axis, axisIndex) => {
+  allAxis.forEach((eachAxis, axisIndex) => {
+    const axis = eachAxis;
     const isDefaultAxis = axisIndex === 0;
-    const [minData, maxData] = (0, _getAxisExtremum.getAxisExtremum)(axis, extremumGetters, isDefaultAxis, formattedSeries);
+    const zoomOption = zoomOptions?.[axis.id];
     const zoom = zoomData?.find(({
       axisId
     }) => axisId === axis.id);
     const zoomRange = zoom ? [zoom.start, zoom.end] : [0, 100];
     const range = getRange(drawingArea, axisDirection, axis.reverse);
-    if ((0, _axis.isBandScaleConfig)(axis)) {
+    const [minData, maxData] = getAxisExtremum(axis, extremumGetters, isDefaultAxis, formattedSeries, zoom === undefined && !zoomOption ? getFilters : undefined // Do not apply filtering if zoom is already defined.
+    );
+    const data = axis.data ?? [];
+    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 = axisDirection === 'x' ? range : [range[1], range[0]];
-      const zoomedRange = zoomedScaleRange(scaleRange, zoomRange);
-      completeAxis[axis.id] = (0, _extends2.default)({
+      const zoomedRange = zoomScaleRange(scaleRange, zoomRange);
+      completeAxis[axis.id] = _extends({
         categoryGapRatio,
         barGapRatio
       }, axis, {
-        scale: (0, _d3Scale.scaleBand)(axis.data, zoomedRange).paddingInner(categoryGapRatio).paddingOuter(categoryGapRatio / 2),
+        data,
+        scale: scaleBand(axis.data, zoomedRange).paddingInner(categoryGapRatio).paddingOuter(categoryGapRatio / 2),
         tickNumber: axis.data.length,
-        colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? (0, _colorScale.getOrdinalColorScale)((0, _extends2.default)({
+        colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? getOrdinalColorScale(_extends({
           values: axis.data
-        }, axis.colorMap)) : (0, _colorScale.getColorScale)(axis.colorMap))
+        }, axis.colorMap)) : getColorScale(axis.colorMap))
       });
       if (isDateData(axis.data)) {
         const dateFormatter = createDateFormatter(axis, scaleRange);
         completeAxis[axis.id].valueFormatter = axis.valueFormatter ?? dateFormatter;
       }
     }
-    if ((0, _axis.isPointScaleConfig)(axis)) {
+    if (isPointScaleConfig(axis)) {
       const scaleRange = axisDirection === 'x' ? range : [...range].reverse();
-      const zoomedRange = zoomedScaleRange(scaleRange, zoomRange);
-      completeAxis[axis.id] = (0, _extends2.default)({}, axis, {
-        scale: (0, _d3Scale.scalePoint)(axis.data, zoomedRange),
+      const zoomedRange = zoomScaleRange(scaleRange, zoomRange);
+      completeAxis[axis.id] = _extends({}, axis, {
+        data,
+        scale: scalePoint(axis.data, zoomedRange),
         tickNumber: axis.data.length,
-        colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? (0, _colorScale.getOrdinalColorScale)((0, _extends2.default)({
+        colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' ? getOrdinalColorScale(_extends({
           values: axis.data
-        }, axis.colorMap)) : (0, _colorScale.getColorScale)(axis.colorMap))
+        }, axis.colorMap)) : getColorScale(axis.colorMap))
       });
       if (isDateData(axis.data)) {
         const dateFormatter = createDateFormatter(axis, scaleRange);
@@ -96,23 +85,24 @@ function computeValue({
       return;
     }
     const scaleType = axis.scaleType ?? 'linear';
-    const extremums = [axis.min ?? minData, axis.max ?? maxData];
-    const rawTickNumber = (0, _useTicks.getTickNumber)((0, _extends2.default)({}, axis, {
+    const axisExtremums = [axis.min ?? minData, axis.max ?? maxData];
+    const rawTickNumber = getTickNumber(_extends({}, axis, {
       range,
-      domain: extremums
+      domain: axisExtremums
     }));
     const tickNumber = rawTickNumber / ((zoomRange[1] - zoomRange[0]) / 100);
-    const zoomedRange = zoomedScaleRange(range, zoomRange);
+    const zoomedRange = zoomScaleRange(range, zoomRange);
 
     // TODO: move nice to prop? Disable when there is zoom?
-    const scale = (0, _getScale.getScale)(scaleType, extremums, zoomedRange).nice(rawTickNumber);
+    const scale = getScale(scaleType, axisExtremums, zoomedRange).nice(rawTickNumber);
     const [minDomain, maxDomain] = scale.domain();
     const domain = [axis.min ?? minDomain, axis.max ?? maxDomain];
-    completeAxis[axis.id] = (0, _extends2.default)({}, axis, {
+    completeAxis[axis.id] = _extends({}, axis, {
+      data,
       scaleType: scaleType,
       scale: scale.domain(domain),
       tickNumber,
-      colorScale: axis.colorMap && (0, _colorScale.getColorScale)(axis.colorMap)
+      colorScale: axis.colorMap && getColorScale(axis.colorMap)
     });
   });
   return {

package/context/CartesianProvider/defaultizeAxis.d.ts

@@ -9,12 +9,10 @@ export declare const defaultizeAxis: (inAxis: MakeOptional<AxisConfig<ScaleName,
     label?: string | undefined;
     max?: (number | Date) | undefined;
     min?: (number | Date) | undefined;
+    valueFormatter?: ((value: any, context: import("../../models/axis").AxisValueFormatterContext) => string) | undefined;
+    dataKey?: string | undefined;
     sx?: import("@mui/system").SxProps | undefined;
     classes?: Partial<import("../..").ChartsAxisClasses> | undefined;
-    slots?: Partial<import("../../models/axis").ChartsAxisSlots> | undefined;
-    slotProps?: Partial<import("../../models/axis").ChartsAxisSlotProps> | undefined;
-    dataKey?: string | undefined;
-    valueFormatter?: ((value: any, context: import("../../models/axis").AxisValueFormatterContext) => string) | undefined;
     tickMaxStep?: number | undefined;
     tickMinStep?: number | undefined;
     tickNumber?: number | undefined;
@@ -26,6 +24,8 @@ export declare const defaultizeAxis: (inAxis: MakeOptional<AxisConfig<ScaleName,
     tickLabelInterval?: ("auto" | ((value: any, index: number) => boolean)) | undefined;
     labelFontSize?: number | undefined;
     tickSize?: number | undefined;
+    slots?: Partial<import("../../models/axis").ChartsAxisSlots> | undefined;
+    slotProps?: Partial<import("../../models/axis").ChartsAxisSlotProps> | undefined;
     tickInterval?: ("auto" | ((value: any, index: number) => boolean) | any[]) | undefined;
     tickPlacement?: ("start" | "end" | "middle" | "extremities") | undefined;
     tickLabelPlacement?: ("middle" | "tick") | undefined;

package/context/CartesianProvider/defaultizeAxis.js

@@ -1,15 +1,8 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.defaultizeAxis = void 0;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var _constants = require("../../constants");
-const defaultizeAxis = (inAxis, axisName) => {
-  const DEFAULT_AXIS_KEY = axisName === 'x' ? _constants.DEFAULT_X_AXIS_KEY : _constants.DEFAULT_Y_AXIS_KEY;
-  return [...(inAxis?.map((axis, index) => (0, _extends2.default)({
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { DEFAULT_X_AXIS_KEY, DEFAULT_Y_AXIS_KEY } from '../../constants';
+export const defaultizeAxis = (inAxis, axisName) => {
+  const DEFAULT_AXIS_KEY = axisName === 'x' ? DEFAULT_X_AXIS_KEY : DEFAULT_Y_AXIS_KEY;
+  return [...(inAxis?.map((axis, index) => _extends({
     id: `defaultized-${axisName}-axis-${index}`
   }, axis)) ?? []), ...(inAxis === undefined || inAxis.findIndex(({
     id
@@ -17,5 +10,4 @@ const defaultizeAxis = (inAxis, axisName) => {
     id: DEFAULT_AXIS_KEY,
     scaleType: 'linear'
   }] : [])];
-};
-exports.defaultizeAxis = defaultizeAxis;
+};

package/context/CartesianProvider/getAxisExtremum.d.ts

@@ -1,4 +1,5 @@
 import { AxisConfig } from '../../models';
 import { FormattedSeries } from '../SeriesProvider';
-import { ExtremumGettersConfig, ExtremumGetterResult } from '../PluginProvider';
-export declare const getAxisExtremum: (axis: AxisConfig, getters: ExtremumGettersConfig, isDefaultAxis: boolean, formattedSeries: FormattedSeries) => ExtremumGetterResult;
+import { ExtremumGettersConfig } from '../PluginProvider';
+import { GetZoomAxisFilters } from './Cartesian.types';
+export declare const getAxisExtremum: (axis: AxisConfig, getters: ExtremumGettersConfig, isDefaultAxis: boolean, formattedSeries: FormattedSeries, getFilters?: GetZoomAxisFilters) => number[];

package/context/CartesianProvider/getAxisExtremum.js

@@ -1,21 +1,20 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getAxisExtremum = void 0;
-const axisExtremumCallback = (acc, chartType, axis, getters, isDefaultAxis, formattedSeries) => {
+const axisExtremumCallback = (acc, chartType, axis, getters, isDefaultAxis, formattedSeries, getFilters) => {
   const getter = getters[chartType];
   const series = formattedSeries[chartType]?.series ?? {};
   const [minChartTypeData, maxChartTypeData] = getter?.({
     series,
     axis,
-    isDefaultAxis
+    isDefaultAxis,
+    getFilters
   }) ?? [Infinity, -Infinity];
-  return [Math.min(minChartTypeData, acc[0]), Math.max(maxChartTypeData, acc[1])];
+  const [minData, maxData] = acc;
+  return [Math.min(minChartTypeData, minData), Math.max(maxChartTypeData, maxData)];
 };
-const getAxisExtremum = (axis, getters, isDefaultAxis, formattedSeries) => {
+export const getAxisExtremum = (axis, getters, isDefaultAxis, formattedSeries, getFilters) => {
   const charTypes = Object.keys(getters);
-  return charTypes.reduce((acc, charType) => axisExtremumCallback(acc, charType, axis, getters, isDefaultAxis, formattedSeries), [Infinity, -Infinity]);
-};
-exports.getAxisExtremum = getAxisExtremum;
+  const extremums = charTypes.reduce((acc, charType) => axisExtremumCallback(acc, charType, axis, getters, isDefaultAxis, formattedSeries, getFilters), [Infinity, -Infinity]);
+  if (Number.isNaN(extremums[0]) || Number.isNaN(extremums[1])) {
+    return [Infinity, -Infinity];
+  }
+  return extremums;
+};

package/context/CartesianProvider/index.d.ts

@@ -2,6 +2,7 @@ import { computeValue } from './computeValue';
 export * from './CartesianProvider';
 export * from './CartesianContext';
 export * from './useCartesianContext';
+export * from './Cartesian.types';
 declare const cartesianProviderUtils: {
     computeValue: typeof computeValue;
 };

package/context/CartesianProvider/index.js

@@ -1,49 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {
-  cartesianProviderUtils: true
+import { computeValue } from './computeValue';
+export * from './CartesianProvider';
+export * from './CartesianContext';
+export * from './useCartesianContext';
+export * from './Cartesian.types';
+const cartesianProviderUtils = {
+  computeValue
 };
-exports.cartesianProviderUtils = void 0;
-var _computeValue = require("./computeValue");
-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
-};
+export { cartesianProviderUtils };

package/context/CartesianProvider/useCartesianContext.d.ts

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

package/context/CartesianProvider/useCartesianContext.js

@@ -1,17 +1,8 @@
-"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 = () => {
+import * as React from 'react';
+import { CartesianContext } from './CartesianContext';
+export const useCartesianContext = () => {
   const {
     data
-  } = React.useContext(_CartesianContext.CartesianContext);
+  } = React.useContext(CartesianContext);
   return data;
-};
-exports.useCartesianContext = useCartesianContext;
+};

package/context/CartesianProvider/zoom.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Applies the zoom into the scale range.
+ * It changes the screen coordinates that the scale covers.
+ * Not the data that is displayed.
+ *
+ * @param scaleRange the original range in real screen coordinates.
+ * @param zoomRange the zoom range in percentage.
+ * @returns zoomed range in real screen coordinates.
+ */
+export declare const zoomScaleRange: (scaleRange: [number, number] | number[], zoomRange: [number, number] | number[]) => number[];