@mui/x-charts 9.14.0 → 9.16.0

package/internals/commonNextFocusItem.d.ts

@@ -44,6 +44,24 @@ allowCycles?: boolean,
  * If true (default), series max index is defined by the current series length and not all series.
  */
 useCurrentSeriesMaxLength?: boolean): (currentItem: WorkingItem | null, state: StateParameters<InSeriesType>) => ReturnedItem<OutSeriesType>;
+export declare function createGetFirstIndexFocusedItem<InSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'>, OutSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'> = InSeriesType>(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes: Set<OutSeriesType>,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength?: boolean): (currentItem: WorkingItem | null, state: StateParameters<InSeriesType>) => ReturnedItem<OutSeriesType>;
+export declare function createGetLastIndexFocusedItem<InSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'>, OutSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'> = InSeriesType>(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes: Set<OutSeriesType>,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength?: boolean): (currentItem: WorkingItem | null, state: StateParameters<InSeriesType>) => ReturnedItem<OutSeriesType>;
 export declare function createGetNextSeriesFocusedItem<InSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'>, OutSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'> = InSeriesType>(
 /**
  * The set of series types compatible with this navigation action.
@@ -54,4 +72,32 @@ export declare function createGetPreviousSeriesFocusedItem<InSeriesType extends
  * The set of series types compatible with this navigation action.
  */
 compatibleSeriesTypes: Set<OutSeriesType>): (currentItem: WorkingItem | null, state: StateParameters<InSeriesType>) => ReturnedItem<OutSeriesType>;
+export declare function createGetFirstSeriesFirstIndexFocusedItem<InSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'>, OutSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'> = InSeriesType>(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes: Set<OutSeriesType>,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength?: boolean): (_currentItem: WorkingItem | null, state: StateParameters<InSeriesType>) => ReturnedItem<OutSeriesType>;
+export declare function createGetLastSeriesLastIndexFocusedItem<InSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'>, OutSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'> = InSeriesType>(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes: Set<OutSeriesType>,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength?: boolean): (_currentItem: WorkingItem | null, state: StateParameters<InSeriesType>) => ReturnedItem<OutSeriesType>;
+export declare function createGetFirstSeriesFocusedItem<InSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'>, OutSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'> = InSeriesType>(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes: Set<OutSeriesType>): (currentItem: WorkingItem | null, state: StateParameters<InSeriesType>) => ReturnedItem<OutSeriesType>;
+export declare function createGetLastSeriesFocusedItem<InSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'>, OutSeriesType extends Exclude<ChartSeriesType, 'sankey' | 'heatmap'> = InSeriesType>(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes: Set<OutSeriesType>): (currentItem: WorkingItem | null, state: StateParameters<InSeriesType>) => ReturnedItem<OutSeriesType>;
 export {};

package/internals/commonNextFocusItem.js

@@ -3,11 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.createGetFirstIndexFocusedItem = createGetFirstIndexFocusedItem;
+exports.createGetFirstSeriesFirstIndexFocusedItem = createGetFirstSeriesFirstIndexFocusedItem;
+exports.createGetFirstSeriesFocusedItem = createGetFirstSeriesFocusedItem;
+exports.createGetLastIndexFocusedItem = createGetLastIndexFocusedItem;
+exports.createGetLastSeriesFocusedItem = createGetLastSeriesFocusedItem;
+exports.createGetLastSeriesLastIndexFocusedItem = createGetLastSeriesLastIndexFocusedItem;
 exports.createGetNextIndexFocusedItem = createGetNextIndexFocusedItem;
 exports.createGetNextSeriesFocusedItem = createGetNextSeriesFocusedItem;
 exports.createGetPreviousIndexFocusedItem = createGetPreviousIndexFocusedItem;
 exports.createGetPreviousSeriesFocusedItem = createGetPreviousSeriesFocusedItem;
 var _getPreviousNonEmptySeries = require("./plugins/featurePlugins/useChartKeyboardNavigation/utils/getPreviousNonEmptySeries");
+var _getNonEmptySeriesArray = require("./plugins/featurePlugins/useChartKeyboardNavigation/utils/getNonEmptySeriesArray");
 var _getMaxSeriesLength = require("./plugins/featurePlugins/useChartKeyboardNavigation/utils/getMaxSeriesLength");
 var _getNextNonEmptySeries = require("./plugins/featurePlugins/useChartKeyboardNavigation/utils/getNextNonEmptySeries");
 var _findVisibleDataIndex = require("./plugins/featurePlugins/useChartKeyboardNavigation/utils/findVisibleDataIndex");
@@ -125,6 +132,88 @@ useCurrentSeriesMaxLength = true) {
     };
   };
 }
+function createGetFirstIndexFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength = true) {
+  return function getFirstIndexFocusedItem(currentItem, state) {
+    const processedSeries = (0, _useChartSeries.selectorChartSeriesProcessed)(state);
+    let seriesId = currentItem?.seriesId;
+    let type = currentItem?.type;
+    if (!type || seriesId == null || !(0, _seriesHasData.seriesHasData)(processedSeries, type, seriesId) || isSeriesHidden(processedSeries, type, seriesId)) {
+      const nextSeries = (0, _getNextNonEmptySeries.getNextNonEmptySeries)(processedSeries, compatibleSeriesTypes, type, seriesId);
+      if (nextSeries === null) {
+        return null;
+      }
+      type = nextSeries.type;
+      seriesId = nextSeries.seriesId;
+    }
+    const maxLength = useCurrentSeriesMaxLength ? processedSeries[type]?.series[seriesId]?.data.length ?? 0 : (0, _getMaxSeriesLength.getMaxSeriesLength)(processedSeries, compatibleSeriesTypes);
+    const visibleDataIndex = (0, _findVisibleDataIndex.findVisibleDataIndex)({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex: 0,
+      dataLength: maxLength,
+      direction: 1,
+      allowCycles: false
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type: type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
+}
+function createGetLastIndexFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength = true) {
+  return function getLastIndexFocusedItem(currentItem, state) {
+    const processedSeries = (0, _useChartSeries.selectorChartSeriesProcessed)(state);
+    let seriesId = currentItem?.seriesId;
+    let type = currentItem?.type;
+    if (!type || seriesId == null || !(0, _seriesHasData.seriesHasData)(processedSeries, type, seriesId) || isSeriesHidden(processedSeries, type, seriesId)) {
+      const previousSeries = (0, _getPreviousNonEmptySeries.getPreviousNonEmptySeries)(processedSeries, compatibleSeriesTypes, type, seriesId);
+      if (previousSeries === null) {
+        return null;
+      }
+      type = previousSeries.type;
+      seriesId = previousSeries.seriesId;
+    }
+    const maxLength = useCurrentSeriesMaxLength ? processedSeries[type]?.series[seriesId]?.data.length ?? 0 : (0, _getMaxSeriesLength.getMaxSeriesLength)(processedSeries, compatibleSeriesTypes);
+    const visibleDataIndex = (0, _findVisibleDataIndex.findVisibleDataIndex)({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex: maxLength - 1,
+      dataLength: maxLength,
+      direction: -1,
+      allowCycles: false
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type: type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
+}
 function createGetNextSeriesFocusedItem(
 /**
  * The set of series types compatible with this navigation action.
@@ -196,4 +285,156 @@ compatibleSeriesTypes) {
       dataIndex: visibleDataIndex
     };
   };
+}
+function createGetFirstSeriesFirstIndexFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength = true) {
+  return function getFirstSeriesFirstIndexFocusedItem(_currentItem, state) {
+    const processedSeries = (0, _useChartSeries.selectorChartSeriesProcessed)(state);
+    const firstSeries = (0, _getNonEmptySeriesArray.getNonEmptySeriesArray)(processedSeries, compatibleSeriesTypes)[0];
+    if (firstSeries === undefined) {
+      return null;
+    }
+    const {
+      type,
+      seriesId
+    } = firstSeries;
+    const maxLength = useCurrentSeriesMaxLength ? processedSeries[type]?.series[seriesId]?.data.length ?? 0 : (0, _getMaxSeriesLength.getMaxSeriesLength)(processedSeries, compatibleSeriesTypes);
+    const visibleDataIndex = (0, _findVisibleDataIndex.findVisibleDataIndex)({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex: 0,
+      dataLength: maxLength,
+      direction: 1,
+      allowCycles: false
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
+}
+function createGetLastSeriesLastIndexFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength = true) {
+  return function getLastSeriesLastIndexFocusedItem(_currentItem, state) {
+    const processedSeries = (0, _useChartSeries.selectorChartSeriesProcessed)(state);
+    const nonEmptySeries = (0, _getNonEmptySeriesArray.getNonEmptySeriesArray)(processedSeries, compatibleSeriesTypes);
+    const lastSeries = nonEmptySeries[nonEmptySeries.length - 1];
+    if (lastSeries === undefined) {
+      return null;
+    }
+    const {
+      type,
+      seriesId
+    } = lastSeries;
+    const maxLength = useCurrentSeriesMaxLength ? processedSeries[type]?.series[seriesId]?.data.length ?? 0 : (0, _getMaxSeriesLength.getMaxSeriesLength)(processedSeries, compatibleSeriesTypes);
+    const visibleDataIndex = (0, _findVisibleDataIndex.findVisibleDataIndex)({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex: maxLength - 1,
+      dataLength: maxLength,
+      direction: -1,
+      allowCycles: false
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
+}
+function createGetFirstSeriesFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes) {
+  return function getFirstSeriesFocusedItem(currentItem, state) {
+    const processedSeries = (0, _useChartSeries.selectorChartSeriesProcessed)(state);
+    const firstSeries = (0, _getNonEmptySeriesArray.getNonEmptySeriesArray)(processedSeries, compatibleSeriesTypes)[0];
+    if (firstSeries === undefined) {
+      return null;
+    }
+    const {
+      type,
+      seriesId
+    } = firstSeries;
+    const data = processedSeries[type].series[seriesId].data;
+    const startIndex = currentItem?.dataIndex == null ? 0 : Math.min(currentItem.dataIndex, data.length - 1);
+    const visibleDataIndex = (0, _findVisibleDataIndex.findVisibleDataIndex)({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex,
+      dataLength: data.length,
+      direction: 1,
+      allowCycles: true
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
+}
+function createGetLastSeriesFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes) {
+  return function getLastSeriesFocusedItem(currentItem, state) {
+    const processedSeries = (0, _useChartSeries.selectorChartSeriesProcessed)(state);
+    const nonEmptySeries = (0, _getNonEmptySeriesArray.getNonEmptySeriesArray)(processedSeries, compatibleSeriesTypes);
+    const lastSeries = nonEmptySeries[nonEmptySeries.length - 1];
+    if (lastSeries === undefined) {
+      return null;
+    }
+    const {
+      type,
+      seriesId
+    } = lastSeries;
+    const data = processedSeries[type].series[seriesId].data;
+    const startIndex = currentItem?.dataIndex == null ? data.length - 1 : Math.min(currentItem.dataIndex, data.length - 1);
+    const visibleDataIndex = (0, _findVisibleDataIndex.findVisibleDataIndex)({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex,
+      dataLength: data.length,
+      direction: -1,
+      allowCycles: true
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
 }

package/internals/commonNextFocusItem.mjs

@@ -1,4 +1,5 @@
 import { getPreviousNonEmptySeries } from "./plugins/featurePlugins/useChartKeyboardNavigation/utils/getPreviousNonEmptySeries.mjs";
+import { getNonEmptySeriesArray } from "./plugins/featurePlugins/useChartKeyboardNavigation/utils/getNonEmptySeriesArray.mjs";
 import { getMaxSeriesLength } from "./plugins/featurePlugins/useChartKeyboardNavigation/utils/getMaxSeriesLength.mjs";
 import { getNextNonEmptySeries } from "./plugins/featurePlugins/useChartKeyboardNavigation/utils/getNextNonEmptySeries.mjs";
 import { findVisibleDataIndex } from "./plugins/featurePlugins/useChartKeyboardNavigation/utils/findVisibleDataIndex.mjs";
@@ -117,6 +118,88 @@ useCurrentSeriesMaxLength = true) {
     };
   };
 }
+export function createGetFirstIndexFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength = true) {
+  return function getFirstIndexFocusedItem(currentItem, state) {
+    const processedSeries = selectorChartSeriesProcessed(state);
+    let seriesId = currentItem?.seriesId;
+    let type = currentItem?.type;
+    if (!type || seriesId == null || !seriesHasData(processedSeries, type, seriesId) || isSeriesHidden(processedSeries, type, seriesId)) {
+      const nextSeries = getNextNonEmptySeries(processedSeries, compatibleSeriesTypes, type, seriesId);
+      if (nextSeries === null) {
+        return null;
+      }
+      type = nextSeries.type;
+      seriesId = nextSeries.seriesId;
+    }
+    const maxLength = useCurrentSeriesMaxLength ? processedSeries[type]?.series[seriesId]?.data.length ?? 0 : getMaxSeriesLength(processedSeries, compatibleSeriesTypes);
+    const visibleDataIndex = findVisibleDataIndex({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex: 0,
+      dataLength: maxLength,
+      direction: 1,
+      allowCycles: false
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type: type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
+}
+export function createGetLastIndexFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength = true) {
+  return function getLastIndexFocusedItem(currentItem, state) {
+    const processedSeries = selectorChartSeriesProcessed(state);
+    let seriesId = currentItem?.seriesId;
+    let type = currentItem?.type;
+    if (!type || seriesId == null || !seriesHasData(processedSeries, type, seriesId) || isSeriesHidden(processedSeries, type, seriesId)) {
+      const previousSeries = getPreviousNonEmptySeries(processedSeries, compatibleSeriesTypes, type, seriesId);
+      if (previousSeries === null) {
+        return null;
+      }
+      type = previousSeries.type;
+      seriesId = previousSeries.seriesId;
+    }
+    const maxLength = useCurrentSeriesMaxLength ? processedSeries[type]?.series[seriesId]?.data.length ?? 0 : getMaxSeriesLength(processedSeries, compatibleSeriesTypes);
+    const visibleDataIndex = findVisibleDataIndex({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex: maxLength - 1,
+      dataLength: maxLength,
+      direction: -1,
+      allowCycles: false
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type: type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
+}
 export function createGetNextSeriesFocusedItem(
 /**
  * The set of series types compatible with this navigation action.
@@ -188,4 +271,156 @@ compatibleSeriesTypes) {
       dataIndex: visibleDataIndex
     };
   };
+}
+export function createGetFirstSeriesFirstIndexFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength = true) {
+  return function getFirstSeriesFirstIndexFocusedItem(_currentItem, state) {
+    const processedSeries = selectorChartSeriesProcessed(state);
+    const firstSeries = getNonEmptySeriesArray(processedSeries, compatibleSeriesTypes)[0];
+    if (firstSeries === undefined) {
+      return null;
+    }
+    const {
+      type,
+      seriesId
+    } = firstSeries;
+    const maxLength = useCurrentSeriesMaxLength ? processedSeries[type]?.series[seriesId]?.data.length ?? 0 : getMaxSeriesLength(processedSeries, compatibleSeriesTypes);
+    const visibleDataIndex = findVisibleDataIndex({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex: 0,
+      dataLength: maxLength,
+      direction: 1,
+      allowCycles: false
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
+}
+export function createGetLastSeriesLastIndexFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes,
+/**
+ * If true, series max index is defined by the current series length and not all series.
+ */
+useCurrentSeriesMaxLength = true) {
+  return function getLastSeriesLastIndexFocusedItem(_currentItem, state) {
+    const processedSeries = selectorChartSeriesProcessed(state);
+    const nonEmptySeries = getNonEmptySeriesArray(processedSeries, compatibleSeriesTypes);
+    const lastSeries = nonEmptySeries[nonEmptySeries.length - 1];
+    if (lastSeries === undefined) {
+      return null;
+    }
+    const {
+      type,
+      seriesId
+    } = lastSeries;
+    const maxLength = useCurrentSeriesMaxLength ? processedSeries[type]?.series[seriesId]?.data.length ?? 0 : getMaxSeriesLength(processedSeries, compatibleSeriesTypes);
+    const visibleDataIndex = findVisibleDataIndex({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex: maxLength - 1,
+      dataLength: maxLength,
+      direction: -1,
+      allowCycles: false
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
+}
+export function createGetFirstSeriesFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes) {
+  return function getFirstSeriesFocusedItem(currentItem, state) {
+    const processedSeries = selectorChartSeriesProcessed(state);
+    const firstSeries = getNonEmptySeriesArray(processedSeries, compatibleSeriesTypes)[0];
+    if (firstSeries === undefined) {
+      return null;
+    }
+    const {
+      type,
+      seriesId
+    } = firstSeries;
+    const data = processedSeries[type].series[seriesId].data;
+    const startIndex = currentItem?.dataIndex == null ? 0 : Math.min(currentItem.dataIndex, data.length - 1);
+    const visibleDataIndex = findVisibleDataIndex({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex,
+      dataLength: data.length,
+      direction: 1,
+      allowCycles: true
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
+}
+export function createGetLastSeriesFocusedItem(
+/**
+ * The set of series types compatible with this navigation action.
+ */
+compatibleSeriesTypes) {
+  return function getLastSeriesFocusedItem(currentItem, state) {
+    const processedSeries = selectorChartSeriesProcessed(state);
+    const nonEmptySeries = getNonEmptySeriesArray(processedSeries, compatibleSeriesTypes);
+    const lastSeries = nonEmptySeries[nonEmptySeries.length - 1];
+    if (lastSeries === undefined) {
+      return null;
+    }
+    const {
+      type,
+      seriesId
+    } = lastSeries;
+    const data = processedSeries[type].series[seriesId].data;
+    const startIndex = currentItem?.dataIndex == null ? data.length - 1 : Math.min(currentItem.dataIndex, data.length - 1);
+    const visibleDataIndex = findVisibleDataIndex({
+      processedSeries,
+      type,
+      seriesId,
+      startIndex,
+      dataLength: data.length,
+      direction: -1,
+      allowCycles: true
+    });
+    if (visibleDataIndex === null) {
+      return null;
+    }
+    return {
+      type,
+      seriesId,
+      dataIndex: visibleDataIndex
+    };
+  };
 }

package/internals/components/AxisSharedComponents.mjs

@@ -1,4 +1,4 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
+import _extends from "@babel/runtime/helpers/extends";
 import { styled } from '@mui/material/styles';
 import { axisClasses } from "../../ChartsAxis/axisClasses.mjs";
 export const AxisRoot = styled('g', {

package/internals/components/ChartsAxesGradients/ChartsContinuousGradientObjectBound.mjs

@@ -1,4 +1,4 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
+import _extends from "@babel/runtime/helpers/extends";
 import { interpolateDate, interpolateNumber } from '@mui/x-charts-vendor/d3-interpolate';
 import { jsx as _jsx } from "react/jsx-runtime";
 const PX_PRECISION = 10;

package/internals/consumeSlots.mjs

@@ -1,7 +1,7 @@
 'use client';
 
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
 const _excluded = ["slots", "slotProps"],
   _excluded2 = ["ownerState"];
 import { useTheme, useThemeProps } from '@mui/material/styles';

package/internals/consumeThemeProps.js

@@ -56,8 +56,7 @@ var _jsxRuntime = require("react/jsx-runtime");
  * @param {Record<string, any>} options.defaultProps A set of defaults for the component, will be deep merged with the props.
  * @param {Function} options.classesResolver A function that returns the classes for the component. It receives the props, after theme props and defaults have been applied. And the theme object as the second argument.
  * @param InComponent The component to render if the slot is not provided.
- */
-const consumeThemeProps = (name, options, InComponent) => /*#__PURE__*/React.forwardRef(function ConsumeThemeInternal(props, ref) {
+ */const consumeThemeProps = (name, options, InComponent) => /*#__PURE__*/React.forwardRef(function ConsumeThemeInternal(props, ref) {
   const themedProps = (0, _styles.useThemeProps)({
     props,
     // eslint-disable-next-line mui/material-ui-name-matches-component-name

package/internals/consumeThemeProps.mjs

@@ -1,6 +1,6 @@
 'use client';
 
-import _extends from "@babel/runtime/helpers/esm/extends";
+import _extends from "@babel/runtime/helpers/extends";
 import { useTheme, useThemeProps } from '@mui/material/styles';
 import resolveProps from '@mui/utils/resolveProps';
 import * as React from 'react';

package/internals/createCommonKeyboardFocusHandler.js

@@ -19,6 +19,22 @@ function createCommonKeyboardFocusHandler(outSeriesTypes, allowCycles, useCurren
         return (0, _commonNextFocusItem.createGetPreviousSeriesFocusedItem)(outSeriesTypes);
       case 'ArrowUp':
         return (0, _commonNextFocusItem.createGetNextSeriesFocusedItem)(outSeriesTypes);
+      case 'Home':
+        // Ctrl+Home (⌘+Home on macOS) jumps to the first item of the first series.
+        if (event.ctrlKey || event.metaKey) {
+          return (0, _commonNextFocusItem.createGetFirstSeriesFirstIndexFocusedItem)(outSeriesTypes, useCurrentSeriesMaxLength);
+        }
+        return (0, _commonNextFocusItem.createGetFirstIndexFocusedItem)(outSeriesTypes, useCurrentSeriesMaxLength);
+      case 'End':
+        // Ctrl+End (⌘+End on macOS) jumps to the last item of the last series.
+        if (event.ctrlKey || event.metaKey) {
+          return (0, _commonNextFocusItem.createGetLastSeriesLastIndexFocusedItem)(outSeriesTypes, useCurrentSeriesMaxLength);
+        }
+        return (0, _commonNextFocusItem.createGetLastIndexFocusedItem)(outSeriesTypes, useCurrentSeriesMaxLength);
+      case 'PageUp':
+        return (0, _commonNextFocusItem.createGetFirstSeriesFocusedItem)(outSeriesTypes);
+      case 'PageDown':
+        return (0, _commonNextFocusItem.createGetLastSeriesFocusedItem)(outSeriesTypes);
       default:
         return null;
     }

package/internals/createCommonKeyboardFocusHandler.mjs

@@ -1,4 +1,4 @@
-import { createGetNextIndexFocusedItem, createGetPreviousIndexFocusedItem, createGetNextSeriesFocusedItem, createGetPreviousSeriesFocusedItem } from "./commonNextFocusItem.mjs";
+import { createGetNextIndexFocusedItem, createGetPreviousIndexFocusedItem, createGetFirstIndexFocusedItem, createGetLastIndexFocusedItem, createGetNextSeriesFocusedItem, createGetPreviousSeriesFocusedItem, createGetFirstSeriesFirstIndexFocusedItem, createGetLastSeriesLastIndexFocusedItem, createGetFirstSeriesFocusedItem, createGetLastSeriesFocusedItem } from "./commonNextFocusItem.mjs";
 
 /**
  * Create a keyboard focus handler for common use cases where focused item are defined by the series is and data index.
@@ -14,6 +14,22 @@ export function createCommonKeyboardFocusHandler(outSeriesTypes, allowCycles, us
         return createGetPreviousSeriesFocusedItem(outSeriesTypes);
       case 'ArrowUp':
         return createGetNextSeriesFocusedItem(outSeriesTypes);
+      case 'Home':
+        // Ctrl+Home (⌘+Home on macOS) jumps to the first item of the first series.
+        if (event.ctrlKey || event.metaKey) {
+          return createGetFirstSeriesFirstIndexFocusedItem(outSeriesTypes, useCurrentSeriesMaxLength);
+        }
+        return createGetFirstIndexFocusedItem(outSeriesTypes, useCurrentSeriesMaxLength);
+      case 'End':
+        // Ctrl+End (⌘+End on macOS) jumps to the last item of the last series.
+        if (event.ctrlKey || event.metaKey) {
+          return createGetLastSeriesLastIndexFocusedItem(outSeriesTypes, useCurrentSeriesMaxLength);
+        }
+        return createGetLastIndexFocusedItem(outSeriesTypes, useCurrentSeriesMaxLength);
+      case 'PageUp':
+        return createGetFirstSeriesFocusedItem(outSeriesTypes);
+      case 'PageDown':
+        return createGetLastSeriesFocusedItem(outSeriesTypes);
       default:
         return null;
     }

package/internals/defaultizeMargin.mjs

@@ -1,4 +1,4 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
+import _extends from "@babel/runtime/helpers/extends";
 export function defaultizeMargin(input, defaultMargin) {
   if (typeof input === 'number') {
     return {