@mui/x-charts 8.11.3 → 8.12.0

package/esm/internals/plugins/featurePlugins/useChartHighlight/useChartHighlight.selectors.js

@@ -1,6 +1,7 @@
 import { createSelector } from "../../utils/selectors.js";
 import { createIsHighlighted } from "./createIsHighlighted.js";
 import { createIsFaded } from "./createIsFaded.js";
+import { getSeriesHighlightedItem, getSeriesUnfadedItem, isSeriesFaded, isSeriesHighlighted } from "./highlightStates.js";
 const selectHighlight = state => state.highlight;
 const selectSeries = state => state.series;
 export const selectorChartsHighlightScopePerSeriesId = createSelector([selectSeries], series => {
@@ -32,6 +33,10 @@ export const selectorChartsIsFadedCallback = createSelector([selectorChartsHighl
 export const selectorChartsIsHighlighted = createSelector([selectorChartsHighlightScope, selectorChartsHighlightedItem, (_, item) => item], function selectorChartsIsHighlighted(highlightScope, highlightedItem, item) {
   return createIsHighlighted(highlightScope, highlightedItem)(item);
 });
+export const selectorChartIsSeriesHighlighted = createSelector([selectorChartsHighlightScope, selectorChartsHighlightedItem, (_, seriesId) => seriesId], isSeriesHighlighted);
+export const selectorChartIsSeriesFaded = createSelector([selectorChartsHighlightScope, selectorChartsHighlightedItem, (_, seriesId) => seriesId], isSeriesFaded);
+export const selectorChartSeriesUnfadedItem = createSelector([selectorChartsHighlightScope, selectorChartsHighlightedItem, (_, seriesId) => seriesId], getSeriesUnfadedItem);
+export const selectorChartSeriesHighlightedItem = createSelector([selectorChartsHighlightScope, selectorChartsHighlightedItem, (_, seriesId) => seriesId], getSeriesHighlightedItem);
 export const selectorChartsIsFaded = createSelector([selectorChartsHighlightScope, selectorChartsHighlightedItem, (_, item) => item], function selectorChartsIsFaded(highlightScope, highlightedItem, item) {
   return createIsFaded(highlightScope, highlightedItem)(item);
 });

package/esm/internals/plugins/featurePlugins/useChartInteraction/checkHasInteractionPlugin.d.ts

@@ -0,0 +1,3 @@
+import { ChartAnyPluginSignature, ChartUsedInstance } from "../../models/plugin.js";
+import { UseChartInteractionInstance } from "./useChartInteraction.types.js";
+export declare function checkHasInteractionPlugin<T extends ChartAnyPluginSignature>(instance: ChartUsedInstance<T>): instance is ChartUsedInstance<T> & UseChartInteractionInstance;

package/esm/internals/plugins/featurePlugins/useChartInteraction/checkHasInteractionPlugin.js

@@ -0,0 +1,3 @@
+export function checkHasInteractionPlugin(instance) {
+  return instance.setPointerCoordinate !== undefined;
+}

package/esm/internals/plugins/featurePlugins/useChartKeyboardNavigation/index.d.ts

@@ -0,0 +1,3 @@
+export { useChartKeyboardNavigation } from "./useChartKeyboardNavigation.js";
+export * from "./useChartKeyboardNavigation.selectors.js";
+export type { UseChartKeyboardNavigationSignature } from "./useChartKeyboardNavigation.types.js";

package/esm/internals/plugins/featurePlugins/useChartKeyboardNavigation/index.js

@@ -0,0 +1,2 @@
+export { useChartKeyboardNavigation } from "./useChartKeyboardNavigation.js";
+export * from "./useChartKeyboardNavigation.selectors.js";

package/esm/internals/plugins/featurePlugins/useChartKeyboardNavigation/useChartKeyboardNavigation.d.ts

@@ -0,0 +1,3 @@
+import { ChartPlugin } from "../../models/index.js";
+import { UseChartKeyboardNavigationSignature } from "./useChartKeyboardNavigation.types.js";
+export declare const useChartKeyboardNavigation: ChartPlugin<UseChartKeyboardNavigationSignature>;

package/esm/internals/plugins/featurePlugins/useChartKeyboardNavigation/useChartKeyboardNavigation.helpers.d.ts

@@ -0,0 +1,20 @@
+import { ChartSeriesType, ChartsSeriesConfig } from "../../../../models/seriesType/config.js";
+import { SeriesId } from "../../../../models/seriesType/common.js";
+import { ProcessedSeries } from "../../corePlugins/useChartSeries/index.js";
+/**
+ * Returns the next series type and id that contains some data.
+ * Returns `null` if no other series have data.
+ */
+export declare function getNextSeriesWithData(series: ProcessedSeries<keyof ChartsSeriesConfig>, type?: ChartSeriesType, seriesId?: SeriesId): {
+  type: Exclude<ChartSeriesType, 'sankey'>;
+  seriesId: SeriesId;
+} | null;
+/**
+ * Returns the previous series type and id that contains some data.
+ * Returns `null` if no other series have data.
+ */
+export declare function getPreviousSeriesWithData(series: ProcessedSeries<keyof ChartsSeriesConfig>, type?: ChartSeriesType, seriesId?: SeriesId): {
+  type: Exclude<ChartSeriesType, 'sankey'>;
+  seriesId: SeriesId;
+} | null;
+export declare function seriesHasData(series: ProcessedSeries<keyof ChartsSeriesConfig>, type: ChartSeriesType, seriesId: SeriesId): boolean | undefined;

package/esm/internals/plugins/featurePlugins/useChartKeyboardNavigation/useChartKeyboardNavigation.helpers.js

@@ -0,0 +1,88 @@
+/**
+ * Returns the next series type and id that contains some data.
+ * Returns `null` if no other series have data.
+ */
+export function getNextSeriesWithData(series, type, seriesId) {
+  const startingTypeIndex = type !== undefined && series[type] ? Object.keys(series).indexOf(type) : 0;
+  const currentSeriesIndex = type !== undefined && seriesId !== undefined && series[type] && series[type].series[seriesId] ? series[type].seriesOrder.indexOf(seriesId) : -1;
+  const typesAvailable = Object.keys(series).filter(t => t !== 'sankey');
+
+  // Loop over all series types starting with the current seriesType
+  for (let typeGap = 0; typeGap < typesAvailable.length; typeGap += 1) {
+    const typeIndex = (startingTypeIndex + typeGap) % typesAvailable.length;
+    const seriesOfType = series[typesAvailable[typeIndex]];
+
+    // Edge case for the current series type: we don't loop on previous series of the same type.
+    const startingSeriesIndex = typeGap === 0 ? currentSeriesIndex + 1 : 0;
+    for (let seriesIndex = startingSeriesIndex; seriesIndex < seriesOfType.seriesOrder.length; seriesIndex += 1) {
+      if (seriesOfType.series[seriesOfType.seriesOrder[seriesIndex]].data.length > 0) {
+        return {
+          type: typesAvailable[typeIndex],
+          seriesId: seriesOfType.seriesOrder[seriesIndex]
+        };
+      }
+    }
+  }
+
+  // End looping on the initial type up to the initial series (excluded)
+  const typeIndex = startingTypeIndex;
+  const seriesOfType = series[typesAvailable[typeIndex]];
+  const endingSeriesIndex = currentSeriesIndex;
+  for (let seriesIndex = 0; seriesIndex < endingSeriesIndex; seriesIndex += 1) {
+    if (seriesOfType.series[seriesOfType.seriesOrder[seriesIndex]].data.length > 0) {
+      return {
+        type: typesAvailable[typeIndex],
+        seriesId: seriesOfType.seriesOrder[seriesIndex]
+      };
+    }
+  }
+  return null;
+}
+
+/**
+ * Returns the previous series type and id that contains some data.
+ * Returns `null` if no other series have data.
+ */
+export function getPreviousSeriesWithData(series, type, seriesId) {
+  const startingTypeIndex = type !== undefined && series[type] ? Object.keys(series).indexOf(type) : 0;
+  const startingSeriesIndex = type !== undefined && seriesId !== undefined && series[type] && series[type].series[seriesId] ? series[type].seriesOrder.indexOf(seriesId) : 1;
+  const typesAvailable = Object.keys(series).filter(t => t !== 'sankey');
+
+  // Loop over all series types starting with the current seriesType
+  for (let typeGap = 0; typeGap < typesAvailable.length; typeGap += 1) {
+    const typeIndex = (typesAvailable.length + startingTypeIndex - typeGap) % typesAvailable.length;
+    const seriesOfType = series[typesAvailable[typeIndex]];
+    const maxGap = typeGap === 0 ? startingSeriesIndex + 1 : seriesOfType.seriesOrder.length;
+    for (let seriesGap = 1; seriesGap < maxGap; seriesGap += 1) {
+      const seriesIndex = (seriesOfType.seriesOrder.length + startingSeriesIndex - seriesGap) % seriesOfType.seriesOrder.length;
+      if (seriesOfType.series[seriesOfType.seriesOrder[seriesIndex]].data.length > 0) {
+        return {
+          type: typesAvailable[typeIndex],
+          seriesId: seriesOfType.seriesOrder[seriesIndex]
+        };
+      }
+    }
+  }
+
+  // End looping on the initial type down to the initial series (excluded)
+  const typeIndex = startingTypeIndex;
+  const seriesOfType = series[typesAvailable[typeIndex]];
+  const availableSeriesIds = seriesOfType.seriesOrder;
+  for (let seriesIndex = availableSeriesIds.length - 1; seriesIndex > startingSeriesIndex; seriesIndex -= 1) {
+    if (seriesOfType.series[seriesOfType.seriesOrder[seriesIndex]].data.length > 0) {
+      return {
+        type: typesAvailable[typeIndex],
+        seriesId: seriesOfType.seriesOrder[seriesIndex]
+      };
+    }
+  }
+  return null;
+}
+export function seriesHasData(series, type, seriesId) {
+  // @ts-ignore snakey is not in MIT version
+  if (type === 'sankey') {
+    return false;
+  }
+  const data = series[type]?.series[seriesId]?.data;
+  return data && data.length > 0;
+}

package/esm/internals/plugins/featurePlugins/useChartKeyboardNavigation/useChartKeyboardNavigation.js

@@ -0,0 +1,210 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import useEventCallback from '@mui/utils/useEventCallback';
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+import { getNextSeriesWithData, getPreviousSeriesWithData, seriesHasData } from "./useChartKeyboardNavigation.helpers.js";
+export const useChartKeyboardNavigation = ({
+  params,
+  store,
+  svgRef
+}) => {
+  const focusNextItem = useEventCallback(function focusNextItem() {
+    store.update(state => {
+      let {
+        type,
+        seriesId
+      } = state.keyboardNavigation.item ?? {};
+      if (type === undefined ||
+      // @ts-ignore sankey is not in MIT version
+      type === 'sankey' || seriesId === undefined || !seriesHasData(state.series.processedSeries, type, seriesId)) {
+        const nextSeries = getNextSeriesWithData(state.series.processedSeries, type, seriesId);
+        if (nextSeries === null) {
+          return _extends({}, state, {
+            keyboardNavigation: _extends({}, state.keyboardNavigation, {
+              item: null // No series to move the focus too.
+            })
+          });
+        }
+        type = nextSeries.type;
+        seriesId = nextSeries.seriesId;
+      }
+      const dataLength = state.series.processedSeries[type].series[seriesId].data.length;
+      return _extends({}, state, {
+        keyboardNavigation: _extends({}, state.keyboardNavigation, {
+          item: {
+            type,
+            seriesId,
+            dataIndex: ((state.keyboardNavigation.item?.dataIndex ?? -1) + 1) % dataLength
+          }
+        })
+      });
+    });
+  });
+  const focusPreviousItem = useEventCallback(function focusPreviousItem() {
+    store.update(state => {
+      let {
+        type,
+        seriesId
+      } = state.keyboardNavigation.item ?? {};
+      if (type === undefined ||
+      // @ts-ignore sankey is not in MIT version
+      type === 'sankey' || seriesId === undefined || !seriesHasData(state.series.processedSeries, type, seriesId)) {
+        const previousSeries = getPreviousSeriesWithData(state.series.processedSeries, type, seriesId);
+        if (previousSeries === null) {
+          return _extends({}, state, {
+            keyboardNavigation: _extends({}, state.keyboardNavigation, {
+              item: null // No series to move the focus too.} };
+            })
+          });
+        }
+        type = previousSeries.type;
+        seriesId = previousSeries.seriesId;
+      }
+      const dataLength = state.series.processedSeries[type].series[seriesId].data.length;
+      return _extends({}, state, {
+        keyboardNavigation: _extends({}, state.keyboardNavigation, {
+          item: {
+            type,
+            seriesId,
+            dataIndex: (dataLength + (state.keyboardNavigation.item?.dataIndex ?? 1) - 1) % dataLength
+          }
+        })
+      });
+    });
+  });
+  const focusPreviousSeries = useEventCallback(function focusPreviousSeries() {
+    let setNewSeries = false;
+    store.update(state => {
+      let {
+        type,
+        seriesId
+      } = state.keyboardNavigation.item ?? {};
+      const previousSeries = getPreviousSeriesWithData(state.series.processedSeries, type, seriesId);
+      if (previousSeries === null) {
+        return _extends({}, state, {
+          keyboardNavigation: _extends({}, state.keyboardNavigation, {
+            item: null // No series to move the focus too.
+          })
+        });
+      }
+      type = previousSeries.type;
+      seriesId = previousSeries.seriesId;
+      const dataLength = state.series.processedSeries[type].series[seriesId].data.length;
+      setNewSeries = true;
+      return _extends({}, state, {
+        keyboardNavigation: _extends({}, state.keyboardNavigation, {
+          item: {
+            type,
+            seriesId,
+            dataIndex: Math.min(dataLength - 1, state.keyboardNavigation.item?.dataIndex ?? 0)
+          }
+        })
+      });
+    });
+    return setNewSeries;
+  });
+  const focusNextSeries = useEventCallback(function focusNextSeries() {
+    let setNewSeries = false;
+    store.update(state => {
+      let {
+        type,
+        seriesId
+      } = state.keyboardNavigation.item ?? {};
+      const nextSeries = getNextSeriesWithData(state.series.processedSeries, type, seriesId);
+      if (nextSeries === null) {
+        return _extends({}, state, {
+          keyboardNavigation: _extends({}, state.keyboardNavigation, {
+            item: null // No series to move the focus too.
+          })
+        });
+      }
+      type = nextSeries.type;
+      seriesId = nextSeries.seriesId;
+      const dataLength = state.series.processedSeries[type].series[seriesId].data.length;
+      setNewSeries = true;
+      return _extends({}, state, {
+        keyboardNavigation: _extends({}, state.keyboardNavigation, {
+          item: {
+            type,
+            seriesId,
+            dataIndex: Math.min(dataLength - 1, state.keyboardNavigation.item?.dataIndex ?? 0)
+          }
+        })
+      });
+    });
+    return setNewSeries;
+  });
+  const removeFocus = useEventCallback(function removeFocus() {
+    store.update(state => {
+      if (state.keyboardNavigation.item === null) {
+        return state;
+      }
+      return _extends({}, state, {
+        keyboardNavigation: _extends({}, state.keyboardNavigation, {
+          item: null
+        })
+      });
+    });
+  });
+  React.useEffect(() => {
+    const element = svgRef.current;
+    if (!element || !params.enableKeyboardNavigation) {
+      return undefined;
+    }
+    function keyboardHandler(event) {
+      switch (event.key) {
+        case 'ArrowRight':
+          focusNextItem();
+          break;
+        case 'ArrowLeft':
+          focusPreviousItem();
+          break;
+        case 'ArrowDown':
+          {
+            const updatedStore = focusPreviousSeries();
+            if (updatedStore) {
+              // prevents scrolling
+              event.preventDefault();
+            }
+            break;
+          }
+        case 'ArrowUp':
+          {
+            const updatedStore = focusNextSeries();
+            if (updatedStore) {
+              // prevents scrolling
+              event.preventDefault();
+            }
+            break;
+          }
+        default:
+          break;
+      }
+    }
+    element.addEventListener('keydown', keyboardHandler);
+    element.addEventListener('blur', removeFocus);
+    return () => {
+      element.removeEventListener('keydown', keyboardHandler);
+      element.removeEventListener('blur', removeFocus);
+    };
+  }, [svgRef, focusNextItem, focusPreviousItem, removeFocus, focusPreviousSeries, focusNextSeries, params.enableKeyboardNavigation]);
+  useEnhancedEffect(() => store.update(prev => prev.keyboardNavigation.enableKeyboardNavigation === params.enableKeyboardNavigation ? prev : _extends({}, prev, {
+    keyboardNavigation: _extends({}, prev.keyboardNavigation, {
+      enableKeyboardNavigation: !!params.enableKeyboardNavigation
+    })
+  })), [store, params.enableKeyboardNavigation]);
+  return {
+    instance: {}
+  };
+};
+useChartKeyboardNavigation.getInitialState = params => ({
+  keyboardNavigation: {
+    item: null,
+    enableKeyboardNavigation: !!params.enableKeyboardNavigation
+  }
+});
+useChartKeyboardNavigation.params = {
+  enableKeyboardNavigation: true
+};

package/esm/internals/plugins/featurePlugins/useChartKeyboardNavigation/useChartKeyboardNavigation.selectors.d.ts

@@ -0,0 +1,25 @@
+export declare const selectorChartsHasFocusedItem: import("reselect").Selector<import("../../corePlugins/useChartId/useChartId.types.js").UseChartIdState & import("../../corePlugins/useChartExperimentalFeature/useChartExperimentalFeature.types.js").UseChartExperimentalFeaturesState & import("../../corePlugins/useChartDimensions/useChartDimensions.types.js").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types.js").UseChartSeriesState<keyof import("../../../index.js").ChartsSeriesConfig> & import("../../corePlugins/useChartAnimation/useChartAnimation.types.js").UseChartAnimationState & import("../../../index.js").UseChartInteractionListenerState & Partial<import("./useChartKeyboardNavigation.types.js").UseChartKeyboardNavigationState> & {
+  cacheKey: import("../../models/index.js").ChartStateCacheKey;
+} & {
+  cacheKey: import("../../models/index.js").ChartStateCacheKey;
+}, boolean, any[]>;
+export declare const selectorChartsFocusedSeriesType: import("reselect").Selector<import("../../corePlugins/useChartId/useChartId.types.js").UseChartIdState & import("../../corePlugins/useChartExperimentalFeature/useChartExperimentalFeature.types.js").UseChartExperimentalFeaturesState & import("../../corePlugins/useChartDimensions/useChartDimensions.types.js").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types.js").UseChartSeriesState<keyof import("../../../index.js").ChartsSeriesConfig> & import("../../corePlugins/useChartAnimation/useChartAnimation.types.js").UseChartAnimationState & import("../../../index.js").UseChartInteractionListenerState & Partial<import("./useChartKeyboardNavigation.types.js").UseChartKeyboardNavigationState> & {
+  cacheKey: import("../../models/index.js").ChartStateCacheKey;
+} & {
+  cacheKey: import("../../models/index.js").ChartStateCacheKey;
+}, keyof import("../../../index.js").ChartsSeriesConfig | undefined, any[]>;
+export declare const selectorChartsFocusedSeriesId: import("reselect").Selector<import("../../corePlugins/useChartId/useChartId.types.js").UseChartIdState & import("../../corePlugins/useChartExperimentalFeature/useChartExperimentalFeature.types.js").UseChartExperimentalFeaturesState & import("../../corePlugins/useChartDimensions/useChartDimensions.types.js").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types.js").UseChartSeriesState<keyof import("../../../index.js").ChartsSeriesConfig> & import("../../corePlugins/useChartAnimation/useChartAnimation.types.js").UseChartAnimationState & import("../../../index.js").UseChartInteractionListenerState & Partial<import("./useChartKeyboardNavigation.types.js").UseChartKeyboardNavigationState> & {
+  cacheKey: import("../../models/index.js").ChartStateCacheKey;
+} & {
+  cacheKey: import("../../models/index.js").ChartStateCacheKey;
+}, import("../../../index.js").SeriesId | undefined, any[]>;
+export declare const selectorChartsFocusedDataIndex: import("reselect").Selector<import("../../corePlugins/useChartId/useChartId.types.js").UseChartIdState & import("../../corePlugins/useChartExperimentalFeature/useChartExperimentalFeature.types.js").UseChartExperimentalFeaturesState & import("../../corePlugins/useChartDimensions/useChartDimensions.types.js").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types.js").UseChartSeriesState<keyof import("../../../index.js").ChartsSeriesConfig> & import("../../corePlugins/useChartAnimation/useChartAnimation.types.js").UseChartAnimationState & import("../../../index.js").UseChartInteractionListenerState & Partial<import("./useChartKeyboardNavigation.types.js").UseChartKeyboardNavigationState> & {
+  cacheKey: import("../../models/index.js").ChartStateCacheKey;
+} & {
+  cacheKey: import("../../models/index.js").ChartStateCacheKey;
+}, number | undefined, any[]>;
+export declare const selectorChartsIsKeyboardNavigationEnabled: import("reselect").Selector<import("../../corePlugins/useChartId/useChartId.types.js").UseChartIdState & import("../../corePlugins/useChartExperimentalFeature/useChartExperimentalFeature.types.js").UseChartExperimentalFeaturesState & import("../../corePlugins/useChartDimensions/useChartDimensions.types.js").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types.js").UseChartSeriesState<keyof import("../../../index.js").ChartsSeriesConfig> & import("../../corePlugins/useChartAnimation/useChartAnimation.types.js").UseChartAnimationState & import("../../../index.js").UseChartInteractionListenerState & Partial<import("./useChartKeyboardNavigation.types.js").UseChartKeyboardNavigationState> & {
+  cacheKey: import("../../models/index.js").ChartStateCacheKey;
+} & {
+  cacheKey: import("../../models/index.js").ChartStateCacheKey;
+}, boolean, any[]>;

package/esm/internals/plugins/featurePlugins/useChartKeyboardNavigation/useChartKeyboardNavigation.selectors.js

@@ -0,0 +1,7 @@
+import { createSelector } from "../../utils/selectors.js";
+const selectKeyboardNavigation = state => state.keyboardNavigation;
+export const selectorChartsHasFocusedItem = createSelector([selectKeyboardNavigation], keyboardNavigationState => keyboardNavigationState?.item != null);
+export const selectorChartsFocusedSeriesType = createSelector([selectKeyboardNavigation], keyboardNavigationState => keyboardNavigationState?.item?.type);
+export const selectorChartsFocusedSeriesId = createSelector([selectKeyboardNavigation], keyboardNavigationState => keyboardNavigationState?.item?.seriesId);
+export const selectorChartsFocusedDataIndex = createSelector([selectKeyboardNavigation], keyboardNavigationState => keyboardNavigationState?.item?.dataIndex);
+export const selectorChartsIsKeyboardNavigationEnabled = createSelector([selectKeyboardNavigation], keyboardNavigationState => !!keyboardNavigationState?.enableKeyboardNavigation);

package/esm/internals/plugins/featurePlugins/useChartKeyboardNavigation/useChartKeyboardNavigation.types.d.ts

@@ -0,0 +1,34 @@
+import { ChartPluginSignature } from "../../models/index.js";
+import { ChartSeriesType } from "../../../../models/seriesType/config.js";
+import { SeriesId } from "../../../../models/seriesType/common.js";
+export interface UseChartKeyboardNavigationInstance {}
+type SeriesItemIdentifier = {
+  /**
+   * The type of the series
+   */
+  type: ChartSeriesType;
+  /**
+   * The id of the series with focus.
+   */
+  seriesId: SeriesId;
+  /**
+   * The index of the data point with focus.
+   */
+  dataIndex: number;
+};
+export interface UseChartKeyboardNavigationState {
+  keyboardNavigation: {
+    item: null | SeriesItemIdentifier;
+    enableKeyboardNavigation: boolean;
+  };
+}
+type UseChartKeyboardNavigationParameters = {
+  enableKeyboardNavigation?: boolean;
+};
+export type UseChartKeyboardNavigationSignature = ChartPluginSignature<{
+  params: UseChartKeyboardNavigationParameters;
+  defaultizedParams: UseChartKeyboardNavigationParameters;
+  instance: UseChartKeyboardNavigationInstance;
+  state: UseChartKeyboardNavigationState;
+}>;
+export {};

package/esm/internals/plugins/featurePlugins/useChartKeyboardNavigation/useChartKeyboardNavigation.types.js

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

package/esm/internals/plugins/featurePlugins/useChartPolarAxis/useChartPolarAxis.js

@@ -12,6 +12,7 @@ import { getSVGPoint } from "../../../getSVGPoint.js";
 import { generatePolar2svg, generateSvg2polar, generateSvg2rotation } from "./coordinateTransformation.js";
 import { getAxisIndex } from "./getAxisIndex.js";
 import { selectorChartSeriesProcessed } from "../../corePlugins/useChartSeries/index.js";
+import { checkHasInteractionPlugin } from "../useChartInteraction/checkHasInteractionPlugin.js";
 export const useChartPolarAxis = ({
   params,
   store,
@@ -78,9 +79,10 @@ export const useChartPolarAxis = ({
   const mousePosition = React.useRef({
     isInChart: false
   });
+  const hasInteractionPlugin = checkHasInteractionPlugin(instance);
   React.useEffect(() => {
     const element = svgRef.current;
-    if (!isInteractionEnabled || element === null || params.disableAxisListener) {
+    if (!isInteractionEnabled || !hasInteractionPlugin || element === null || params.disableAxisListener) {
       return () => {};
     }
 
@@ -94,13 +96,13 @@ export const useChartPolarAxis = ({
     const panEndHandler = instance.addInteractionListener('panEnd', event => {
       if (!event.detail.activeGestures.move) {
         mousePosition.current.isInChart = false;
-        instance.cleanInteraction();
+        instance.cleanInteraction?.();
       }
     });
     const pressEndHandler = instance.addInteractionListener('quickPressEnd', event => {
       if (!event.detail.activeGestures.move && !event.detail.activeGestures.pan) {
         mousePosition.current.isInChart = false;
-        instance.cleanInteraction();
+        instance.cleanInteraction?.();
       }
     });
     const gestureHandler = event => {
@@ -112,12 +114,12 @@ export const useChartPolarAxis = ({
         const svgRect = element.getBoundingClientRect();
         if (srcEvent.clientX < svgRect.left || srcEvent.clientX > svgRect.right || srcEvent.clientY < svgRect.top || srcEvent.clientY > svgRect.bottom) {
           mousePosition.current.isInChart = false;
-          instance.cleanInteraction();
+          instance.cleanInteraction?.();
           return;
         }
         const svgPoint = getSVGPoint(element, srcEvent);
         mousePosition.current.isInChart = true;
-        instance.setPointerCoordinate(svgPoint);
+        instance.setPointerCoordinate?.(svgPoint);
         return;
       }
 
@@ -128,7 +130,7 @@ export const useChartPolarAxis = ({
       // Test if it's in the drawing area
       if (!instance.isPointInside(svgPoint.x, svgPoint.y, event.detail.target)) {
         if (mousePosition.current.isInChart) {
-          instance?.cleanInteraction();
+          instance.cleanInteraction?.();
           mousePosition.current.isInChart = false;
         }
         return;
@@ -139,7 +141,7 @@ export const useChartPolarAxis = ({
       const maxRadius = radiusAxisWithScale[usedRadiusAxisId].scale.range()[1];
       if (radiusSquare > maxRadius ** 2) {
         if (mousePosition.current.isInChart) {
-          instance?.cleanInteraction();
+          instance.cleanInteraction?.();
           mousePosition.current.isInChart = false;
         }
         return;
@@ -158,7 +160,7 @@ export const useChartPolarAxis = ({
       pressHandler.cleanup();
       pressEndHandler.cleanup();
     };
-  }, [svgRef, store, center, radiusAxisWithScale, usedRadiusAxisId, rotationAxisWithScale, usedRotationAxisId, instance, params.disableAxisListener, isInteractionEnabled, svg2rotation]);
+  }, [svgRef, store, center, radiusAxisWithScale, usedRadiusAxisId, rotationAxisWithScale, usedRotationAxisId, instance, params.disableAxisListener, isInteractionEnabled, svg2rotation, hasInteractionPlugin]);
   React.useEffect(() => {
     const element = svgRef.current;
     const onAxisClick = params.onAxisClick;

package/esm/internals/plugins/featurePlugins/useChartPolarAxis/useChartPolarAxis.types.d.ts

@@ -69,5 +69,6 @@ export type UseChartPolarAxisSignature<SeriesType extends ChartSeriesType = Char
   defaultizedParams: UseChartPolarAxisDefaultizedParameters;
   state: UseChartPolarAxisState;
   instance: UseChartPolarAxisInstance;
-  dependencies: [UseChartInteractionSignature, UseChartSeriesSignature<SeriesType>];
+  dependencies: [UseChartSeriesSignature<SeriesType>];
+  optionalDependencies: [UseChartInteractionSignature];
 }>;

package/esm/internals/plugins/models/seriesConfig/getSeriesWithDefaultValues.types.d.ts

@@ -1,3 +1,3 @@
 import type { ChartSeries, ChartSeriesType } from "../../../../models/seriesType/config.js";
 import type { AllSeriesType } from "../../../../models/seriesType/index.js";
-export type GetSeriesWithDefaultValues<T extends ChartSeriesType> = (series: AllSeriesType<T>, seriesIndex: number, colors: string[]) => ChartSeries<T>;
+export type GetSeriesWithDefaultValues<T extends ChartSeriesType> = (series: AllSeriesType<T>, seriesIndex: number, colors: readonly string[]) => ChartSeries<T>;

package/esm/internals/scaleGuards.d.ts

@@ -1,4 +1,11 @@
+import type { ScaleBand } from '@mui/x-charts-vendor/d3-scale';
 import { D3OrdinalScale, D3Scale } from "../models/axis.js";
 export declare function isOrdinalScale<T extends {
   toString(): string;
+}>(scale: D3Scale<T>): scale is D3OrdinalScale<T>;
+export declare function isBandScale<T extends {
+  toString(): string;
+}>(scale: D3Scale<T>): scale is ScaleBand<T>;
+export declare function isPointScale<T extends {
+  toString(): string;
 }>(scale: D3Scale<T>): scale is D3OrdinalScale<T>;

package/esm/internals/scaleGuards.js

@@ -1,3 +1,9 @@
 export function isOrdinalScale(scale) {
   return scale.bandwidth !== undefined;
+}
+export function isBandScale(scale) {
+  return isOrdinalScale(scale) && scale.paddingOuter !== undefined;
+}
+export function isPointScale(scale) {
+  return isOrdinalScale(scale) && !('paddingOuter' in scale);
 }