@mui/x-charts-premium 9.0.4 → 9.1.0

package/RadialLineChart/seriesConfig/getItemAtPosition.js

@@ -0,0 +1,353 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getItemAtPosition;
+var _hooks = require("@mui/x-charts/hooks");
+var _internals = require("@mui/x-charts/internals");
+/**
+ * For a continuous rotation axis, find the two data indices that bracket the pointer's angle position.
+ * For ordinal axes, returns the single matching index (left === right).
+ * Returns null if the pointer is outside the data range.
+ */
+function getBracketIndices(rotationAxis, angle) {
+  const {
+    scale,
+    data: axisData,
+    isFullCircle
+  } = rotationAxis;
+  if (!axisData || axisData.length === 0) {
+    return null;
+  }
+  if ((0, _internals.isOrdinalScale)(scale)) {
+    const index = (0, _internals.getPolarAxisIndex)(rotationAxis, angle);
+    if (index === -1) {
+      return null;
+    }
+    const valueAngle = (0, _hooks.getValueToPositionMapper)(scale)(axisData[index]);
+    const gapAngle = (0, _internals.clampAngleRad)(angle - valueAngle);
+    if (gapAngle > Math.PI) {
+      // We are between the previous and current rotation point.
+      if (index === 0 && !isFullCircle) {
+        return null; // Only relevant for band scales.
+      }
+      return {
+        left: index > 0 ? index - 1 : axisData.length - 1,
+        right: index
+      };
+    }
+
+    // We are between the next and current rotation point.
+    if (index === rotationAxis.data.length - 1 && !isFullCircle) {
+      return null; // Only relevant for band scales.
+    }
+    return {
+      left: index,
+      right: (index + 1) % axisData.length
+    };
+  }
+
+  // For continuous axes, find the two adjacent data points surrounding pointX.
+  const rotationValue = scale.invert(scale.range()[0] + (0, _internals.clampAngleRad)(angle - scale.range()[0]));
+  const rotationAsNumber = rotationValue instanceof Date ? rotationValue.getTime() : rotationValue;
+
+  // Find the rightmost index where data[i] <= rotationValue.
+  let leftIndex = -1;
+  for (let i = 0; i < axisData.length; i += 1) {
+    if ((0, _internals.getAsNumber)(axisData[i]) <= rotationAsNumber) {
+      leftIndex = i;
+    } else {
+      break;
+    }
+  }
+  if (leftIndex === -1) {
+    // Pointer is before the first data point.
+    return null;
+  }
+  if (leftIndex === axisData.length - 1) {
+    // Pointer is at or after the last data point — check if it's close enough.
+    return {
+      left: leftIndex,
+      right: leftIndex
+    };
+  }
+  return {
+    left: leftIndex,
+    right: leftIndex + 1
+  };
+}
+
+/**
+ * Compute the r0 (baseline) for a given data point,
+ * replicating the logic from useAreaPlotData.
+ */
+function getBaselineRadius(baseline, radiusScale, stackedY0) {
+  if (typeof baseline === 'number') {
+    return radiusScale(baseline);
+  }
+  if (baseline === 'max') {
+    return radiusScale.range()[1];
+  }
+  if (baseline === 'min') {
+    return radiusScale.range()[0];
+  }
+  // Default: use the stacked baseline value.
+  const value = radiusScale(stackedY0);
+  if (Number.isNaN(value)) {
+    return radiusScale.range()[0];
+  }
+  return value;
+}
+
+// Collect the pixel-coordinate points for a contiguous (non-null) segment
+// of a series that contains the bracket indices.
+//
+// When connectNulls is true, all non-null points are returned.
+// When connectNulls is false, only the contiguous run containing [left, right] is returned.
+function collectCurvePoints(data, getPosition, left, right, connectNulls) {
+  const points = [];
+  if (connectNulls) {
+    // All non-null points form one continuous curve.
+    for (let i = 0; i < data.length; i += 1) {
+      if (data[i] != null) {
+        const position = getPosition(i);
+        if (position != null && !Number.isNaN(position.y) && !Number.isNaN(position.x)) {
+          points.push(position);
+        }
+      }
+    }
+    return points;
+  }
+
+  // Find the contiguous non-null run containing [left, right].
+  let start = left;
+  while (start > 0 && data[start - 1] != null) {
+    start -= 1;
+  }
+  let end = right;
+  while (end < data.length - 1 && data[end + 1] != null) {
+    end += 1;
+  }
+  for (let i = start; i <= end; i += 1) {
+    const position = getPosition(i);
+    if (position != null && !Number.isNaN(position.y) && !Number.isNaN(position.x)) {
+      points.push(position);
+    }
+  }
+  return points;
+}
+function isInRadiusRange(pointerRadius, radiusAxis) {
+  const range = radiusAxis.scale.range();
+  const minRadius = Math.min(range[0], range[1]);
+  const maxRadius = Math.max(range[0], range[1]);
+  return pointerRadius >= minRadius && pointerRadius <= maxRadius;
+}
+/**
+ * The maximum pixel distance (in the radial direction) from a line at which
+ * the line is still considered "close enough" to be selected over an area.
+ */
+const LINE_PROXIMITY_THRESHOLD = 15;
+function getItemAtPosition(state, point) {
+  const {
+    axis: rotationAxes,
+    axisIds: rotationAxisIds
+  } = (0, _internals.selectorChartRotationAxis)(state);
+  const {
+    axis: radiusAxes,
+    axisIds: radiusAxisIds
+  } = (0, _internals.selectorChartRadiusAxis)(state);
+  const center = (0, _internals.selectorChartPolarCenter)(state);
+  const series = (0, _internals.selectorAllSeriesOfType)(state, 'radialLine');
+  if (!series || series.seriesOrder.length === 0) {
+    return undefined;
+  }
+  const defaultRotationAxisId = rotationAxisIds[0];
+  const defaultRadiusAxisId = radiusAxisIds[0];
+
+  // Convert the pointer position to polar coordinates.
+  const dx = point.x - center.cx;
+  const dy = center.cy - point.y;
+  const pointerRadius = Math.sqrt(dx * dx + dy * dy);
+  const pointerAngle = Math.atan2(dx, dy);
+
+  // Step 1: Find the closest line across all series (measured as radial distance).
+  let closestDistance = Infinity;
+  let closestItem;
+  for (const seriesId of series.seriesOrder) {
+    const seriesItem = series.series[seriesId];
+    if (seriesItem.hidden) {
+      continue;
+    }
+    const rotationAxisId = seriesItem.rotationAxisId ?? defaultRotationAxisId;
+    const radiusAxisId = seriesItem.radiusAxisId ?? defaultRadiusAxisId;
+    const rotationAxis = rotationAxes[rotationAxisId];
+    const radiusAxis = radiusAxes[radiusAxisId];
+    if (!isInRadiusRange(pointerRadius, radiusAxis)) {
+      continue;
+    }
+    const bracket = getBracketIndices(rotationAxis, pointerAngle);
+    if (!bracket) {
+      continue;
+    }
+    const {
+      left,
+      right
+    } = bracket;
+    const {
+      visibleStackedData,
+      data,
+      connectNulls,
+      curve
+    } = seriesItem;
+    const dataIndex = (0, _internals.getPolarAxisIndex)(rotationAxis, pointerAngle);
+    if (dataIndex === -1) {
+      continue;
+    }
+
+    // Evaluate the actual curve at the pointer's angle for precise distance.
+    const rotationData = rotationAxis.data;
+    if (!rotationData) {
+      continue;
+    }
+    const rotationPosition = (0, _hooks.getValueToPositionMapper)(rotationAxis.scale);
+    const getRotation = idx => rotationPosition(rotationData[idx]);
+    const getRadius = idx => {
+      const stacked = visibleStackedData[idx];
+      return stacked ? radiusAxis.scale(stacked[1]) : null;
+    };
+    const getPosition = idx => {
+      const rotation = getRotation(idx);
+      const radius = getRadius(idx);
+      if (rotation == null || radius == null) {
+        return null;
+      }
+      return {
+        radius,
+        rotation,
+        // coordinate centered at (0, 0)
+        x: radius * Math.sin(rotation),
+        y: -radius * Math.cos(rotation)
+      };
+    };
+    const curvePoints = collectCurvePoints(data, getPosition, left, right, connectNulls);
+    if (curvePoints.length < 2) {
+      continue;
+    }
+    const closestPoint = (0, _internals.evaluateCurveAtAngle)(curvePoints, pointerAngle, curve);
+    if (closestPoint == null) {
+      continue;
+    }
+    const distance = Math.abs(pointerRadius - Math.sqrt(closestPoint.x ** 2 + closestPoint.y ** 2));
+    if (distance < closestDistance) {
+      closestDistance = distance;
+      closestItem = {
+        type: 'radialLine',
+        seriesId,
+        dataIndex
+      };
+    }
+  }
+
+  // Step 2: If the closest line is within the proximity threshold, pick it.
+  if (closestItem && closestDistance <= LINE_PROXIMITY_THRESHOLD && !series.series[closestItem.seriesId].area) {
+    return closestItem;
+  }
+
+  // Step 3: Check area series — iterate stacking groups in reverse
+  // so that topmost (last rendered) area is checked first.
+  const {
+    stackingGroups
+  } = series;
+  for (let g = stackingGroups.length - 1; g >= 0; g -= 1) {
+    const groupIds = stackingGroups[g].ids;
+    for (let i = 0; i <= groupIds.length - 1; i += 1) {
+      const seriesId = groupIds[i];
+      const seriesItem = series.series[seriesId];
+      if (seriesItem.hidden || !seriesItem.area) {
+        continue;
+      }
+      const rotationAxisId = seriesItem.rotationAxisId ?? defaultRotationAxisId;
+      const radiusAxisId = seriesItem.radiusAxisId ?? defaultRadiusAxisId;
+      const rotationAxis = rotationAxes[rotationAxisId];
+      const radiusAxis = radiusAxes[radiusAxisId];
+      if (!rotationAxis || !radiusAxis) {
+        continue;
+      }
+      const bracket = getBracketIndices(rotationAxis, pointerAngle);
+      if (!bracket) {
+        continue;
+      }
+      const {
+        left,
+        right
+      } = bracket;
+      const {
+        visibleStackedData,
+        data,
+        connectNulls,
+        baseline,
+        curve
+      } = seriesItem;
+
+      // Check for null gaps at bracket points.
+      if ((data[left] == null || data[right] == null) && !connectNulls) {
+        continue;
+      }
+      const rotationScale = rotationAxis.scale;
+      const radiusScale = radiusAxis.scale;
+      const rotationPosition = (0, _hooks.getValueToPositionMapper)(rotationScale);
+      const rotationData = rotationAxis.data;
+      if (!rotationData) {
+        continue;
+      }
+      const getRotation = idx => rotationPosition(rotationData[idx]);
+      const getRadius = (idx, position) => {
+        const stacked = visibleStackedData[idx];
+        return position === 0 ? getBaselineRadius(baseline, radiusScale, stacked ? stacked[0] : 0) : radiusScale(stacked[1]);
+      };
+      const getPosition = position => idx => {
+        const rotation = getRotation(idx);
+        const radius = getRadius(idx, position);
+        if (rotation == null || radius == null) {
+          return null;
+        }
+        return {
+          radius,
+          rotation,
+          // coordinate centered at (0, 0)
+          x: radius * Math.sin(rotation),
+          y: -radius * Math.cos(rotation)
+        };
+      };
+
+      // Build pixel-coordinate points for the top and bottom curves,
+      // then evaluate them at the pointer's x using the actual d3 curve.
+      const topPoints = collectCurvePoints(data, getPosition(1), left, right, connectNulls);
+      const bottomPoints = collectCurvePoints(data, getPosition(0), left, right, connectNulls);
+      if (topPoints.length < 2 || bottomPoints.length < 2) {
+        continue;
+      }
+      const outerPoint = (0, _internals.evaluateCurveAtAngle)(topPoints, pointerAngle, curve);
+      const innerPoint = (0, _internals.evaluateCurveAtAngle)(bottomPoints, pointerAngle, curve);
+      if (outerPoint == null || innerPoint == null) {
+        continue;
+      }
+      const innerRadius = Math.sqrt(innerPoint.x ** 2 + innerPoint.y ** 2);
+      const outerRadius = Math.sqrt(outerPoint.x ** 2 + outerPoint.y ** 2);
+      const radiusMin = Math.min(innerRadius, outerRadius);
+      const radiusMax = Math.max(innerRadius, outerRadius);
+      if (pointerRadius >= radiusMin && pointerRadius <= radiusMax) {
+        const dataIndex = (0, _internals.getPolarAxisIndex)(rotationAxis, pointerAngle);
+        return {
+          type: 'radialLine',
+          seriesId,
+          dataIndex: dataIndex === -1 ? left : dataIndex
+        };
+      }
+    }
+  }
+
+  // Step 4: No area matched — return the closest line regardless of threshold.
+  return closestItem;
+}

package/RadialLineChart/seriesConfig/getItemAtPosition.mjs

@@ -0,0 +1,348 @@
+import { getValueToPositionMapper } from '@mui/x-charts/hooks';
+import { selectorAllSeriesOfType, selectorChartPolarCenter, selectorChartRadiusAxis, selectorChartRotationAxis, getPolarAxisIndex, isOrdinalScale } from '@mui/x-charts/internals';
+import { evaluateCurveAtAngle, clampAngleRad, getAsNumber } from '@mui/x-charts/internals';
+/**
+ * For a continuous rotation axis, find the two data indices that bracket the pointer's angle position.
+ * For ordinal axes, returns the single matching index (left === right).
+ * Returns null if the pointer is outside the data range.
+ */
+function getBracketIndices(rotationAxis, angle) {
+  const {
+    scale,
+    data: axisData,
+    isFullCircle
+  } = rotationAxis;
+  if (!axisData || axisData.length === 0) {
+    return null;
+  }
+  if (isOrdinalScale(scale)) {
+    const index = getPolarAxisIndex(rotationAxis, angle);
+    if (index === -1) {
+      return null;
+    }
+    const valueAngle = getValueToPositionMapper(scale)(axisData[index]);
+    const gapAngle = clampAngleRad(angle - valueAngle);
+    if (gapAngle > Math.PI) {
+      // We are between the previous and current rotation point.
+      if (index === 0 && !isFullCircle) {
+        return null; // Only relevant for band scales.
+      }
+      return {
+        left: index > 0 ? index - 1 : axisData.length - 1,
+        right: index
+      };
+    }
+
+    // We are between the next and current rotation point.
+    if (index === rotationAxis.data.length - 1 && !isFullCircle) {
+      return null; // Only relevant for band scales.
+    }
+    return {
+      left: index,
+      right: (index + 1) % axisData.length
+    };
+  }
+
+  // For continuous axes, find the two adjacent data points surrounding pointX.
+  const rotationValue = scale.invert(scale.range()[0] + clampAngleRad(angle - scale.range()[0]));
+  const rotationAsNumber = rotationValue instanceof Date ? rotationValue.getTime() : rotationValue;
+
+  // Find the rightmost index where data[i] <= rotationValue.
+  let leftIndex = -1;
+  for (let i = 0; i < axisData.length; i += 1) {
+    if (getAsNumber(axisData[i]) <= rotationAsNumber) {
+      leftIndex = i;
+    } else {
+      break;
+    }
+  }
+  if (leftIndex === -1) {
+    // Pointer is before the first data point.
+    return null;
+  }
+  if (leftIndex === axisData.length - 1) {
+    // Pointer is at or after the last data point — check if it's close enough.
+    return {
+      left: leftIndex,
+      right: leftIndex
+    };
+  }
+  return {
+    left: leftIndex,
+    right: leftIndex + 1
+  };
+}
+
+/**
+ * Compute the r0 (baseline) for a given data point,
+ * replicating the logic from useAreaPlotData.
+ */
+function getBaselineRadius(baseline, radiusScale, stackedY0) {
+  if (typeof baseline === 'number') {
+    return radiusScale(baseline);
+  }
+  if (baseline === 'max') {
+    return radiusScale.range()[1];
+  }
+  if (baseline === 'min') {
+    return radiusScale.range()[0];
+  }
+  // Default: use the stacked baseline value.
+  const value = radiusScale(stackedY0);
+  if (Number.isNaN(value)) {
+    return radiusScale.range()[0];
+  }
+  return value;
+}
+
+// Collect the pixel-coordinate points for a contiguous (non-null) segment
+// of a series that contains the bracket indices.
+//
+// When connectNulls is true, all non-null points are returned.
+// When connectNulls is false, only the contiguous run containing [left, right] is returned.
+function collectCurvePoints(data, getPosition, left, right, connectNulls) {
+  const points = [];
+  if (connectNulls) {
+    // All non-null points form one continuous curve.
+    for (let i = 0; i < data.length; i += 1) {
+      if (data[i] != null) {
+        const position = getPosition(i);
+        if (position != null && !Number.isNaN(position.y) && !Number.isNaN(position.x)) {
+          points.push(position);
+        }
+      }
+    }
+    return points;
+  }
+
+  // Find the contiguous non-null run containing [left, right].
+  let start = left;
+  while (start > 0 && data[start - 1] != null) {
+    start -= 1;
+  }
+  let end = right;
+  while (end < data.length - 1 && data[end + 1] != null) {
+    end += 1;
+  }
+  for (let i = start; i <= end; i += 1) {
+    const position = getPosition(i);
+    if (position != null && !Number.isNaN(position.y) && !Number.isNaN(position.x)) {
+      points.push(position);
+    }
+  }
+  return points;
+}
+function isInRadiusRange(pointerRadius, radiusAxis) {
+  const range = radiusAxis.scale.range();
+  const minRadius = Math.min(range[0], range[1]);
+  const maxRadius = Math.max(range[0], range[1]);
+  return pointerRadius >= minRadius && pointerRadius <= maxRadius;
+}
+/**
+ * The maximum pixel distance (in the radial direction) from a line at which
+ * the line is still considered "close enough" to be selected over an area.
+ */
+const LINE_PROXIMITY_THRESHOLD = 15;
+export default function getItemAtPosition(state, point) {
+  const {
+    axis: rotationAxes,
+    axisIds: rotationAxisIds
+  } = selectorChartRotationAxis(state);
+  const {
+    axis: radiusAxes,
+    axisIds: radiusAxisIds
+  } = selectorChartRadiusAxis(state);
+  const center = selectorChartPolarCenter(state);
+  const series = selectorAllSeriesOfType(state, 'radialLine');
+  if (!series || series.seriesOrder.length === 0) {
+    return undefined;
+  }
+  const defaultRotationAxisId = rotationAxisIds[0];
+  const defaultRadiusAxisId = radiusAxisIds[0];
+
+  // Convert the pointer position to polar coordinates.
+  const dx = point.x - center.cx;
+  const dy = center.cy - point.y;
+  const pointerRadius = Math.sqrt(dx * dx + dy * dy);
+  const pointerAngle = Math.atan2(dx, dy);
+
+  // Step 1: Find the closest line across all series (measured as radial distance).
+  let closestDistance = Infinity;
+  let closestItem;
+  for (const seriesId of series.seriesOrder) {
+    const seriesItem = series.series[seriesId];
+    if (seriesItem.hidden) {
+      continue;
+    }
+    const rotationAxisId = seriesItem.rotationAxisId ?? defaultRotationAxisId;
+    const radiusAxisId = seriesItem.radiusAxisId ?? defaultRadiusAxisId;
+    const rotationAxis = rotationAxes[rotationAxisId];
+    const radiusAxis = radiusAxes[radiusAxisId];
+    if (!isInRadiusRange(pointerRadius, radiusAxis)) {
+      continue;
+    }
+    const bracket = getBracketIndices(rotationAxis, pointerAngle);
+    if (!bracket) {
+      continue;
+    }
+    const {
+      left,
+      right
+    } = bracket;
+    const {
+      visibleStackedData,
+      data,
+      connectNulls,
+      curve
+    } = seriesItem;
+    const dataIndex = getPolarAxisIndex(rotationAxis, pointerAngle);
+    if (dataIndex === -1) {
+      continue;
+    }
+
+    // Evaluate the actual curve at the pointer's angle for precise distance.
+    const rotationData = rotationAxis.data;
+    if (!rotationData) {
+      continue;
+    }
+    const rotationPosition = getValueToPositionMapper(rotationAxis.scale);
+    const getRotation = idx => rotationPosition(rotationData[idx]);
+    const getRadius = idx => {
+      const stacked = visibleStackedData[idx];
+      return stacked ? radiusAxis.scale(stacked[1]) : null;
+    };
+    const getPosition = idx => {
+      const rotation = getRotation(idx);
+      const radius = getRadius(idx);
+      if (rotation == null || radius == null) {
+        return null;
+      }
+      return {
+        radius,
+        rotation,
+        // coordinate centered at (0, 0)
+        x: radius * Math.sin(rotation),
+        y: -radius * Math.cos(rotation)
+      };
+    };
+    const curvePoints = collectCurvePoints(data, getPosition, left, right, connectNulls);
+    if (curvePoints.length < 2) {
+      continue;
+    }
+    const closestPoint = evaluateCurveAtAngle(curvePoints, pointerAngle, curve);
+    if (closestPoint == null) {
+      continue;
+    }
+    const distance = Math.abs(pointerRadius - Math.sqrt(closestPoint.x ** 2 + closestPoint.y ** 2));
+    if (distance < closestDistance) {
+      closestDistance = distance;
+      closestItem = {
+        type: 'radialLine',
+        seriesId,
+        dataIndex
+      };
+    }
+  }
+
+  // Step 2: If the closest line is within the proximity threshold, pick it.
+  if (closestItem && closestDistance <= LINE_PROXIMITY_THRESHOLD && !series.series[closestItem.seriesId].area) {
+    return closestItem;
+  }
+
+  // Step 3: Check area series — iterate stacking groups in reverse
+  // so that topmost (last rendered) area is checked first.
+  const {
+    stackingGroups
+  } = series;
+  for (let g = stackingGroups.length - 1; g >= 0; g -= 1) {
+    const groupIds = stackingGroups[g].ids;
+    for (let i = 0; i <= groupIds.length - 1; i += 1) {
+      const seriesId = groupIds[i];
+      const seriesItem = series.series[seriesId];
+      if (seriesItem.hidden || !seriesItem.area) {
+        continue;
+      }
+      const rotationAxisId = seriesItem.rotationAxisId ?? defaultRotationAxisId;
+      const radiusAxisId = seriesItem.radiusAxisId ?? defaultRadiusAxisId;
+      const rotationAxis = rotationAxes[rotationAxisId];
+      const radiusAxis = radiusAxes[radiusAxisId];
+      if (!rotationAxis || !radiusAxis) {
+        continue;
+      }
+      const bracket = getBracketIndices(rotationAxis, pointerAngle);
+      if (!bracket) {
+        continue;
+      }
+      const {
+        left,
+        right
+      } = bracket;
+      const {
+        visibleStackedData,
+        data,
+        connectNulls,
+        baseline,
+        curve
+      } = seriesItem;
+
+      // Check for null gaps at bracket points.
+      if ((data[left] == null || data[right] == null) && !connectNulls) {
+        continue;
+      }
+      const rotationScale = rotationAxis.scale;
+      const radiusScale = radiusAxis.scale;
+      const rotationPosition = getValueToPositionMapper(rotationScale);
+      const rotationData = rotationAxis.data;
+      if (!rotationData) {
+        continue;
+      }
+      const getRotation = idx => rotationPosition(rotationData[idx]);
+      const getRadius = (idx, position) => {
+        const stacked = visibleStackedData[idx];
+        return position === 0 ? getBaselineRadius(baseline, radiusScale, stacked ? stacked[0] : 0) : radiusScale(stacked[1]);
+      };
+      const getPosition = position => idx => {
+        const rotation = getRotation(idx);
+        const radius = getRadius(idx, position);
+        if (rotation == null || radius == null) {
+          return null;
+        }
+        return {
+          radius,
+          rotation,
+          // coordinate centered at (0, 0)
+          x: radius * Math.sin(rotation),
+          y: -radius * Math.cos(rotation)
+        };
+      };
+
+      // Build pixel-coordinate points for the top and bottom curves,
+      // then evaluate them at the pointer's x using the actual d3 curve.
+      const topPoints = collectCurvePoints(data, getPosition(1), left, right, connectNulls);
+      const bottomPoints = collectCurvePoints(data, getPosition(0), left, right, connectNulls);
+      if (topPoints.length < 2 || bottomPoints.length < 2) {
+        continue;
+      }
+      const outerPoint = evaluateCurveAtAngle(topPoints, pointerAngle, curve);
+      const innerPoint = evaluateCurveAtAngle(bottomPoints, pointerAngle, curve);
+      if (outerPoint == null || innerPoint == null) {
+        continue;
+      }
+      const innerRadius = Math.sqrt(innerPoint.x ** 2 + innerPoint.y ** 2);
+      const outerRadius = Math.sqrt(outerPoint.x ** 2 + outerPoint.y ** 2);
+      const radiusMin = Math.min(innerRadius, outerRadius);
+      const radiusMax = Math.max(innerRadius, outerRadius);
+      if (pointerRadius >= radiusMin && pointerRadius <= radiusMax) {
+        const dataIndex = getPolarAxisIndex(rotationAxis, pointerAngle);
+        return {
+          type: 'radialLine',
+          seriesId,
+          dataIndex: dataIndex === -1 ? left : dataIndex
+        };
+      }
+    }
+  }
+
+  // Step 4: No area matched — return the closest line regardless of threshold.
+  return closestItem;
+}

package/RadialLineChart/seriesConfig/getSeriesWithDefaultValues.js

@@ -8,6 +8,7 @@ exports.default = void 0;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 const getSeriesWithDefaultValues = (seriesData, seriesIndex, colors) => (0, _extends2.default)({}, seriesData, {
   id: seriesData.id ?? `auto-generated-id-${seriesIndex}`,
-  color: seriesData.color ?? colors[seriesIndex % colors.length]
+  color: seriesData.color ?? colors[seriesIndex % colors.length],
+  curve: seriesData.curve ?? 'linear'
 });
 var _default = exports.default = getSeriesWithDefaultValues;