@mui/x-charts-premium 8.22.1 → 8.24.0

package/esm/BarChartPremium/RangeBar/seriesConfig/seriesProcessor.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { warnOnce } from '@mui/x-internals/warning';
+const rangeBarValueFormatter = v => v == null ? '' : `[${v[0]}, ${v[1]}]`;
+const seriesProcessor = (params, dataset) => {
+  const {
+    seriesOrder,
+    series
+  } = params;
+  const completedSeries = {};
+  for (const id of seriesOrder) {
+    const seriesData = series[id];
+    const datasetKeys = seriesData?.datasetKeys;
+    if (seriesData.data === undefined && dataset === undefined && process.env.NODE_ENV !== 'production') {
+      throw new Error([`MUI X Charts: range bar series with id='${id}' has no data.`, 'Either provide a data property to the series or use the dataset prop.'].join('\n'));
+    }
+    const missingKeys = ['start', 'end'].filter(key => typeof datasetKeys?.[key] !== 'string');
+    if (datasetKeys && missingKeys.length > 0) {
+      throw new Error([`MUI X Charts: range bar series with id='${id}' has incomplete datasetKeys.`, `Properties ${missingKeys.map(key => `"${key}"`).join(', ')} are missing.`].join('\n'));
+    }
+    completedSeries[id] = _extends({
+      layout: 'vertical'
+    }, series[id], {
+      valueFormatter: series[id].valueFormatter ?? rangeBarValueFormatter,
+      data: datasetKeys ? dataset.map(data => {
+        const start = data[datasetKeys.start];
+        const end = data[datasetKeys.end];
+        if (typeof start !== 'number' || typeof end !== 'number') {
+          if (process.env.NODE_ENV !== 'production') {
+            if (start !== null) {
+              warnOnce([`MUI X Charts: Your dataset key "start" is used for plotting an range bar, but contains nonnumerical elements.`, 'Range bars only support numbers.']);
+            }
+            if (end !== null) {
+              warnOnce([`MUI X Charts: Your dataset key "end" is used for plotting an range bar, but contains nonnumerical elements.`, 'Range bars only support numbers.']);
+            }
+          }
+          return null;
+        }
+        return [start, end];
+      }) : series[id].data
+    });
+  }
+  return {
+    seriesOrder,
+    series: completedSeries
+  };
+};
+export default seriesProcessor;

package/esm/BarChartPremium/RangeBar/seriesConfig/tooltip.d.ts

@@ -0,0 +1,4 @@
+import { type AxisTooltipGetter, type TooltipGetter } from '@mui/x-charts/internals';
+declare const tooltipGetter: TooltipGetter<'rangeBar'>;
+export declare const axisTooltipGetter: AxisTooltipGetter<'rangeBar', 'x' | 'y'>;
+export default tooltipGetter;

package/esm/BarChartPremium/RangeBar/seriesConfig/tooltip.js

@@ -0,0 +1,37 @@
+import { getLabel } from '@mui/x-charts/internals';
+const tooltipGetter = params => {
+  const {
+    series,
+    getColor,
+    identifier
+  } = params;
+  if (!identifier || identifier.dataIndex === undefined) {
+    return null;
+  }
+  const label = getLabel(series.label, 'tooltip');
+  const value = series.data[identifier.dataIndex];
+  if (value == null) {
+    return null;
+  }
+  const formattedValue = series.valueFormatter(value, {
+    dataIndex: identifier.dataIndex
+  });
+  return {
+    identifier,
+    color: getColor(identifier.dataIndex),
+    label,
+    value,
+    formattedValue,
+    markType: series.labelMarkType
+  };
+};
+export const axisTooltipGetter = series => {
+  return Object.values(series).map(s => s.layout === 'horizontal' ? {
+    direction: 'y',
+    axisId: s.yAxisId
+  } : {
+    direction: 'x',
+    axisId: s.xAxisId
+  });
+};
+export default tooltipGetter;

package/esm/BarChartPremium/RangeBar/seriesConfig/tooltipPosition.d.ts

@@ -0,0 +1,3 @@
+import { type TooltipItemPositionGetter } from '@mui/x-charts/internals';
+declare const tooltipItemPositionGetter: TooltipItemPositionGetter<'rangeBar'>;
+export default tooltipItemPositionGetter;

package/esm/BarChartPremium/RangeBar/seriesConfig/tooltipPosition.js

@@ -0,0 +1,53 @@
+import { getRangeBarDimensions } from "../useRangeBarPlotData.js";
+const tooltipItemPositionGetter = params => {
+  const {
+    series,
+    identifier,
+    axesConfig,
+    placement
+  } = params;
+  if (!identifier || identifier.dataIndex === undefined) {
+    return null;
+  }
+  const itemSeries = series.rangeBar?.series[identifier.seriesId];
+  if (series.rangeBar == null || itemSeries == null) {
+    return null;
+  }
+  if (axesConfig.x === undefined || axesConfig.y === undefined) {
+    return null;
+  }
+  const dimensions = getRangeBarDimensions(itemSeries.layout, axesConfig.x, axesConfig.y, itemSeries.data, identifier.dataIndex, series.rangeBar.seriesOrder.length, series.rangeBar.seriesOrder.findIndex(id => id === itemSeries.id));
+  if (dimensions == null) {
+    return null;
+  }
+  const {
+    x,
+    y,
+    width,
+    height
+  } = dimensions;
+  switch (placement) {
+    case 'right':
+      return {
+        x: x + width,
+        y: y + height / 2
+      };
+    case 'bottom':
+      return {
+        x: x + width / 2,
+        y: y + height
+      };
+    case 'left':
+      return {
+        x,
+        y: y + height / 2
+      };
+    case 'top':
+    default:
+      return {
+        x: x + width / 2,
+        y
+      };
+  }
+};
+export default tooltipItemPositionGetter;

package/esm/BarChartPremium/RangeBar/types.d.ts

@@ -0,0 +1,22 @@
+import type { SeriesId } from '@mui/x-charts/models';
+import type { BarSeriesType } from '@mui/x-charts-pro/models';
+import type { RangeBarValueType } from "../../models/index.js";
+export interface LayoutData {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+export interface ProcessedRangeBarSeriesData {
+  seriesId: SeriesId;
+  data: ProcessedRangeBarData[];
+  layout: BarSeriesType['layout'];
+  yOrigin: number;
+  xOrigin: number;
+}
+export interface ProcessedRangeBarData extends LayoutData {
+  seriesId: SeriesId;
+  dataIndex: number;
+  color: string;
+  value: RangeBarValueType | null;
+}

package/esm/BarChartPremium/RangeBar/types.js

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

package/esm/BarChartPremium/RangeBar/useRangeBarPlotData.d.ts

@@ -0,0 +1,12 @@
+import { type ChartDrawingArea } from '@mui/x-charts/hooks';
+import { type ComputedAxis, type ComputedAxisConfig, type ScaleName } from '@mui/x-charts/internals';
+import { type ChartsXAxisProps, type ChartsYAxisProps } from '@mui/x-charts/models';
+import { type DefaultizedRangeBarSeriesType } from "../../models/seriesType/rangeBar.js";
+import { type ProcessedRangeBarSeriesData } from "./types.js";
+export declare function useRangeBarPlotData(drawingArea: ChartDrawingArea, xAxes: ComputedAxisConfig<ChartsXAxisProps>, yAxes: ComputedAxisConfig<ChartsYAxisProps>): ProcessedRangeBarSeriesData[];
+export declare function getRangeBarDimensions(layout: 'vertical' | 'horizontal', xAxis: ComputedAxis<ScaleName, any, ChartsXAxisProps>, yAxis: ComputedAxis<ScaleName, any, ChartsYAxisProps>, seriesData: DefaultizedRangeBarSeriesType['data'], dataIndex: number, seriesCount: number, seriesIndex: number): {
+  x: number;
+  y: number;
+  height: number;
+  width: number;
+} | null;

package/esm/BarChartPremium/RangeBar/useRangeBarPlotData.js

@@ -0,0 +1,105 @@
+import { useXAxes, useYAxes } from '@mui/x-charts/hooks';
+import { checkBarChartScaleErrors, getBandSize, selectorChartSeriesConfig, useStore } from '@mui/x-charts/internals';
+import { useRangeBarSeriesContext } from "../../hooks/useRangeBarSeries.js";
+export function useRangeBarPlotData(drawingArea, xAxes, yAxes) {
+  const store = useStore();
+  const seriesData = useRangeBarSeriesContext() ?? {
+    series: {},
+    seriesOrder: []
+  };
+  const defaultXAxisId = useXAxes().xAxisIds[0];
+  const defaultYAxisId = useYAxes().yAxisIds[0];
+  const getColor = store.use(selectorChartSeriesConfig).rangeBar.colorProcessor;
+  const {
+    series,
+    seriesOrder
+  } = seriesData;
+  const xMin = drawingArea.left;
+  const xMax = drawingArea.left + drawingArea.width;
+  const yMin = drawingArea.top;
+  const yMax = drawingArea.top + drawingArea.height;
+  const data = seriesOrder.map((seriesId, seriesIndex) => {
+    const xAxisId = series[seriesId].xAxisId ?? defaultXAxisId;
+    const yAxisId = series[seriesId].yAxisId ?? defaultYAxisId;
+    const xAxisConfig = xAxes[xAxisId];
+    const yAxisConfig = yAxes[yAxisId];
+    const verticalLayout = series[seriesId].layout === 'vertical';
+    checkBarChartScaleErrors(verticalLayout, seriesId, series[seriesId].data.length, xAxisId, xAxes, yAxisId, yAxes);
+    const baseScaleConfig = verticalLayout ? xAxisConfig : yAxisConfig;
+    const xScale = xAxisConfig.scale;
+    const yScale = yAxisConfig.scale;
+    const xOrigin = Math.round(xScale(0) ?? 0);
+    const yOrigin = Math.round(yScale(0) ?? 0);
+    const colorGetter = getColor(series[seriesId], xAxes[xAxisId], yAxes[yAxisId]);
+    const bandWidth = baseScaleConfig.scale.bandwidth();
+    const {
+      barWidth,
+      offset
+    } = getBandSize(bandWidth, seriesOrder.length, baseScaleConfig.barGapRatio);
+    const barOffset = seriesIndex * (barWidth + offset);
+    const {
+      data: currentSeriesData,
+      layout
+    } = series[seriesId];
+    const seriesDataPoints = [];
+    for (let dataIndex = 0; dataIndex < baseScaleConfig.data.length; dataIndex += 1) {
+      const baseValue = baseScaleConfig.data[dataIndex];
+      const seriesValue = currentSeriesData[dataIndex];
+      if (seriesValue == null) {
+        continue;
+      }
+      const valueCoordinates = seriesValue.map(v => verticalLayout ? yScale(v) : xScale(v));
+      const minValueCoord = Math.round(Math.min(...valueCoordinates));
+      const maxValueCoord = Math.round(Math.max(...valueCoordinates));
+      const barSize = maxValueCoord - minValueCoord;
+      const result = {
+        seriesId,
+        dataIndex,
+        x: verticalLayout ? xScale(baseValue) + barOffset : minValueCoord,
+        y: verticalLayout ? minValueCoord : yScale(baseValue) + barOffset,
+        height: verticalLayout ? barSize : barWidth,
+        width: verticalLayout ? barWidth : barSize,
+        color: colorGetter(dataIndex),
+        value: currentSeriesData[dataIndex]
+      };
+      if (result.x > xMax || result.x + result.width < xMin || result.y > yMax || result.y + result.height < yMin) {
+        continue;
+      }
+      seriesDataPoints.push(result);
+    }
+    return {
+      seriesId,
+      data: seriesDataPoints,
+      layout,
+      xOrigin,
+      yOrigin
+    };
+  });
+  return data;
+}
+export function getRangeBarDimensions(layout, xAxis, yAxis, seriesData, dataIndex, seriesCount, seriesIndex) {
+  const xScale = xAxis.scale;
+  const yScale = yAxis.scale;
+  const verticalLayout = layout === 'vertical';
+  const baseScaleConfig = verticalLayout ? xAxis : yAxis;
+  const baseValue = baseScaleConfig.data[dataIndex];
+  const seriesValue = seriesData[dataIndex];
+  const {
+    barWidth,
+    offset
+  } = getBandSize(baseScaleConfig.scale.bandwidth(), seriesCount, baseScaleConfig.barGapRatio);
+  const barOffset = seriesIndex * (barWidth + offset);
+  if (seriesValue == null) {
+    return null;
+  }
+  const valueCoordinates = seriesValue.map(v => verticalLayout ? yScale(v) : xScale(v));
+  const minValueCoord = Math.round(Math.min(...valueCoordinates));
+  const maxValueCoord = Math.round(Math.max(...valueCoordinates));
+  const barSize = maxValueCoord - minValueCoord;
+  return {
+    x: verticalLayout ? xScale(baseValue) + barOffset : minValueCoord,
+    y: verticalLayout ? minValueCoord : yScale(baseValue) + barOffset,
+    height: verticalLayout ? barSize : barWidth,
+    width: verticalLayout ? barWidth : barSize
+  };
+}

package/esm/BarChartPremium/RangeBar/useUtilityClasses.d.ts

@@ -0,0 +1,12 @@
+export interface RangeBarClasses {
+  /** Styles applied to the range bar plot element. */
+  root: string;
+  /** Styles applied to the group surrounding a series' bar elements. */
+  series: string;
+  /** Styles applied to the group surrounding a series' labels. */
+  seriesLabels: string;
+}
+export type RangeBarClassKey = keyof RangeBarClasses;
+export declare function getRangeBarUtilityClass(slot: string): string;
+export declare const rangeBarClasses: RangeBarClasses;
+export declare const useUtilityClasses: (classes?: Partial<RangeBarClasses>) => Record<"series" | "root" | "seriesLabels", string>;

package/esm/BarChartPremium/RangeBar/useUtilityClasses.js

@@ -0,0 +1,15 @@
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+import composeClasses from '@mui/utils/composeClasses';
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+export function getRangeBarUtilityClass(slot) {
+  return generateUtilityClass('MuiRangeBar', slot);
+}
+export const rangeBarClasses = generateUtilityClasses('MuiRangeBar', ['root', 'series', 'seriesLabels']);
+export const useUtilityClasses = classes => {
+  const slots = {
+    root: ['root'],
+    series: ['series'],
+    seriesLabels: ['seriesLabels']
+  };
+  return composeClasses(slots, getRangeBarUtilityClass, classes);
+};

package/esm/BarChartPremium/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./BarChartPremium.js";
-export * from "./BarChartPremium.plugins.js";
+export * from "./BarChartPremium.plugins.js";
+export * from "./RangeBar/RangeBarPlot.js";
+export { rangeBarClasses, type RangeBarClasses, type RangeBarClassKey } from "./RangeBar/useUtilityClasses.js";

package/esm/BarChartPremium/index.js

@@ -1,2 +1,4 @@
 export * from "./BarChartPremium.js";
-export * from "./BarChartPremium.plugins.js";
+export * from "./BarChartPremium.plugins.js";
+export * from "./RangeBar/RangeBarPlot.js";
+export { rangeBarClasses } from "./RangeBar/useUtilityClasses.js";

package/esm/BarChartPremium/useBarChartPremiumProps.d.ts

@@ -1,4 +1,7 @@
+import { type BarChartPluginSignatures } from '@mui/x-charts/BarChart';
+import { type ChartContainerProps } from '@mui/x-charts/ChartContainer';
 import { type BarChartPremiumProps } from "./BarChartPremium.js";
+import { type RangeBarPlotProps } from "./RangeBar/RangeBarPlot.js";
 /**
  * A helper function that extracts BarChartPremiumProps from the input props
  * and returns an object with props for the children components of BarChartPremium.
@@ -7,8 +10,9 @@ import { type BarChartPremiumProps } from "./BarChartPremium.js";
  * @returns An object with props for the children components of BarChartPremium
  */
 export declare function useBarChartPremiumProps(props: BarChartPremiumProps): {
+  chartContainerProps: ChartContainerProps<"bar" | "rangeBar", BarChartPluginSignatures>;
+  rangeBarPlotProps: RangeBarPlotProps;
   chartsWrapperProps: Omit<import("@mui/x-charts").ChartsWrapperProps, "children">;
-  chartContainerProps: import("@mui/x-charts").ChartContainerProps<"bar", import("@mui/x-charts").BarChartPluginSignatures>;
   barPlotProps: import("@mui/x-charts").BarPlotProps;
   gridProps: import("@mui/x-charts").ChartsGridProps;
   clipPathProps: import("@mui/x-charts").ChartsClipPathProps;

package/esm/BarChartPremium/useBarChartPremiumProps.js

@@ -1,3 +1,6 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["chartContainerProps"];
 import { useBarChartProps } from '@mui/x-charts/internals';
 /**
  * A helper function that extracts BarChartPremiumProps from the input props
@@ -7,5 +10,19 @@ import { useBarChartProps } from '@mui/x-charts/internals';
  * @returns An object with props for the children components of BarChartPremium
  */
 export function useBarChartPremiumProps(props) {
-  return useBarChartProps(props);
+  const _useBarChartProps = useBarChartProps(props),
+    {
+      chartContainerProps
+    } = _useBarChartProps,
+    barChartProps = _objectWithoutPropertiesLoose(_useBarChartProps, _excluded);
+  const rangeBarPlotProps = {
+    onItemClick: props.onItemClick,
+    slots: props.slots,
+    slotProps: props.slotProps,
+    borderRadius: props.borderRadius
+  };
+  return _extends({}, barChartProps, {
+    chartContainerProps: chartContainerProps,
+    rangeBarPlotProps
+  });
 }

package/esm/ChartDataProviderPremium/ChartDataProviderPremium.d.ts

@@ -1,6 +1,6 @@
-import { type ChartSeriesType, type ChartAnyPluginSignature, type ChartProviderProps } from '@mui/x-charts/internals';
-import { type ChartDataProviderProProps } from '@mui/x-charts-pro/ChartDataProviderPro';
+import { type ChartSeriesType, type ChartAnyPluginSignature, type ChartProviderProps, type ChartSeriesConfig } from '@mui/x-charts/internals';
 import { type ChartsSlotPropsPro, type ChartsSlotsPro } from '@mui/x-charts-pro/internals';
+import { type ChartDataProviderProProps } from '@mui/x-charts-pro/ChartDataProviderPro';
 import { type AllPluginSignatures } from "../internals/plugins/allPlugins.js";
 export type ChartDataProviderPremiumProps<TSeries extends ChartSeriesType = ChartSeriesType, TSignatures extends readonly ChartAnyPluginSignature[] = AllPluginSignatures<TSeries>> = ChartDataProviderProProps<TSeries, TSignatures> & ChartProviderProps<TSeries, TSignatures>['pluginParams'] & {
   /**
@@ -12,6 +12,7 @@ export type ChartDataProviderPremiumProps<TSeries extends ChartSeriesType = Char
    */
   slotProps?: Partial<ChartsSlotPropsPro>;
 };
+export declare const defaultSeriesConfigPremium: ChartSeriesConfig<'bar' | 'rangeBar' | 'scatter' | 'line' | 'pie'>;
 /**
  * Orchestrates the data providers for the chart components and hooks.
  *

package/esm/ChartDataProviderPremium/ChartDataProviderPremium.js

@@ -6,11 +6,17 @@ import { Watermark } from '@mui/x-license/Watermark';
 import { ChartProvider, ChartsSlotsProvider, defaultSlotsMaterial } from '@mui/x-charts/internals';
 import { ChartsLocalizationProvider } from '@mui/x-charts/ChartsLocalizationProvider';
 import { useLicenseVerifier } from '@mui/x-license/useLicenseVerifier';
+import { defaultSeriesConfigPro } from '@mui/x-charts-pro/internals';
+import { rangeBarSeriesConfig } from "../BarChartPremium/RangeBar/seriesConfig/index.js";
 import { DEFAULT_PLUGINS } from "../internals/plugins/allPlugins.js";
 import { useChartDataProviderPremiumProps } from "./useChartDataProviderPremiumProps.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const releaseInfo = "MTc2NjAxNjAwMDAwMA==";
+const releaseInfo = "MTc2NzgzMDQwMDAwMA==";
 const packageIdentifier = 'x-charts-premium';
+export const defaultSeriesConfigPremium = _extends({}, defaultSeriesConfigPro, {
+  rangeBar: rangeBarSeriesConfig
+});
+
 /**
  * Orchestrates the data providers for the chart components and hooks.
  *
@@ -46,6 +52,7 @@ function ChartDataProviderPremium(props) {
     slots,
     slotProps
   } = useChartDataProviderPremiumProps(_extends({}, props, {
+    seriesConfig: props.seriesConfig ?? defaultSeriesConfigPremium,
     plugins: props.plugins ?? DEFAULT_PLUGINS
   }));
   useLicenseVerifier(packageIdentifier, releaseInfo);

package/esm/ChartDataProviderPremium/index.d.ts

@@ -1 +1 @@
-export * from "./ChartDataProviderPremium.js";
+export { ChartDataProviderPremium, type ChartDataProviderPremiumProps } from "./ChartDataProviderPremium.js";

package/esm/ChartDataProviderPremium/index.js

@@ -1 +1 @@
-export * from "./ChartDataProviderPremium.js";
+export { ChartDataProviderPremium } from "./ChartDataProviderPremium.js";

package/esm/ChartZoomSlider/internals/previews/RangeBarPreviewPlot.d.ts

@@ -0,0 +1,2 @@
+import { type PreviewPlotProps } from '@mui/x-charts-pro/internals';
+export declare function RangeBarPreviewPlot(props: PreviewPlotProps): import("react/jsx-runtime").JSX.Element;

package/esm/ChartZoomSlider/internals/previews/RangeBarPreviewPlot.js

@@ -0,0 +1,53 @@
+import { selectorChartPreviewComputedXAxis, selectorChartPreviewComputedYAxis, useStore } from '@mui/x-charts/internals';
+import { BarElement } from '@mui/x-charts/BarChart';
+import { useRangeBarPlotData } from "../../../BarChartPremium/RangeBar/useRangeBarPlotData.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+export function RangeBarPreviewPlot(props) {
+  const drawingArea = {
+    left: props.x,
+    top: props.y,
+    width: props.width,
+    height: props.height,
+    right: props.x + props.width,
+    bottom: props.y + props.height
+  };
+  const completedData = useBarPreviewData(props.axisId, drawingArea);
+  return /*#__PURE__*/_jsx("g", {
+    children: completedData.map(({
+      seriesId,
+      layout,
+      xOrigin,
+      yOrigin,
+      data
+    }) => /*#__PURE__*/_jsx("g", {
+      children: data.map(({
+        dataIndex,
+        color,
+        x,
+        y,
+        width,
+        height
+      }) => {
+        return /*#__PURE__*/_jsx(BarElement, {
+          id: seriesId,
+          dataIndex: dataIndex,
+          color: color,
+          skipAnimation: true,
+          layout: layout ?? 'vertical',
+          x: x,
+          xOrigin: xOrigin,
+          y: y,
+          yOrigin: yOrigin,
+          width: width,
+          height: height
+        }, dataIndex);
+      })
+    }, seriesId))
+  });
+}
+function useBarPreviewData(axisId, drawingArea) {
+  const store = useStore();
+  const xAxes = store.use(selectorChartPreviewComputedXAxis, axisId);
+  const yAxes = store.use(selectorChartPreviewComputedYAxis, axisId);
+  return useRangeBarPlotData(drawingArea, xAxes, yAxes);
+}

package/esm/hooks/animation/index.d.ts

@@ -0,0 +1 @@
+export * from "./useAnimateRangeBar.js";

package/esm/hooks/animation/index.js

@@ -0,0 +1 @@
+export * from "./useAnimateRangeBar.js";

package/esm/hooks/animation/useAnimateRangeBar.d.ts

@@ -0,0 +1,18 @@
+import type * as React from 'react';
+import { type AnimatedRangeBarElementProps } from "../../BarChartPremium/RangeBar/AnimatedRangeBarElement.js";
+type UseAnimateRangeBarParams = Pick<AnimatedRangeBarElementProps, 'x' | 'y' | 'xOrigin' | 'yOrigin' | 'width' | 'height' | 'skipAnimation' | 'layout'> & {
+  ref?: React.Ref<SVGRectElement>;
+};
+type UseAnimateRangeBarReturnValue = {
+  ref: React.Ref<SVGRectElement>;
+} & Pick<AnimatedRangeBarElementProps, 'x' | 'y' | 'width' | 'height'>;
+/**
+ * Animates a range bar from its center outwards.
+ * The animation only happens in the direction of the numerical axis (x-axis for vertical layout, y-axis for horizontal layout).
+ * The other direction remains constant during the animation.
+ *
+ * The props object also accepts a `ref` which will be merged with the ref returned from this hook. This means you can
+ * pass the ref returned by this hook to the `path` element and the `ref` provided as argument will also be called.
+ */
+export declare function useAnimateRangeBar(props: UseAnimateRangeBarParams): UseAnimateRangeBarReturnValue;
+export {};

package/esm/hooks/animation/useAnimateRangeBar.js

@@ -0,0 +1,51 @@
+import { interpolateNumber } from '@mui/x-charts-vendor/d3-interpolate';
+import { useAnimate } from '@mui/x-charts/hooks';
+function rangeBarPropsInterpolator(from, to) {
+  const interpolateX = interpolateNumber(from.x, to.x);
+  const interpolateY = interpolateNumber(from.y, to.y);
+  const interpolateWidth = interpolateNumber(from.width, to.width);
+  const interpolateHeight = interpolateNumber(from.height, to.height);
+  return t => {
+    return {
+      x: interpolateX(t),
+      y: interpolateY(t),
+      width: interpolateWidth(t),
+      height: interpolateHeight(t)
+    };
+  };
+}
+
+/**
+ * Animates a range bar from its center outwards.
+ * The animation only happens in the direction of the numerical axis (x-axis for vertical layout, y-axis for horizontal layout).
+ * The other direction remains constant during the animation.
+ *
+ * The props object also accepts a `ref` which will be merged with the ref returned from this hook. This means you can
+ * pass the ref returned by this hook to the `path` element and the `ref` provided as argument will also be called.
+ */
+export function useAnimateRangeBar(props) {
+  const initialProps = {
+    x: props.layout === 'vertical' ? props.x : props.x + props.width / 2,
+    y: props.layout === 'vertical' ? props.y + props.height / 2 : props.y,
+    width: props.layout === 'vertical' ? props.width : 0,
+    height: props.layout === 'vertical' ? 0 : props.height
+  };
+  return useAnimate({
+    x: props.x,
+    y: props.y,
+    width: props.width,
+    height: props.height
+  }, {
+    createInterpolator: rangeBarPropsInterpolator,
+    applyProps(element, animatedProps) {
+      element.setAttribute('x', animatedProps.x.toString());
+      element.setAttribute('y', animatedProps.y.toString());
+      element.setAttribute('width', animatedProps.width.toString());
+      element.setAttribute('height', animatedProps.height.toString());
+    },
+    transformProps: p => p,
+    initialProps,
+    skip: props.skipAnimation,
+    ref: props.ref
+  });
+}

package/esm/hooks/index.d.ts

@@ -1 +1,3 @@
-export * from '@mui/x-charts-pro/hooks';
+export * from '@mui/x-charts-pro/hooks';
+export * from "./animation/index.js";
+export * from "./useRangeBarSeries.js";

package/esm/hooks/index.js

@@ -1,3 +1,6 @@
 // This re-export-block is automatically generated, to customize, simply remove the block.
 export * from '@mui/x-charts-pro/hooks';
-// End of re-export-block
+// End of re-export-block
+
+export * from "./animation/index.js";
+export * from "./useRangeBarSeries.js";

package/esm/hooks/useRangeBarSeries.d.ts

@@ -0,0 +1,34 @@
+import { type ChartSeriesDefaultized, type ProcessedSeries } from '@mui/x-charts/internals';
+import { type SeriesId } from '@mui/x-charts/models';
+export type UseRangeBarSeriesReturnValue = ChartSeriesDefaultized<'rangeBar'>;
+export type UseRangeBarSeriesContextReturnValue = ProcessedSeries['rangeBar'];
+/**
+ * Get access to the internal state of range bar series.
+ *
+ * @param {SeriesId} seriesId The id of the series to get.
+ * @returns {UseRangeBarSeriesReturnValue} the range bar series
+ */
+export declare function useRangeBarSeries(seriesId: SeriesId): UseRangeBarSeriesReturnValue | undefined;
+/**
+ * Get access to the internal state of range bar series.
+ *
+ * When called without arguments, it returns all range bar series.
+ *
+ * @returns {UseRangeBarSeriesReturnValue[]} the range bar series
+ */
+export declare function useRangeBarSeries(): UseRangeBarSeriesReturnValue[];
+/**
+ * Get access to the internal state of range bar series.
+ *
+ * @param {SeriesId[]} seriesIds The ids of the series to get. Order is preserved.
+ * @returns {UseRangeBarSeriesReturnValue[]} the range bar series
+ */
+export declare function useRangeBarSeries(seriesIds: SeriesId[]): UseRangeBarSeriesReturnValue[];
+/**
+ * Get access to the internal state of range bar series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * @returns the range bar series
+ */
+export declare function useRangeBarSeriesContext(): UseRangeBarSeriesContextReturnValue;