@mui/x-charts 8.0.0-beta.2 → 8.0.0-beta.3

package/hooks/animation/useAnimatePieArc.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAnimatePieArc = useAnimatePieArc;
+var _d3Shape = require("@mui/x-charts-vendor/d3-shape");
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _d3Interpolate = require("@mui/x-charts-vendor/d3-interpolate");
+var _useAnimate = require("../../internals/animation/useAnimate");
+function pieArcPropsInterpolator(from, to) {
+  const interpolateStartAngle = (0, _d3Interpolate.interpolateNumber)(from.startAngle, to.startAngle);
+  const interpolateEndAngle = (0, _d3Interpolate.interpolateNumber)(from.endAngle, to.endAngle);
+  const interpolateInnerRadius = (0, _d3Interpolate.interpolateNumber)(from.innerRadius, to.innerRadius);
+  const interpolateOuterRadius = (0, _d3Interpolate.interpolateNumber)(from.outerRadius, to.outerRadius);
+  const interpolatePaddingAngle = (0, _d3Interpolate.interpolateNumber)(from.paddingAngle, to.paddingAngle);
+  const interpolateCornerRadius = (0, _d3Interpolate.interpolateNumber)(from.cornerRadius, to.cornerRadius);
+  return t => {
+    return {
+      startAngle: interpolateStartAngle(t),
+      endAngle: interpolateEndAngle(t),
+      innerRadius: interpolateInnerRadius(t),
+      outerRadius: interpolateOuterRadius(t),
+      paddingAngle: interpolatePaddingAngle(t),
+      cornerRadius: interpolateCornerRadius(t)
+    };
+  };
+}
+
+/** Animates a slice of a pie chart by increasing the start and end angles from the middle angle to their final values.
+ * 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. */
+function useAnimatePieArc(props) {
+  const initialProps = {
+    startAngle: (props.startAngle + props.endAngle) / 2,
+    endAngle: (props.startAngle + props.endAngle) / 2,
+    innerRadius: props.innerRadius,
+    outerRadius: props.outerRadius,
+    paddingAngle: props.paddingAngle,
+    cornerRadius: props.cornerRadius
+  };
+  const ref = (0, _useAnimate.useAnimate)({
+    startAngle: props.startAngle,
+    endAngle: props.endAngle,
+    innerRadius: props.innerRadius,
+    outerRadius: props.outerRadius,
+    paddingAngle: props.paddingAngle,
+    cornerRadius: props.cornerRadius
+  }, {
+    createInterpolator: pieArcPropsInterpolator,
+    applyProps(element, animatedProps) {
+      element.setAttribute('d', (0, _d3Shape.arc)().cornerRadius(animatedProps.cornerRadius)({
+        padAngle: animatedProps.paddingAngle,
+        innerRadius: animatedProps.innerRadius,
+        outerRadius: animatedProps.outerRadius,
+        startAngle: animatedProps.startAngle,
+        endAngle: animatedProps.endAngle
+      }).toString());
+      element.setAttribute('visibility', animatedProps.startAngle === animatedProps.endAngle ? 'hidden' : 'visible');
+    },
+    initialProps,
+    skip: props.skipAnimation
+  });
+  const usedProps = props.skipAnimation ? props : initialProps;
+  return {
+    ref: (0, _useForkRef.default)(ref, props.ref),
+    d: (0, _d3Shape.arc)().cornerRadius(usedProps.cornerRadius)({
+      padAngle: usedProps.paddingAngle,
+      innerRadius: usedProps.innerRadius,
+      outerRadius: usedProps.outerRadius,
+      startAngle: usedProps.startAngle,
+      endAngle: usedProps.endAngle
+    }),
+    visibility: usedProps.startAngle === usedProps.endAngle ? 'hidden' : 'visible'
+  };
+}

package/hooks/animation/useAnimatePieArcLabel.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { PieArcLabelProps } from '../../PieChart';
+type UseAnimatePieArcLabelParams = Pick<PieArcLabelProps, 'startAngle' | 'endAngle' | 'cornerRadius' | 'paddingAngle' | 'innerRadius' | 'outerRadius' | 'skipAnimation'> & {
+  ref?: React.Ref<SVGTextElement>;
+};
+type UseAnimatePieArcLabelReturn = {
+  ref: React.Ref<SVGTextElement>;
+  x: number;
+  y: number;
+};
+/** Animates the label of pie slice from its middle point to the centroid of the slice.
+ * 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 useAnimatePieArcLabel(props: UseAnimatePieArcLabelParams): UseAnimatePieArcLabelReturn;
+export {};

package/hooks/animation/useAnimatePieArcLabel.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAnimatePieArcLabel = useAnimatePieArcLabel;
+var _d3Shape = require("@mui/x-charts-vendor/d3-shape");
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _d3Interpolate = require("@mui/x-charts-vendor/d3-interpolate");
+var _useAnimate = require("../../internals/animation/useAnimate");
+function pieArcLabelPropsInterpolator(from, to) {
+  const interpolateStartAngle = (0, _d3Interpolate.interpolateNumber)(from.startAngle, to.startAngle);
+  const interpolateEndAngle = (0, _d3Interpolate.interpolateNumber)(from.endAngle, to.endAngle);
+  const interpolateInnerRadius = (0, _d3Interpolate.interpolateNumber)(from.innerRadius, to.innerRadius);
+  const interpolateOuterRadius = (0, _d3Interpolate.interpolateNumber)(from.outerRadius, to.outerRadius);
+  const interpolatePaddingAngle = (0, _d3Interpolate.interpolateNumber)(from.paddingAngle, to.paddingAngle);
+  const interpolateCornerRadius = (0, _d3Interpolate.interpolateNumber)(from.cornerRadius, to.cornerRadius);
+  return t => {
+    return {
+      startAngle: interpolateStartAngle(t),
+      endAngle: interpolateEndAngle(t),
+      innerRadius: interpolateInnerRadius(t),
+      outerRadius: interpolateOuterRadius(t),
+      paddingAngle: interpolatePaddingAngle(t),
+      cornerRadius: interpolateCornerRadius(t)
+    };
+  };
+}
+
+/** Animates the label of pie slice from its middle point to the centroid of the slice.
+ * 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. */
+function useAnimatePieArcLabel(props) {
+  const initialProps = {
+    startAngle: (props.startAngle + props.endAngle) / 2,
+    endAngle: (props.startAngle + props.endAngle) / 2,
+    innerRadius: props.innerRadius,
+    outerRadius: props.outerRadius,
+    paddingAngle: props.paddingAngle,
+    cornerRadius: props.cornerRadius
+  };
+  const ref = (0, _useAnimate.useAnimate)({
+    startAngle: props.startAngle,
+    endAngle: props.endAngle,
+    innerRadius: props.innerRadius,
+    outerRadius: props.outerRadius,
+    paddingAngle: props.paddingAngle,
+    cornerRadius: props.cornerRadius
+  }, {
+    createInterpolator: pieArcLabelPropsInterpolator,
+    applyProps(element, animatedProps) {
+      const [x, y] = (0, _d3Shape.arc)().cornerRadius(animatedProps.cornerRadius).centroid({
+        padAngle: animatedProps.paddingAngle,
+        startAngle: animatedProps.startAngle,
+        endAngle: animatedProps.endAngle,
+        innerRadius: animatedProps.innerRadius,
+        outerRadius: animatedProps.outerRadius
+      });
+      element.setAttribute('x', x.toString());
+      element.setAttribute('y', y.toString());
+    },
+    initialProps,
+    skip: props.skipAnimation
+  });
+  const usedProps = props.skipAnimation ? props : initialProps;
+  const [x, y] = (0, _d3Shape.arc)().cornerRadius(usedProps.cornerRadius).centroid({
+    padAngle: usedProps.paddingAngle,
+    startAngle: usedProps.startAngle,
+    endAngle: usedProps.endAngle,
+    innerRadius: usedProps.innerRadius,
+    outerRadius: usedProps.outerRadius
+  });
+  return {
+    ref: (0, _useForkRef.default)(ref, props.ref),
+    x,
+    y
+  };
+}

package/hooks/index.d.ts

@@ -13,4 +13,5 @@ export * from "./useLineSeries.js";
 export * from "./useItemHighlighted.js";
 export * from "./useItemHighlightedGetter.js";
 export * from "./useLegend.js";
-export { useChartGradientId, useChartGradientIdObjectBound } from "./useChartGradientId.js";
+export { useChartGradientId, useChartGradientIdObjectBound } from "./useChartGradientId.js";
+export * from "./animation/index.js";

package/hooks/index.js

@@ -199,4 +199,16 @@ Object.keys(_useLegend).forEach(function (key) {
     }
   });
 });
-var _useChartGradientId = require("./useChartGradientId");
+var _useChartGradientId = require("./useChartGradientId");
+var _animation = require("./animation");
+Object.keys(_animation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _animation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _animation[key];
+    }
+  });
+});

package/hooks/useInteractionItemProps.js

@@ -17,7 +17,9 @@ const useInteractionItemProps = (data, skip) => {
   const {
     instance
   } = (0, _ChartProvider.useChartContext)();
+  const interactionActive = React.useRef(false);
   const onPointerEnter = React.useCallback(() => {
+    interactionActive.current = true;
     instance.setItemInteraction({
       type: data.type,
       seriesId: data.seriesId,
@@ -29,6 +31,7 @@ const useInteractionItemProps = (data, skip) => {
     });
   }, [instance, data.type, data.seriesId, data.dataIndex]);
   const onPointerLeave = React.useCallback(() => {
+    interactionActive.current = false;
     instance.removeItemInteraction({
       type: data.type,
       seriesId: data.seriesId,
@@ -36,6 +39,14 @@ const useInteractionItemProps = (data, skip) => {
     });
     instance.clearHighlight();
   }, [instance, data.type, data.seriesId, data.dataIndex]);
+  React.useEffect(() => {
+    return () => {
+      /* Clean up state if this item is unmounted while active. */
+      if (interactionActive.current) {
+        onPointerLeave();
+      }
+    };
+  }, [onPointerLeave]);
   if (skip) {
     return {};
   }

package/index.js

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

package/internals/animation/Transition.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A resumable transition class inspired by d3-transition.
+ * Allows for starting, and stopping and resuming transitions.
+ *
+ * The transition is started automatically.
+ * A transition cannot be restarted after it has finished.
+ * Resuming a transition will continue from the point it was stopped, i.e., easing will continue from the point it was
+ * stopped.
+ */
+export declare class Transition {
+  private readonly duration;
+  private elapsed;
+  private readonly easingFn;
+  private timer;
+  private readonly onTickCallback;
+  /**
+   * Create a new ResumableTransition.
+   * @param duration Duration in milliseconds
+   * @param easingFn The easing function
+   * @param onTick Callback function called on each animation frame with the eased time in range [0, 1].
+   */
+  constructor(duration: number, easingFn: (t: number) => number, onTick: (easedT: number) => void);
+  private get running();
+  private timerCallback;
+  /**
+   * Resume the transition
+   */
+  resume(): this;
+  /**
+   * Stops the transition.
+   */
+  stop(): this;
+  /**
+   * Immediately finishes the transition and calls the tick callback with the final value.
+   */
+  finish(): this;
+}

package/internals/animation/Transition.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Transition = void 0;
+var _d3Timer = require("@mui/x-charts-vendor/d3-timer");
+/**
+ * A resumable transition class inspired by d3-transition.
+ * Allows for starting, and stopping and resuming transitions.
+ *
+ * The transition is started automatically.
+ * A transition cannot be restarted after it has finished.
+ * Resuming a transition will continue from the point it was stopped, i.e., easing will continue from the point it was
+ * stopped.
+ */
+class Transition {
+  /**
+   * Create a new ResumableTransition.
+   * @param duration Duration in milliseconds
+   * @param easingFn The easing function
+   * @param onTick Callback function called on each animation frame with the eased time in range [0, 1].
+   */
+  constructor(duration, easingFn, onTick) {
+    this.duration = void 0;
+    this.elapsed = 0;
+    this.easingFn = void 0;
+    this.timer = null;
+    this.onTickCallback = void 0;
+    this.duration = duration;
+    this.easingFn = easingFn;
+    this.onTickCallback = onTick;
+    this.resume();
+  }
+  get running() {
+    return this.timer !== null;
+  }
+  timerCallback(elapsed) {
+    this.elapsed = Math.min(elapsed, this.duration);
+    const t = this.duration === 0 ? 1 : this.elapsed / this.duration;
+    const easedT = this.easingFn(t);
+
+    // Call the tick callback with the current value
+    this.onTickCallback(easedT);
+    if (this.elapsed >= this.duration) {
+      this.stop();
+    }
+  }
+
+  /**
+   * Resume the transition
+   */
+  resume() {
+    if (this.running || this.elapsed >= this.duration) {
+      return this;
+    }
+
+    /* If we're resuming the transition, then subtract elapsed to continue the easing. */
+    const time = (0, _d3Timer.now)() - this.elapsed;
+    this.timer = (0, _d3Timer.timer)(elapsed => this.timerCallback(elapsed), 0, time);
+    (0, _d3Timer.timerFlush)();
+    return this;
+  }
+
+  /**
+   * Stops the transition.
+   */
+  stop() {
+    if (!this.running) {
+      return this;
+    }
+    if (this.timer) {
+      this.timer.stop();
+      this.timer = null;
+    }
+    return this;
+  }
+
+  /**
+   * Immediately finishes the transition and calls the tick callback with the final value.
+   */
+  finish() {
+    this.stop();
+    (0, _d3Timer.timeout)(() => this.timerCallback(this.duration));
+    (0, _d3Timer.timerFlush)();
+    return this;
+  }
+}
+exports.Transition = Transition;

package/internals/animation/animation.d.ts

@@ -0,0 +1,4 @@
+import BezierEasing from 'bezier-easing';
+export declare const ANIMATION_DURATION_MS = 300;
+export declare const ANIMATION_TIMING_FUNCTION = "cubic-bezier(0.66, 0, 0.34, 1)";
+export declare const ANIMATION_TIMING_FUNCTION_JS: BezierEasing.EasingFunction;

package/internals/animation/animation.js

@@ -0,0 +1,11 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ANIMATION_TIMING_FUNCTION_JS = exports.ANIMATION_TIMING_FUNCTION = exports.ANIMATION_DURATION_MS = void 0;
+var _bezierEasing = _interopRequireDefault(require("bezier-easing"));
+const ANIMATION_DURATION_MS = exports.ANIMATION_DURATION_MS = 300;
+const ANIMATION_TIMING_FUNCTION = exports.ANIMATION_TIMING_FUNCTION = 'cubic-bezier(0.66, 0, 0.34, 1)';
+const ANIMATION_TIMING_FUNCTION_JS = exports.ANIMATION_TIMING_FUNCTION_JS = (0, _bezierEasing.default)(0.66, 0, 0.34, 1);

package/internals/animation/useAnimate.d.ts

@@ -0,0 +1,19 @@
+/** Animates a ref. The animation can be skipped by setting {@link skip} to true.
+ *
+ * - If {@link skip} is false, a transition will be started.
+ * - If {@link skip} is true and no transition is in progress, no transition will be started and {@link applyProps} will
+ *   never be called.
+ * - If {@link skip} becomes true and a transition is in progress, the transition will immediately end and
+ *   {@link applyProps} be called with the final value.
+ * */
+export declare function useAnimate<Props extends {}, Elem extends Element>(props: Props, {
+  createInterpolator,
+  applyProps,
+  skip,
+  initialProps
+}: {
+  createInterpolator: (lastProps: Props, newProps: Props) => (t: number) => Props;
+  applyProps: (element: Elem, props: Props) => void;
+  skip?: boolean;
+  initialProps?: Props;
+}): (element: Elem | null) => void;

package/internals/animation/useAnimate.js

@@ -0,0 +1,80 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAnimate = useAnimate;
+var React = _interopRequireWildcard(require("react"));
+var _useEnhancedEffect = _interopRequireDefault(require("@mui/utils/useEnhancedEffect"));
+var _animation = require("./animation");
+var _Transition = require("./Transition");
+var _shallowEqual = require("../shallowEqual");
+/** Animates a ref. The animation can be skipped by setting {@link skip} to true.
+ *
+ * - If {@link skip} is false, a transition will be started.
+ * - If {@link skip} is true and no transition is in progress, no transition will be started and {@link applyProps} will
+ *   never be called.
+ * - If {@link skip} becomes true and a transition is in progress, the transition will immediately end and
+ *   {@link applyProps} be called with the final value.
+ * */
+function useAnimate(props, {
+  createInterpolator,
+  applyProps,
+  skip,
+  initialProps = props
+}) {
+  const lastInterpolatedPropsRef = React.useRef(initialProps);
+  const transitionRef = React.useRef(null);
+  const elementRef = React.useRef(null);
+  const lastPropsRef = React.useRef(props);
+  (0, _useEnhancedEffect.default)(() => {
+    lastPropsRef.current = props;
+  }, [props]);
+  (0, _useEnhancedEffect.default)(() => {
+    if (skip) {
+      transitionRef.current?.finish();
+      transitionRef.current = null;
+      elementRef.current = null;
+      lastInterpolatedPropsRef.current = props;
+    }
+  }, [props, skip]);
+  const animate = React.useCallback(element => {
+    const lastInterpolatedProps = lastInterpolatedPropsRef.current;
+    const interpolate = createInterpolator(lastInterpolatedProps, props);
+    transitionRef.current = new _Transition.Transition(_animation.ANIMATION_DURATION_MS, _animation.ANIMATION_TIMING_FUNCTION_JS, t => {
+      const interpolatedProps = interpolate(t);
+      lastInterpolatedPropsRef.current = interpolatedProps;
+      applyProps(element, interpolatedProps);
+    });
+  }, [applyProps, createInterpolator, props]);
+  const setRef = React.useCallback(element => {
+    if (element === null) {
+      transitionRef.current?.stop();
+      return;
+    }
+    const lastElement = elementRef.current;
+    if (lastElement === element) {
+      // If it's the same element and same props, resume the transition.
+      if ((0, _shallowEqual.shallowEqual)(lastPropsRef.current, props)) {
+        transitionRef.current?.resume();
+        return;
+      }
+
+      // If props aren't the same, stop the transition and start a new animation.
+      transitionRef.current?.stop();
+    }
+
+    // If it's a different element, stop the transition of the last element and start a new animation.
+    if (lastElement) {
+      transitionRef.current?.stop();
+    }
+    elementRef.current = element;
+    if (transitionRef.current || !skip) {
+      animate(element);
+    }
+  }, [animate, props, skip]);
+  return setRef;
+}

package/internals/plugins/featurePlugins/useChartCartesianAxis/computeAxisValue.d.ts

@@ -6,7 +6,7 @@ import { ChartSeriesConfig } from "../../models/seriesConfig/index.js";
 import { DefaultizedAxisConfig, DefaultizedZoomOptions } from "./useChartCartesianAxis.types.js";
 import { ProcessedSeries } from "../../corePlugins/useChartSeries/useChartSeries.types.js";
 import { GetZoomAxisFilters, ZoomData } from "./zoom.types.js";
-type ComputeResult<T extends ChartsAxisProps> = {
+export type ComputeResult<T extends ChartsAxisProps> = {
   axis: DefaultizedAxisConfig<T>;
   axisIds: string[];
 };

package/internals/plugins/featurePlugins/useChartCartesianAxis/computeAxisValue.js

@@ -13,6 +13,7 @@ var _useTicks = require("../../../../hooks/useTicks");
 var _getScale = require("../../../getScale");
 var _zoom = require("./zoom");
 var _getAxisExtremum = require("./getAxisExtremum");
+var _getAxisTriggerTooltip = require("./getAxisTriggerTooltip");
 function getRange(drawingArea, axisDirection,
 // | 'rotation' | 'radius',
 axis) {
@@ -44,6 +45,7 @@ function computeAxisValue({
       axisIds: []
     };
   }
+  const axisIdsTriggeringTooltip = (0, _getAxisTriggerTooltip.getAxisTriggerTooltip)(axisDirection, seriesConfig, formattedSeries, allAxis[0].id);
   const completeAxis = {};
   allAxis.forEach((eachAxis, axisIndex) => {
     const axis = eachAxis;
@@ -53,6 +55,7 @@ function computeAxisValue({
     const range = getRange(drawingArea, axisDirection, axis);
     const [minData, maxData] = (0, _getAxisExtremum.getAxisExtremum)(axis, axisDirection, seriesConfig, axisIndex, formattedSeries, zoom === undefined && !zoomOption ? getFilters : undefined // Do not apply filtering if zoom is already defined.
     );
+    const triggerTooltip = !axis.ignoreTooltip && axisIdsTriggeringTooltip.has(axis.id);
     const data = axis.data ?? [];
     if ((0, _axis.isBandScaleConfig)(axis)) {
       const categoryGapRatio = axis.categoryGapRatio ?? DEFAULT_CATEGORY_GAP_RATIO;
@@ -64,7 +67,8 @@ function computeAxisValue({
         offset: 0,
         height: 0,
         categoryGapRatio,
-        barGapRatio
+        barGapRatio,
+        triggerTooltip
       }, axis, {
         data,
         scale: (0, _d3Scale.scaleBand)(axis.data, zoomedRange).paddingInner(categoryGapRatio).paddingOuter(categoryGapRatio / 2),
@@ -83,7 +87,8 @@ function computeAxisValue({
       const zoomedRange = (0, _zoom.zoomScaleRange)(scaleRange, zoomRange);
       completeAxis[axis.id] = (0, _extends2.default)({
         offset: 0,
-        height: 0
+        height: 0,
+        triggerTooltip
       }, axis, {
         data,
         scale: (0, _d3Scale.scalePoint)(axis.data, zoomedRange),
@@ -124,7 +129,8 @@ function computeAxisValue({
     const domain = [axis.min ?? minDomain, axis.max ?? maxDomain];
     completeAxis[axis.id] = (0, _extends2.default)({
       offset: 0,
-      height: 0
+      height: 0,
+      triggerTooltip
     }, axis, {
       data,
       scaleType: scaleType,

package/internals/plugins/featurePlugins/useChartCartesianAxis/getAxisTriggerTooltip.d.ts

@@ -0,0 +1,5 @@
+import { CartesianChartSeriesType } from "../../../../models/seriesType/config.js";
+import { ChartSeriesConfig } from "../../models/seriesConfig/index.js";
+import { ProcessedSeries } from "../../corePlugins/useChartSeries/useChartSeries.types.js";
+import { AxisId } from "../../../../models/axis.js";
+export declare const getAxisTriggerTooltip: <TSeriesType extends CartesianChartSeriesType>(axisDirection: "x" | "y", seriesConfig: ChartSeriesConfig<TSeriesType>, formattedSeries: ProcessedSeries<TSeriesType>, defaultAxisId: AxisId) => Set<AxisId>;

package/internals/plugins/featurePlugins/useChartCartesianAxis/getAxisTriggerTooltip.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAxisTriggerTooltip = void 0;
+var _isCartesian = require("../../../isCartesian");
+const getAxisTriggerTooltip = (axisDirection, seriesConfig, formattedSeries, defaultAxisId) => {
+  const tooltipAxesIds = new Set();
+  const chartTypes = Object.keys(seriesConfig).filter(_isCartesian.isCartesianSeriesType);
+  chartTypes.forEach(chartType => {
+    const series = formattedSeries[chartType]?.series ?? {};
+    const tooltipAxes = seriesConfig[chartType].axisTooltipGetter?.(series);
+    if (tooltipAxes === undefined) {
+      return;
+    }
+    tooltipAxes.forEach(({
+      axisId,
+      direction
+    }) => {
+      if (direction === axisDirection) {
+        tooltipAxesIds.add(axisId ?? defaultAxisId);
+      }
+    });
+  });
+  return tooltipAxesIds;
+};
+exports.getAxisTriggerTooltip = getAxisTriggerTooltip;