@mui/x-charts 8.9.2 → 8.10.0

package/esm/ChartsXAxis/useAxisProps.js

@@ -0,0 +1,98 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["scale", "tickNumber", "reverse"];
+import useSlotProps from '@mui/utils/useSlotProps';
+import { useThemeProps, useTheme } from '@mui/material/styles';
+import { useRtl } from '@mui/system/RtlProvider';
+import { ChartsText } from "../ChartsText/index.js";
+import { useXAxes } from "../hooks/useAxis.js";
+import { getDefaultBaseline, getDefaultTextAnchor } from "../ChartsText/defaultTextPlacement.js";
+import { invertTextAnchor } from "../internals/invertTextAnchor.js";
+import { defaultProps, useUtilityClasses } from "./utilities.js";
+import { isBandScale } from "../internals/isBandScale.js";
+import { isInfinity } from "../internals/isInfinity.js";
+export const useAxisProps = inProps => {
+  const {
+    xAxis,
+    xAxisIds
+  } = useXAxes();
+  const _xAxis = xAxis[inProps.axisId ?? xAxisIds[0]],
+    {
+      scale: xScale,
+      tickNumber,
+      reverse
+    } = _xAxis,
+    settings = _objectWithoutPropertiesLoose(_xAxis, _excluded);
+
+  // eslint-disable-next-line material-ui/mui-name-matches-component-name
+  const themedProps = useThemeProps({
+    props: _extends({}, settings, inProps),
+    name: 'MuiChartsXAxis'
+  });
+  const defaultizedProps = _extends({}, defaultProps, themedProps);
+  const {
+    position,
+    tickLabelStyle,
+    labelStyle,
+    slots,
+    slotProps
+  } = defaultizedProps;
+  const theme = useTheme();
+  const isRtl = useRtl();
+  const classes = useUtilityClasses(defaultizedProps);
+  const positionSign = position === 'bottom' ? 1 : -1;
+  const Line = slots?.axisLine ?? 'line';
+  const Tick = slots?.axisTick ?? 'line';
+  const TickLabel = slots?.axisTickLabel ?? ChartsText;
+  const Label = slots?.axisLabel ?? ChartsText;
+  const defaultTextAnchor = getDefaultTextAnchor((position === 'bottom' ? 0 : 180) - (tickLabelStyle?.angle ?? 0));
+  const defaultDominantBaseline = getDefaultBaseline((position === 'bottom' ? 0 : 180) - (tickLabelStyle?.angle ?? 0));
+  const axisTickLabelProps = useSlotProps({
+    elementType: TickLabel,
+    externalSlotProps: slotProps?.axisTickLabel,
+    additionalProps: {
+      style: _extends({}, theme.typography.caption, {
+        fontSize: 12,
+        lineHeight: 1.25,
+        textAnchor: isRtl ? invertTextAnchor(defaultTextAnchor) : defaultTextAnchor,
+        dominantBaseline: defaultDominantBaseline
+      }, tickLabelStyle)
+    },
+    className: classes.tickLabel,
+    ownerState: {}
+  });
+  const axisLabelProps = useSlotProps({
+    elementType: Label,
+    externalSlotProps: slotProps?.axisLabel,
+    additionalProps: {
+      style: _extends({}, theme.typography.body1, {
+        lineHeight: 1,
+        fontSize: 14,
+        textAnchor: 'middle',
+        dominantBaseline: position === 'bottom' ? 'text-after-edge' : 'text-before-edge'
+      }, labelStyle)
+    },
+    ownerState: {}
+  });
+  const domain = xScale.domain();
+  const isScaleBand = isBandScale(xScale);
+  const skipAxisRendering = isScaleBand && domain.length === 0 || !isScaleBand && domain.some(isInfinity) || position === 'none';
+  return {
+    xScale,
+    defaultizedProps,
+    tickNumber,
+    positionSign,
+    skipAxisRendering,
+    classes,
+    Line,
+    Tick,
+    TickLabel,
+    Label,
+    axisTickLabelProps,
+    axisLabelProps,
+    reverse,
+    isRtl
+  };
+};

package/esm/ChartsXAxis/utilities.d.ts

@@ -0,0 +1,11 @@
+import { AxisConfig, ChartsXAxisProps } from "../models/axis.js";
+export declare const useUtilityClasses: (ownerState: AxisConfig<any, any, ChartsXAxisProps>) => Record<"root" | "line" | "label" | "tickContainer" | "tick" | "tickLabel", string>;
+export declare const TICK_LABEL_GAP = 3;
+export declare const AXIS_LABEL_TICK_LABEL_GAP = 4;
+export declare const XAxisRoot: import("@emotion/styled").StyledComponent<Pick<import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme> & Pick<import("react").SVGProps<SVGGElement>, keyof import("react").SVGProps<SVGGElement>>, keyof import("react").SVGProps<SVGGElement> | keyof import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme>> & import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme>, {}, {}>;
+export declare const defaultProps: {
+  readonly disableLine: false;
+  readonly disableTicks: false;
+  readonly tickSize: 6;
+  readonly tickLabelMinGap: 4;
+};

package/esm/ChartsXAxis/utilities.js

@@ -0,0 +1,35 @@
+import composeClasses from '@mui/utils/composeClasses';
+import { styled } from '@mui/material/styles';
+import { getAxisUtilityClass } from "../ChartsAxis/axisClasses.js";
+import { AxisRoot } from "../internals/components/AxisSharedComponents.js";
+export const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    position,
+    id
+  } = ownerState;
+  const slots = {
+    root: ['root', 'directionX', position, `id-${id}`],
+    line: ['line'],
+    tickContainer: ['tickContainer'],
+    tick: ['tick'],
+    tickLabel: ['tickLabel'],
+    label: ['label']
+  };
+  return composeClasses(slots, getAxisUtilityClass, classes);
+};
+
+/* Gap between a tick and its label. */
+export const TICK_LABEL_GAP = 3;
+/* Gap between the axis label and tick labels. */
+export const AXIS_LABEL_TICK_LABEL_GAP = 4;
+export const XAxisRoot = styled(AxisRoot, {
+  name: 'MuiChartsXAxis',
+  slot: 'Root'
+})({});
+export const defaultProps = {
+  disableLine: false,
+  disableTicks: false,
+  tickSize: 6,
+  tickLabelMinGap: 4
+};

package/esm/LineChart/LineChart.js

@@ -270,6 +270,10 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     height: PropTypes.number,
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
@@ -321,6 +325,10 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     height: PropTypes.number,
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
@@ -703,6 +711,10 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
     ignoreTooltip: PropTypes.bool,
@@ -753,6 +765,10 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
     ignoreTooltip: PropTypes.bool,

package/esm/RadarChart/index.d.ts

@@ -1,7 +1,14 @@
-export { RadarChart as Unstable_RadarChart } from "./RadarChart.js";
+import { RadarDataProvider } from "./RadarDataProvider/index.js";
 export { RadarChart } from "./RadarChart.js";
-export { RadarDataProvider as Unstable_RadarDataProvider } from "./RadarDataProvider/index.js";
+/**
+ * @deprecated radar chart is now stable, import `RadarChart` instead
+ */
+export declare const Unstable_RadarChart: import("react").ForwardRefExoticComponent<import("./RadarChart.js").RadarChartProps & import("react").RefAttributes<SVGSVGElement>>;
 export { RadarDataProvider } from "./RadarDataProvider/index.js";
+/**
+ * @deprecated radar data provider is now stable, import `RadarDataProvider` instead
+ */
+export declare const Unstable_RadarDataProvider: typeof RadarDataProvider;
 export type { RadarChartProps, RadarChartSlots, RadarChartSlotProps } from "./RadarChart.js";
 export type { RadarDataProviderProps, RadarSeries } from "./RadarDataProvider/index.js";
 export * from "./RadarGrid/index.js";

package/esm/RadarChart/index.js

@@ -1,7 +1,17 @@
-export { RadarChart as Unstable_RadarChart } from "./RadarChart.js";
+import { RadarChart } from "./RadarChart.js";
+import { RadarDataProvider } from "./RadarDataProvider/index.js";
 export { RadarChart } from "./RadarChart.js";
-export { RadarDataProvider as Unstable_RadarDataProvider } from "./RadarDataProvider/index.js";
+/**
+ * @deprecated radar chart is now stable, import `RadarChart` instead
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const Unstable_RadarChart = RadarChart;
 export { RadarDataProvider } from "./RadarDataProvider/index.js";
+/**
+ * @deprecated radar data provider is now stable, import `RadarDataProvider` instead
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const Unstable_RadarDataProvider = RadarDataProvider;
 export * from "./RadarGrid/index.js";
 export * from "./RadarAxisHighlight/index.js";
 export * from "./RadarMetricLabels/index.js";

package/esm/ScatterChart/ScatterChart.d.ts

@@ -6,6 +6,7 @@ import { ScatterPlotProps, ScatterPlotSlotProps, ScatterPlotSlots } from "./Scat
 import { ChartContainerProps } from "../ChartContainer/index.js";
 import { ChartsAxisProps } from "../ChartsAxis/index.js";
 import { ScatterSeriesType } from "../models/seriesType/scatter.js";
+import { ChartsTooltipProps } from "../ChartsTooltip/index.js";
 import { ChartsTooltipSlots, ChartsTooltipSlotProps } from "../ChartsTooltip/ChartTooltip.types.js";
 import { ChartsLegendSlotProps, ChartsLegendSlots } from "../ChartsLegend/index.js";
 import { ChartsOverlayProps, ChartsOverlaySlotProps, ChartsOverlaySlots } from "../ChartsOverlay/index.js";
@@ -15,7 +16,13 @@ import { ChartsGridProps } from "../ChartsGrid/index.js";
 import { UseChartVoronoiSignature } from "../internals/plugins/featurePlugins/useChartVoronoi/index.js";
 import { ScatterChartPluginsSignatures } from "./ScatterChart.plugins.js";
 export interface ScatterChartSlots extends ChartsAxisSlots, ScatterPlotSlots, ChartsLegendSlots, ChartsOverlaySlots, ChartsTooltipSlots, ChartsToolbarSlots, Partial<ChartsSlots> {}
-export interface ScatterChartSlotProps extends ChartsAxisSlotProps, ScatterPlotSlotProps, ChartsLegendSlotProps, ChartsOverlaySlotProps, ChartsTooltipSlotProps, ChartsToolbarSlotProps, Partial<ChartsSlotProps> {}
+export interface ScatterChartSlotProps extends ChartsAxisSlotProps, ScatterPlotSlotProps, ChartsLegendSlotProps, ChartsOverlaySlotProps, Omit<ChartsTooltipSlotProps, 'tooltip'>, ChartsToolbarSlotProps, Partial<ChartsSlotProps> {
+  /**
+   * Slot props for the tooltip component.
+   * @default {}
+   */
+  tooltip?: Partial<ChartsTooltipProps<'item' | 'none'>>;
+}
 export type ScatterSeries = MakeOptional<ScatterSeriesType, 'type'>;
 export interface ScatterChartProps extends Omit<ChartContainerProps<'scatter', ScatterChartPluginsSignatures>, 'series' | 'plugins' | 'onItemClick' | 'experimentalFeatures' | 'highlightedAxis' | 'onHighlightedAxisChange'>, Omit<ChartsAxisProps, 'slots' | 'slotProps'>, Omit<ChartsOverlayProps, 'slots' | 'slotProps'> {
   /**

package/esm/ScatterChart/ScatterChart.js

@@ -239,6 +239,10 @@ process.env.NODE_ENV !== "production" ? ScatterChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     height: PropTypes.number,
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
@@ -290,6 +294,10 @@ process.env.NODE_ENV !== "production" ? ScatterChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     height: PropTypes.number,
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
@@ -672,6 +680,10 @@ process.env.NODE_ENV !== "production" ? ScatterChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
     ignoreTooltip: PropTypes.bool,
@@ -722,6 +734,10 @@ process.env.NODE_ENV !== "production" ? ScatterChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
     ignoreTooltip: PropTypes.bool,

package/esm/SparkLineChart/SparkLineChart.js

@@ -353,6 +353,10 @@ process.env.NODE_ENV !== "production" ? SparkLineChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     height: PropTypes.number,
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
@@ -404,6 +408,10 @@ process.env.NODE_ENV !== "production" ? SparkLineChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     height: PropTypes.number,
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
@@ -785,6 +793,10 @@ process.env.NODE_ENV !== "production" ? SparkLineChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
     ignoreTooltip: PropTypes.bool,
@@ -835,6 +847,10 @@ process.env.NODE_ENV !== "production" ? SparkLineChart.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    groups: PropTypes.arrayOf(PropTypes.shape({
+      getValue: PropTypes.func.isRequired,
+      tickSize: PropTypes.number
+    })),
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
     ignoreTooltip: PropTypes.bool,

package/esm/hooks/useTicksGrouped.d.ts

@@ -0,0 +1,28 @@
+import type { ScaleBand, ScalePoint } from '@mui/x-charts-vendor/d3-scale';
+import { AxisConfig, type AxisGroup } from "../models/axis.js";
+import type { TickParams } from "./useTicks.js";
+export type GroupedTickItemType = {
+  /**
+   * This property is undefined only if it's the tick closing the last band
+   */
+  value?: any;
+  formattedValue?: string;
+  offset: number;
+  labelOffset: number;
+  /**
+   * In band scales, we remove some redundant ticks.
+   */
+  ignoreTick?: boolean;
+  dataIndex?: number;
+  /**
+   * The index of the group this tick belongs to. If `getGrouping` returns `[[0, 1], [2, 3]]`
+   * both ticks with value `0` and `2` will have `groupIndex: 0`, and both ticks with value `1` and `3` will have `groupIndex: 1`.
+   */
+  groupIndex?: number;
+};
+export declare function useTicksGrouped(options: {
+  scale: ScaleBand<any> | ScalePoint<any>;
+  valueFormatter?: AxisConfig['valueFormatter'];
+  direction: 'x' | 'y';
+  groups: AxisGroup[];
+} & Pick<TickParams, 'tickNumber' | 'tickInterval' | 'tickPlacement' | 'tickLabelPlacement'>): GroupedTickItemType[];

package/esm/hooks/useTicksGrouped.js

@@ -0,0 +1,98 @@
+'use client';
+
+import * as React from 'react';
+import { isBandScale } from "../internals/isBandScale.js";
+const offsetRatio = {
+  start: 0,
+  extremities: 0,
+  end: 1,
+  middle: 0.5,
+  tick: 0
+};
+export function useTicksGrouped(options) {
+  const {
+    scale,
+    tickInterval,
+    tickLabelPlacement = 'middle',
+    tickPlacement = 'extremities',
+    groups
+  } = options;
+  return React.useMemo(() => {
+    const domain = scale.domain();
+    const filteredDomain = typeof tickInterval === 'function' && domain.filter(tickInterval) || typeof tickInterval === 'object' && tickInterval || domain;
+    if (scale.bandwidth() > 0) {
+      // scale type = 'band'
+      const entries = mapToGrouping(filteredDomain, groups, tickPlacement, tickLabelPlacement, scale);
+      if (entries[0]) {
+        entries[0].ignoreTick = true;
+      }
+      return [{
+        formattedValue: undefined,
+        offset: scale.range()[0],
+        labelOffset: 0,
+        groupIndex: groups.length - 1
+      }, ...entries,
+      // Last tick
+      {
+        formattedValue: undefined,
+        offset: scale.range()[1],
+        labelOffset: 0,
+        groupIndex: groups.length - 1
+      }];
+    }
+
+    // scale type = 'point'
+    return mapToGrouping(filteredDomain, groups, tickPlacement, tickLabelPlacement, scale);
+  }, [scale, tickInterval, groups, tickPlacement, tickLabelPlacement]);
+}
+function mapToGrouping(tickValues, groups, tickPlacement, tickLabelPlacement, scale) {
+  const allTickItems = [];
+  // Map to keep track of offsets and their corresponding tick indexes
+  // Used to remove redundant ticks when they are in the same position
+  const dataIndexToTickIndex = new Map();
+  let currentValueCount = 0;
+  for (let groupIndex = 0; groupIndex < groups.length; groupIndex += 1) {
+    for (let dataIndex = 0; dataIndex < tickValues.length; dataIndex += 1) {
+      const tickValue = tickValues[dataIndex];
+      const groupValue = groups[groupIndex].getValue(tickValue, dataIndex);
+      const lastItem = allTickItems[allTickItems.length - 1];
+
+      // Check if this is a new unique value for this group
+      const isNew = lastItem?.value !== groupValue || lastItem?.groupIndex !== groupIndex;
+      if (isNew) {
+        currentValueCount = 1;
+        // Calculate tick offset
+        const tickOffset = isBandScale(scale) ? scale(tickValue) - (scale.step() - scale.bandwidth()) / 2 + offsetRatio[tickPlacement] * scale.step() : scale(tickValue);
+
+        // Calculate the label offset
+        const labelOffset = scale.step() * currentValueCount * (offsetRatio[tickLabelPlacement] - offsetRatio[tickPlacement]);
+
+        // Add a new item
+        allTickItems.push({
+          value: groupValue,
+          formattedValue: `${groupValue}`,
+          offset: tickOffset,
+          groupIndex,
+          dataIndex,
+          ignoreTick: false,
+          labelOffset
+        });
+        if (!dataIndexToTickIndex.has(dataIndex)) {
+          dataIndexToTickIndex.set(dataIndex, new Set());
+        }
+        const tickIndexes = dataIndexToTickIndex.get(dataIndex);
+        for (const previousIndex of tickIndexes.values()) {
+          allTickItems[previousIndex].ignoreTick = true;
+        }
+        tickIndexes.add(allTickItems.length - 1);
+      } else {
+        currentValueCount += 1;
+
+        // Calculate the label offset
+        const labelOffset = scale.step() * currentValueCount * (offsetRatio[tickLabelPlacement] - offsetRatio[tickPlacement]);
+        lastItem.labelOffset = labelOffset;
+      }
+    }
+  }
+  return allTickItems;
+}

package/esm/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-charts v8.9.2
+ * @mui/x-charts v8.10.0
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/esm/internals/getScale.d.ts

@@ -1,2 +1,2 @@
 import { ContinuousScaleName, D3ContinuousScale } from "../models/axis.js";
-export declare function getScale(scaleType: ContinuousScaleName, domain: any[], range: any[]): D3ContinuousScale;
+export declare function getScale(scaleType: ContinuousScaleName, domain: readonly any[], range: readonly any[]): D3ContinuousScale;

package/esm/internals/plugins/featurePlugins/useChartCartesianAxis/createAxisFilterMapper.d.ts

@@ -1,4 +1,4 @@
-import { AxisId, ChartsXAxisProps, ChartsYAxisProps, ScaleName } from "../../../../models/axis.js";
+import { AxisId, ChartsXAxisProps, ChartsYAxisProps, ContinuousScaleName, ScaleName } from "../../../../models/axis.js";
 import { CartesianChartSeriesType } from "../../../../models/seriesType/config.js";
 import { ProcessedSeries } from "../../corePlugins/useChartSeries/index.js";
 import { AxisConfig } from "../../../../models/index.js";
@@ -19,4 +19,6 @@ export declare function createAxisFilterMapper(params: {
   formattedSeries: ProcessedSeries;
   direction: 'y';
 }): (axis: AxisConfig<ScaleName, any, ChartsYAxisProps>, axisIndex: number) => ExtremumFilter | null;
+export declare function createDiscreteScaleGetAxisFilter(axisData: AxisConfig['data'], zoomStart: number, zoomEnd: number, direction: 'x' | 'y'): ExtremumFilter;
+export declare function createContinuousScaleGetAxisFilter(scaleType: ContinuousScaleName | undefined, extrema: readonly [number, number], zoomStart: number, zoomEnd: number, direction: 'x' | 'y', axisData: AxisConfig['data']): ExtremumFilter;
 export declare const createGetAxisFilters: (filters: ZoomAxisFilters) => GetZoomAxisFilters;

package/esm/internals/plugins/featurePlugins/useChartCartesianAxis/createAxisFilterMapper.js

@@ -18,32 +18,41 @@ export function createAxisFilterMapper({
       // No zoom, or zoom with all data visible
       return null;
     }
-    let extremums = [];
     const scaleType = axis.scaleType;
     if (scaleType === 'point' || scaleType === 'band') {
-      extremums = [0, (axis.data?.length ?? 1) - 1];
-    } else {
-      extremums = getAxisExtremum(axis, direction, seriesConfig, axisIndex, formattedSeries);
+      return createDiscreteScaleGetAxisFilter(axis.data, zoom.start, zoom.end, direction);
     }
-    let min;
-    let max;
-    const continuousScaleType = !scaleType || scaleType === 'band' || scaleType === 'point' ? 'linear' : scaleType;
-    [min, max] = getScale(continuousScaleType, extremums, [0, 100]).nice().domain();
-    min = min instanceof Date ? min.getTime() : min;
-    max = max instanceof Date ? max.getTime() : max;
-    const minVal = min + zoom.start * (max - min) / 100;
-    const maxVal = min + zoom.end * (max - min) / 100;
-    return (value, dataIndex) => {
-      const val = value[direction] ?? axis.data?.[dataIndex];
-      if (val == null) {
-        // If the value does not exist because of missing data point, or out of range index, we just ignore.
-        return true;
-      }
-      if (axis.scaleType === 'point' || axis.scaleType === 'band' || typeof val === 'string') {
-        return dataIndex >= minVal && dataIndex <= maxVal;
-      }
-      return val >= minVal && val <= maxVal;
-    };
+    return createContinuousScaleGetAxisFilter(scaleType, getAxisExtremum(axis, direction, seriesConfig, axisIndex, formattedSeries), zoom.start, zoom.end, direction, axis.data);
+  };
+}
+export function createDiscreteScaleGetAxisFilter(axisData, zoomStart, zoomEnd, direction) {
+  const maxIndex = axisData?.length ?? 0;
+  const minVal = Math.floor(zoomStart * maxIndex / 100);
+  const maxVal = Math.ceil(zoomEnd * maxIndex / 100);
+  return function filterAxis(value, dataIndex) {
+    const val = value[direction] ?? axisData?.[dataIndex];
+    if (val == null) {
+      // If the value does not exist because of missing data point, or out of range index, we just ignore.
+      return true;
+    }
+    return dataIndex >= minVal && dataIndex < maxVal;
+  };
+}
+export function createContinuousScaleGetAxisFilter(scaleType, extrema, zoomStart, zoomEnd, direction, axisData) {
+  let min;
+  let max;
+  [min, max] = getScale(scaleType ?? 'linear', extrema, [0, 100]).nice().domain();
+  min = min instanceof Date ? min.getTime() : min;
+  max = max instanceof Date ? max.getTime() : max;
+  const minVal = min + zoomStart * (max - min) / 100;
+  const maxVal = min + zoomEnd * (max - min) / 100;
+  return function filterAxis(value, dataIndex) {
+    const val = value[direction] ?? axisData?.[dataIndex];
+    if (val == null) {
+      // If the value does not exist because of missing data point, or out of range index, we just ignore.
+      return true;
+    }
+    return val >= minVal && val <= maxVal;
   };
 }
 export const createGetAxisFilters = filters => ({

package/esm/internals/plugins/featurePlugins/useChartCartesianAxis/getAxisExtremum.d.ts

@@ -3,4 +3,4 @@ import { CartesianChartSeriesType } from "../../../../models/seriesType/config.j
 import { ChartSeriesConfig } from "../../models/seriesConfig/index.js";
 import { ProcessedSeries } from "../../corePlugins/useChartSeries/useChartSeries.types.js";
 import { GetZoomAxisFilters } from "./zoom.types.js";
-export declare const getAxisExtremum: <T extends CartesianChartSeriesType>(axis: AxisConfig, axisDirection: "x" | "y", seriesConfig: ChartSeriesConfig<T>, axisIndex: number, formattedSeries: ProcessedSeries<T>, getFilters?: GetZoomAxisFilters) => number[];
+export declare const getAxisExtremum: <T extends CartesianChartSeriesType>(axis: AxisConfig, axisDirection: "x" | "y", seriesConfig: ChartSeriesConfig<T>, axisIndex: number, formattedSeries: ProcessedSeries<T>, getFilters?: GetZoomAxisFilters) => [number, number];

package/esm/models/axis.d.ts

@@ -180,6 +180,21 @@ export interface ChartsRadiusAxisProps extends ChartsAxisProps {
 }
 export type ScaleName = keyof AxisScaleConfig;
 export type ContinuousScaleName = 'linear' | 'log' | 'symlog' | 'pow' | 'sqrt' | 'time' | 'utc';
+export type AxisGroup = {
+  /**
+   * The function used to return the value for this group.
+   *
+   * @param {any} value The value of the axis item.
+   * @param {number} dataIndex  The index of the data item.
+   * @returns {string | number | Date} The value that will be used to group the axis items.
+   */
+  getValue: (value: any, dataIndex: number) => string | number | Date;
+  /**
+   * The size of the tick in pixels.
+   * @default 6
+   */
+  tickSize?: number;
+};
 export interface AxisScaleConfig {
   band: {
     scaleType: 'band';
@@ -197,11 +212,57 @@ export interface AxisScaleConfig {
      */
     barGapRatio: number;
     colorMap?: OrdinalColorConfig | ContinuousColorConfig | PiecewiseColorConfig;
+    /**
+     * Each group will have a label that is the stringified value of the group.
+     *
+     * @example
+     * If the axis is grouped by day, month and year.
+     *
+     * ```tsx
+     * [
+     *   { getValue: getDate },
+     *   { getValue: getMonth },
+     *   { getValue: getFullYear }
+     * ]
+     * ```
+     *
+     * Then the axis will have three rows, one for each group.
+     *
+     * ```bash
+     * | 31   | 1    | 2    |
+     * | Jan  | Feb         |
+     * | 2021               |
+     * ```
+     */
+    groups?: AxisGroup[];
   } & Pick<TickParams, 'tickPlacement' | 'tickLabelPlacement'>;
   point: {
     scaleType: 'point';
     scale: ScalePoint<number | Date | string>;
     colorMap?: OrdinalColorConfig | ContinuousColorConfig | PiecewiseColorConfig;
+    /**
+     * Each group will have a label that is the stringified value of the group.
+     *
+     * @example
+     * If the axis is grouped by day, month and year.
+     *
+     * ```tsx
+     * [
+     *   { getValue: getDate },
+     *   { getValue: getMonth },
+     *   { getValue: getFullYear }
+     * ]
+     * ```
+     *
+     * Then the axis will have three rows, one for each group.
+     *
+     * ```bash
+     * | 31   | 1    | 2    |
+     * | Jan  | Feb         |
+     * | 2021               |
+     * ```
+     */
+    groups?: AxisGroup[];
   };
   log: {
     scaleType: 'log';