@mui/x-charts 8.0.0-alpha.10 → 8.0.0-alpha.12

package/modern/hooks/useAxisEvents.js

@@ -1,165 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { isBandScale } from "../internals/isBandScale.js";
-import { getSVGPoint } from "../internals/getSVGPoint.js";
-import { useSvgRef } from "./useSvgRef.js";
-import { useStore } from "../internals/store/useStore.js";
-import { useChartContext } from "../context/ChartProvider/index.js";
-import { useXAxes, useYAxes } from "./useAxis.js";
-function getAsANumber(value) {
-  return value instanceof Date ? value.getTime() : value;
-}
-export const useAxisEvents = disableAxisListener => {
-  const svgRef = useSvgRef();
-  const {
-    instance
-  } = useChartContext();
-  const {
-    xAxis,
-    xAxisIds
-  } = useXAxes();
-  const {
-    yAxis,
-    yAxisIds
-  } = useYAxes();
-  const store = useStore();
-  const usedXAxis = xAxisIds[0];
-  const usedYAxis = yAxisIds[0];
-
-  // Use a ref to avoid rerendering on every mousemove event.
-  const mousePosition = React.useRef({
-    isInChart: false,
-    x: -1,
-    y: -1
-  });
-  React.useEffect(() => {
-    const element = svgRef.current;
-    if (element === null || disableAxisListener || !store) {
-      return () => {};
-    }
-    function getNewAxisState(axisConfig, mouseValue) {
-      const {
-        scale,
-        data: axisData,
-        reverse
-      } = axisConfig;
-      if (!isBandScale(scale)) {
-        const value = scale.invert(mouseValue);
-        if (axisData === undefined) {
-          return {
-            value,
-            index: -1
-          };
-        }
-        const valueAsNumber = getAsANumber(value);
-        const closestIndex = axisData?.findIndex((pointValue, index) => {
-          const v = getAsANumber(pointValue);
-          if (v > valueAsNumber) {
-            if (index === 0 || Math.abs(valueAsNumber - v) <= Math.abs(valueAsNumber - getAsANumber(axisData[index - 1]))) {
-              return true;
-            }
-          }
-          if (v <= valueAsNumber) {
-            if (index === axisData.length - 1 || Math.abs(getAsANumber(value) - v) < Math.abs(getAsANumber(value) - getAsANumber(axisData[index + 1]))) {
-              return true;
-            }
-          }
-          return false;
-        });
-        return {
-          value: closestIndex !== undefined && closestIndex >= 0 ? axisData[closestIndex] : value,
-          index: closestIndex
-        };
-      }
-      const dataIndex = scale.bandwidth() === 0 ? Math.floor((mouseValue - Math.min(...scale.range()) + scale.step() / 2) / scale.step()) : Math.floor((mouseValue - Math.min(...scale.range())) / scale.step());
-      if (dataIndex < 0 || dataIndex >= axisData.length) {
-        return null;
-      }
-      if (reverse) {
-        const reverseIndex = axisData.length - 1 - dataIndex;
-        return {
-          index: reverseIndex,
-          value: axisData[reverseIndex]
-        };
-      }
-      return {
-        index: dataIndex,
-        value: axisData[dataIndex]
-      };
-    }
-    const handleOut = () => {
-      mousePosition.current = {
-        isInChart: false,
-        x: -1,
-        y: -1
-      };
-      store.update(prev => _extends({}, prev, {
-        interaction: {
-          item: null,
-          axis: {
-            x: null,
-            y: null
-          }
-        }
-      }));
-    };
-    const handleMove = event => {
-      const target = 'targetTouches' in event ? event.targetTouches[0] : event;
-      const svgPoint = getSVGPoint(element, target);
-      mousePosition.current.x = svgPoint.x;
-      mousePosition.current.y = svgPoint.y;
-      if (!instance.isPointInside(svgPoint, {
-        targetElement: event.target
-      })) {
-        if (mousePosition.current.isInChart) {
-          store.update(prev => _extends({}, prev, {
-            interaction: {
-              item: null,
-              axis: {
-                x: null,
-                y: null
-              }
-            }
-          }));
-          mousePosition.current.isInChart = false;
-        }
-        return;
-      }
-      mousePosition.current.isInChart = true;
-      const newStateX = getNewAxisState(xAxis[usedXAxis], svgPoint.x);
-      const newStateY = getNewAxisState(yAxis[usedYAxis], svgPoint.y);
-      store.update(prev => _extends({}, prev, {
-        interaction: _extends({}, prev.interaction, {
-          axis: _extends({}, prev.interaction.axis, prev.interaction.axis.x?.index !== newStateX?.index || prev.interaction.axis.x?.value !== newStateX?.value ? {
-            x: newStateX
-          } : {}, prev.interaction.axis.y?.index !== newStateY?.index || prev.interaction.axis.y?.value !== newStateY?.value ? {
-            y: newStateY
-          } : {})
-        })
-      }));
-    };
-    const handleDown = event => {
-      const target = event.currentTarget;
-      if (!target) {
-        return;
-      }
-      if (target.hasPointerCapture(event.pointerId)) {
-        target.releasePointerCapture(event.pointerId);
-      }
-    };
-    element.addEventListener('pointerdown', handleDown);
-    element.addEventListener('pointermove', handleMove);
-    element.addEventListener('pointerout', handleOut);
-    element.addEventListener('pointercancel', handleOut);
-    element.addEventListener('pointerleave', handleOut);
-    return () => {
-      element.removeEventListener('pointerdown', handleDown);
-      element.removeEventListener('pointermove', handleMove);
-      element.removeEventListener('pointerout', handleOut);
-      element.removeEventListener('pointercancel', handleOut);
-      element.removeEventListener('pointerleave', handleOut);
-    };
-  }, [svgRef, store, usedYAxis, yAxis, usedXAxis, xAxis, disableAxisListener, instance]);
-};

package/modern/hooks/useBarSeries.d.ts

@@ -0,0 +1,36 @@
+import { ProcessedSeries } from "../internals/plugins/corePlugins/useChartSeries/useChartSeries.types.js";
+import { SeriesId } from "../models/seriesType/common.js";
+import { ChartSeriesDefaultized } from "../models/seriesType/config.js";
+export type UseBarSeriesReturnValue = ChartSeriesDefaultized<'bar'>;
+export type UseBarSeriesContextReturnValue = ProcessedSeries['bar'];
+/**
+ * Get access to the internal state of bar series.
+ *
+ * @param {SeriesId} seriesId The id of the series to get.
+ * @returns {UseBarSeriesReturnValue} the bar series
+ */
+export declare function useBarSeries(seriesId: SeriesId): UseBarSeriesReturnValue | undefined;
+/**
+ * Get access to the internal state of bar series.
+ *
+ * When called without arguments, it returns all bar series.
+ *
+ * @returns {UseBarSeriesReturnValue[]} the bar series
+ */
+export declare function useBarSeries(): UseBarSeriesReturnValue[];
+/**
+ * Get access to the internal state of bar series.
+ *
+ * @param {SeriesId[]} seriesIds The ids of the series to get. Order is preserved.
+ * @returns {UseBarSeriesReturnValue[]} the bar series
+ */
+export declare function useBarSeries(seriesIds: SeriesId[]): UseBarSeriesReturnValue[];
+/**
+ * Get access to the internal state of bar series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * - stackingGroups: the array of stacking groups. Each group contains the series ids stacked and the strategy to use.
+ * @returns the bar series
+ */
+export declare function useBarSeriesContext(): UseBarSeriesContextReturnValue;

package/modern/hooks/useBarSeries.js

@@ -0,0 +1,43 @@
+'use client';
+
+import { createSeriesSelectorsOfType, createAllSeriesSelectorOfType } from "../internals/createSeriesSelectorOfType.js";
+const useSelectorSeries = createSeriesSelectorsOfType('bar');
+const useSelectorSeriesContext = createAllSeriesSelectorOfType('bar');
+
+/**
+ * Get access to the internal state of bar series.
+ *
+ * @param {SeriesId} seriesId The id of the series to get.
+ * @returns {UseBarSeriesReturnValue} the bar series
+ */
+
+/**
+ * Get access to the internal state of bar series.
+ *
+ * When called without arguments, it returns all bar series.
+ *
+ * @returns {UseBarSeriesReturnValue[]} the bar series
+ */
+
+/**
+ * Get access to the internal state of bar series.
+ *
+ * @param {SeriesId[]} seriesIds The ids of the series to get. Order is preserved.
+ * @returns {UseBarSeriesReturnValue[]} the bar series
+ */
+
+export function useBarSeries(seriesIds) {
+  return useSelectorSeries(seriesIds);
+}
+
+/**
+ * Get access to the internal state of bar series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * - stackingGroups: the array of stacking groups. Each group contains the series ids stacked and the strategy to use.
+ * @returns the bar series
+ */
+export function useBarSeriesContext() {
+  return useSelectorSeriesContext();
+}

package/modern/hooks/useChartGradientId.d.ts

@@ -0,0 +1,31 @@
+import { AxisId } from "../models/axis.js";
+/**
+ * Returns a function that generates a gradient id for the given axis id.
+ */
+export declare function useChartGradientIdBuilder(): (axisId: AxisId) => string;
+/**
+ * Returns a function that generates a gradient id for the given axis id.
+ */
+export declare function useChartGradientIdObjectBoundBuilder(): (axisId: AxisId) => string;
+/**
+ * Returns a gradient id for the given axis id.
+ *
+ * Can be useful when reusing the same gradient on custom components.
+ *
+ * For a gradient that respects the coordinates of the object on which it is applied, use `useChartGradientIdObjectBound` instead.
+ *
+ * @param axisId the axis id
+ * @returns the gradient id
+ */
+export declare function useChartGradientId(axisId: AxisId): string;
+/**
+ * Returns a gradient id for the given axis id.
+ *
+ * Can be useful when reusing the same gradient on custom components.
+ *
+ * This gradient differs from `useChartGradientId` in that it respects the coordinates of the object on which it is applied.
+ *
+ * @param axisId the axis id
+ * @returns the gradient id
+ */
+export declare function useChartGradientIdObjectBound(axisId: AxisId): string;

package/modern/hooks/useChartId.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Get the unique identifier of the chart.
+ * @returns chartId if it exists.
+ */
+export declare function useChartId(): string | undefined;

package/modern/hooks/useChartId.js

@@ -3,6 +3,11 @@
 import { useStore } from "../internals/store/useStore.js";
 import { useSelector } from "../internals/store/useSelector.js";
 import { selectorChartId } from "../internals/plugins/corePlugins/useChartId/useChartId.selectors.js";
+
+/**
+ * Get the unique identifier of the chart.
+ * @returns chartId if it exists.
+ */
 export function useChartId() {
   const store = useStore();
   return useSelector(store, selectorChartId);

package/modern/hooks/useColorScale.d.ts

@@ -0,0 +1,22 @@
+import { AxisId, AxisScaleComputedConfig, ScaleName } from "../models/axis.js";
+/**
+ * Get the X axis color scale.
+ *
+ * @param {AxisId | undefined} axisId - If provided returns color scale for axisId, else returns the values for the default axis.
+ * @returns {AxisScaleComputedConfig[S]['colorScale'] | undefined} The color scale for the specified X axis, or undefined if not found.
+ */
+export declare function useXColorScale<S extends ScaleName>(axisId?: AxisId): AxisScaleComputedConfig[S]['colorScale'] | undefined;
+/**
+ * Get the Y axis color scale.
+ *
+ * @param {AxisId | undefined} axisId - If provided returns color scale for axisId, else returns the values for the default axis.
+ * @returns {AxisScaleComputedConfig[S]['colorScale'] | undefined} The color scale for the specified Y axis, or undefined if not found.
+ */
+export declare function useYColorScale<S extends ScaleName>(axisId?: AxisId): AxisScaleComputedConfig[S]['colorScale'] | undefined;
+/**
+ * Get the Z axis color scale.
+ *
+ * @param {AxisId | undefined} axisId - If provided returns color scale for axisId, else returns the values for the default axis.
+ * @returns {AxisScaleComputedConfig[S]['colorScale'] | undefined} The color scale for the specified Z axis, or undefined if not found.
+ */
+export declare function useZColorScale<S extends ScaleName>(axisId?: AxisId): AxisScaleComputedConfig[S]['colorScale'] | undefined;

package/modern/hooks/useColorScale.js

@@ -1,28 +1,37 @@
 'use client';
 
-import { useXAxes, useYAxes } from "./useAxis.js";
-import { useZAxes } from "./useZAxis.js";
-export function useXColorScale(identifier) {
-  const {
-    xAxis,
-    xAxisIds
-  } = useXAxes();
-  const id = typeof identifier === 'string' ? identifier : xAxisIds[identifier ?? 0];
-  return xAxis[id].colorScale;
+import { useXAxis, useYAxis } from "./useAxis.js";
+import { useZAxis } from "./useZAxis.js";
+
+/**
+ * Get the X axis color scale.
+ *
+ * @param {AxisId | undefined} axisId - If provided returns color scale for axisId, else returns the values for the default axis.
+ * @returns {AxisScaleComputedConfig[S]['colorScale'] | undefined} The color scale for the specified X axis, or undefined if not found.
+ */
+export function useXColorScale(axisId) {
+  const axis = useXAxis(axisId);
+  return axis.colorScale;
 }
-export function useYColorScale(identifier) {
-  const {
-    yAxis,
-    yAxisIds
-  } = useYAxes();
-  const id = typeof identifier === 'string' ? identifier : yAxisIds[identifier ?? 0];
-  return yAxis[id].colorScale;
+
+/**
+ * Get the Y axis color scale.
+ *
+ * @param {AxisId | undefined} axisId - If provided returns color scale for axisId, else returns the values for the default axis.
+ * @returns {AxisScaleComputedConfig[S]['colorScale'] | undefined} The color scale for the specified Y axis, or undefined if not found.
+ */
+export function useYColorScale(axisId) {
+  const axis = useYAxis(axisId);
+  return axis.colorScale;
 }
-export function useZColorScale(identifier) {
-  const {
-    zAxis,
-    zAxisIds
-  } = useZAxes();
-  const id = typeof identifier === 'string' ? identifier : zAxisIds[identifier ?? 0];
-  return zAxis[id]?.colorScale;
+
+/**
+ * Get the Z axis color scale.
+ *
+ * @param {AxisId | undefined} axisId - If provided returns color scale for axisId, else returns the values for the default axis.
+ * @returns {AxisScaleComputedConfig[S]['colorScale'] | undefined} The color scale for the specified Z axis, or undefined if not found.
+ */
+export function useZColorScale(axisId) {
+  const axis = useZAxis(axisId);
+  return axis.colorScale;
 }

package/modern/hooks/useDrawingArea.d.ts

@@ -0,0 +1,16 @@
+export type ChartDrawingArea = {
+  top: number;
+  left: number;
+  right: number;
+  bottom: number;
+  width: number;
+  height: number;
+};
+/**
+ * Get the drawing area dimensions and coordinates. The drawing area is the area where the chart is rendered.
+ *
+ * It includes the left, top, width, height, bottom, and right dimensions.
+ *
+ * @returns The drawing area dimensions.
+ */
+export declare function useDrawingArea(): ChartDrawingArea;

package/modern/hooks/useDrawingArea.js

@@ -3,6 +3,13 @@
 import { useStore } from "../internals/store/useStore.js";
 import { useSelector } from "../internals/store/useSelector.js";
 import { selectorChartDrawingArea } from "../internals/plugins/corePlugins/useChartDimensions/useChartDimensions.selectors.js";
+/**
+ * Get the drawing area dimensions and coordinates. The drawing area is the area where the chart is rendered.
+ *
+ * It includes the left, top, width, height, bottom, and right dimensions.
+ *
+ * @returns The drawing area dimensions.
+ */
 export function useDrawingArea() {
   const store = useStore();
   return useSelector(store, selectorChartDrawingArea);

package/modern/hooks/useInteractionItemProps.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { SeriesItemIdentifier } from "../models/index.js";
+export declare const useInteractionItemProps: (skip?: boolean) => (() => {}) | ((data: SeriesItemIdentifier) => {
+  onPointerEnter: () => void;
+  onPointerLeave: (event: React.PointerEvent) => void;
+  onPointerDown: (event: React.PointerEvent) => void;
+});

package/modern/hooks/useItemHighlighted.d.ts

@@ -0,0 +1,23 @@
+import { HighlightItemData } from "../internals/plugins/featurePlugins/useChartHighlight/useChartHighlight.types.js";
+type UseItemHighlightedReturnType = {
+  /**
+   * Whether the item is highlighted.
+   */
+  isHighlighted: boolean;
+  /**
+   * Whether the item is faded.
+   */
+  isFaded: boolean;
+};
+type UseItemHighlightedParams = HighlightItemData | null;
+/**
+ * A hook to check the highlighted state of the item.
+ * This function already calculates that an item is not faded if it is highlighted.
+ *
+ * If you need fine control over the state, use the `useItemHighlightedGetter` hook instead.
+ *
+ * @param {HighlightItemData | null} item is the item to check
+ * @returns {UseItemHighlightedReturnType} the state of the item
+ */
+export declare function useItemHighlighted(item: UseItemHighlightedParams): UseItemHighlightedReturnType;
+export {};

package/modern/hooks/useItemHighlightedGetter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A hook to check the highlighted state of multiple items.
+ * If you're interested by a single one, consider using `useItemHighlighted`.
+ *
+ * Warning: highlighted and faded can both be true at the same time.
+ * We recommend to first test if item is highlighted: `const faded = !highlighted && isFaded(item)`
+ * @returns {{ isHighlighted, isFaded }} callbacks to get the state of the item.
+ */
+export declare function useItemHighlightedGetter(): {
+  isHighlighted: (item: import("..").HighlightItemData | null) => boolean;
+  isFaded: (item: import("..").HighlightItemData | null) => boolean;
+};

package/modern/hooks/useLegend.d.ts

@@ -0,0 +1,13 @@
+import type { LegendItemParams } from '../ChartsLegend';
+/**
+ * Get the legend items to display.
+ *
+ * This hook is used by the `ChartsLegend` component. And will return the legend items formatted for display.
+ *
+ * An alternative is to use the `useSeries` hook and format the legend items yourself.
+ *
+ * @returns legend data
+ */
+export declare function useLegend(): {
+  items: LegendItemParams[];
+};

package/modern/hooks/useLineSeries.d.ts

@@ -0,0 +1,36 @@
+import { ProcessedSeries } from "../internals/plugins/corePlugins/useChartSeries/useChartSeries.types.js";
+import { SeriesId } from "../models/seriesType/common.js";
+import { ChartSeriesDefaultized } from "../models/seriesType/config.js";
+export type UseLineSeriesReturnValue = ChartSeriesDefaultized<'line'>;
+export type UseLineSeriesContextReturnValue = ProcessedSeries['line'];
+/**
+ * Get access to the internal state of line series.
+ *
+ * @param {SeriesId} seriesId The id of the series to get.
+ * @returns {UseLineSeriesReturnValue} the line series
+ */
+export declare function useLineSeries(seriesId: SeriesId): UseLineSeriesReturnValue | undefined;
+/**
+ * Get access to the internal state of line series.
+ *
+ * When called without arguments, it returns all line series.
+ *
+ * @returns {UseLineSeriesReturnValue[]} the line series
+ */
+export declare function useLineSeries(): UseLineSeriesReturnValue[];
+/**
+ * Get access to the internal state of line series.
+ *
+ * @param {SeriesId[]} seriesIds The ids of the series to get. Order is preserved.
+ * @returns {UseLineSeriesReturnValue[]} the line series
+ */
+export declare function useLineSeries(seriesIds: SeriesId[]): UseLineSeriesReturnValue[];
+/**
+ * Get access to the internal state of line series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * - stackingGroups: the array of stacking groups. Each group contains the series ids stacked and the strategy to use.
+ * @returns the line series
+ */
+export declare function useLineSeriesContext(): UseLineSeriesContextReturnValue;

package/modern/hooks/useLineSeries.js

@@ -0,0 +1,43 @@
+'use client';
+
+import { createSeriesSelectorsOfType, createAllSeriesSelectorOfType } from "../internals/createSeriesSelectorOfType.js";
+const useSelectorSeries = createSeriesSelectorsOfType('line');
+const useSelectorSeriesContext = createAllSeriesSelectorOfType('line');
+
+/**
+ * Get access to the internal state of line series.
+ *
+ * @param {SeriesId} seriesId The id of the series to get.
+ * @returns {UseLineSeriesReturnValue} the line series
+ */
+
+/**
+ * Get access to the internal state of line series.
+ *
+ * When called without arguments, it returns all line series.
+ *
+ * @returns {UseLineSeriesReturnValue[]} the line series
+ */
+
+/**
+ * Get access to the internal state of line series.
+ *
+ * @param {SeriesId[]} seriesIds The ids of the series to get. Order is preserved.
+ * @returns {UseLineSeriesReturnValue[]} the line series
+ */
+
+export function useLineSeries(seriesIds) {
+  return useSelectorSeries(seriesIds);
+}
+
+/**
+ * Get access to the internal state of line series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * - stackingGroups: the array of stacking groups. Each group contains the series ids stacked and the strategy to use.
+ * @returns the line series
+ */
+export function useLineSeriesContext() {
+  return useSelectorSeriesContext();
+}

package/modern/hooks/useMounted.d.ts

@@ -0,0 +1 @@
+export declare function useMounted(defer?: boolean): boolean;

package/modern/hooks/usePieSeries.d.ts

@@ -0,0 +1,35 @@
+import { ProcessedSeries } from "../internals/plugins/corePlugins/useChartSeries/useChartSeries.types.js";
+import { SeriesId } from "../models/seriesType/common.js";
+import { ChartSeriesDefaultized } from "../models/seriesType/config.js";
+export type UsePieSeriesReturnValue = ChartSeriesDefaultized<'pie'>;
+export type UsePieSeriesContextReturnValue = ProcessedSeries['pie'];
+/**
+ * Get access to the internal state of pie series.
+ *
+ * @param {SeriesId} seriesId The id of the series to get.
+ * @returns {UsePieSeriesReturnValue} the pie series
+ */
+export declare function usePieSeries(seriesId: SeriesId): UsePieSeriesReturnValue | undefined;
+/**
+ * Get access to the internal state of pie series.
+ *
+ * When called without arguments, it returns all pie series.
+ *
+ * @returns {UsePieSeriesReturnValue[]} the pie series
+ */
+export declare function usePieSeries(): UsePieSeriesReturnValue[];
+/**
+ * Get access to the internal state of pie series.
+ *
+ * @param {SeriesId[]} seriesIds The ids of the series to get. Order is preserved.
+ * @returns {UsePieSeriesReturnValue[]} the pie series
+ */
+export declare function usePieSeries(seriesIds: SeriesId[]): UsePieSeriesReturnValue[];
+/**
+ * Get access to the internal state of pie series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * @returns the pie series
+ */
+export declare function usePieSeriesContext(): UsePieSeriesContextReturnValue;

package/modern/hooks/usePieSeries.js

@@ -0,0 +1,42 @@
+'use client';
+
+import { createSeriesSelectorsOfType, createAllSeriesSelectorOfType } from "../internals/createSeriesSelectorOfType.js";
+const useSelectorSeries = createSeriesSelectorsOfType('pie');
+const useSelectorSeriesContext = createAllSeriesSelectorOfType('pie');
+
+/**
+ * Get access to the internal state of pie series.
+ *
+ * @param {SeriesId} seriesId The id of the series to get.
+ * @returns {UsePieSeriesReturnValue} the pie series
+ */
+
+/**
+ * Get access to the internal state of pie series.
+ *
+ * When called without arguments, it returns all pie series.
+ *
+ * @returns {UsePieSeriesReturnValue[]} the pie series
+ */
+
+/**
+ * Get access to the internal state of pie series.
+ *
+ * @param {SeriesId[]} seriesIds The ids of the series to get. Order is preserved.
+ * @returns {UsePieSeriesReturnValue[]} the pie series
+ */
+
+export function usePieSeries(seriesIds) {
+  return useSelectorSeries(seriesIds);
+}
+
+/**
+ * Get access to the internal state of pie series.
+ * The returned object contains:
+ * - series: a mapping from ids to series attributes.
+ * - seriesOrder: the array of series ids.
+ * @returns the pie series
+ */
+export function usePieSeriesContext() {
+  return useSelectorSeriesContext();
+}

package/modern/hooks/useScale.d.ts

@@ -0,0 +1,22 @@
+import { AxisId, AxisScaleConfig, D3Scale, ScaleName } from "../models/axis.js";
+/**
+ * For a given scale return a function that map value to their position.
+ * Useful when dealing with specific scale such as band.
+ * @param {D3Scale} scale The scale to use
+ * @returns {(value: any) => number} A function that map value to their position
+ */
+export declare function getValueToPositionMapper(scale: D3Scale): (value: any) => number;
+/**
+ * Get the X scale.
+ *
+ * @param {AxisId | undefined} axisId - If provided returns the scale for the x axis with axisId, else returns the values for the default x axis.
+ * @returns {AxisScaleConfig[S]['scale']} The scale for the specified X axis.
+ */
+export declare function useXScale<S extends ScaleName>(axisId?: AxisId): AxisScaleConfig[S]['scale'];
+/**
+ * Get the Y scale.
+ *
+ * @param {AxisId | undefined} axisId - If provided returns the scale for the y axis with axisId, else returns the values for the default y axis.
+ * @returns {AxisScaleConfig[S]['scale']} The scale for the specified Y axis.
+ */
+export declare function useYScale<S extends ScaleName>(axisId?: AxisId): AxisScaleConfig[S]['scale'];