Function findPointsAtX

src/interaction/findPointsAtX.ts:146–404

(
  series: ReadonlyArray<ResolvedSeriesConfig>,
  xValue: number,
  xScale: LinearScale,
  tolerance?: number,
)

 *   back to the existing nearest-x behavior (so axis-trigger tooltips still work away from bars).
 */
export function findPointsAtX(
  series: ReadonlyArray<ResolvedSeriesConfig>,
  xValue: number,
  xScale: LinearScale,
  tolerance?: number,
): ReadonlyArray<PointsAtXMatch> {
  if (!Number.isFinite(xValue)) return [];

  const maxDx =
    tolerance === undefined || !Number.isFinite(tolerance) ? Number.POSITIVE_INFINITY : Math.max(0, tolerance);
  const maxDxSq = maxDx * maxDx;

  const xTarget = xScale.invert(xValue);
  if (!Number.isFinite(xTarget)) return [];

  const matches: PointsAtXMatch[] = [];
  const barLayout = computeBarHitTestLayout(series, xScale);

  for (let s = 0; s < series.length; s++) {
    const seriesConfig = series[s];
    // Pie and candlestick are non-cartesian (or not yet implemented); they can't match an x position.
    if (seriesConfig.type === 'pie' || seriesConfig.type === 'candlestick') continue;

    const data = seriesConfig.data;
    const n = data.length;
    if (n === 0) continue;

    const first = data[0];
    const isTuple = Array.isArray(first);

    // Bar series: return the correct bar dataIndex for xValue when inside the bar interval.
    // When tolerance is finite: require an (expanded) interval hit.
    // When tolerance is non-finite: attempt exact hit, otherwise fall back to nearest-x behavior below.
    if (seriesConfig.type === 'bar' && barLayout) {
      const clusterIndex = barLayout.clusterIndexByGlobalSeriesIndex.get(s);
      if (clusterIndex !== undefined) {
        const { barWidth, gap, clusterWidth } = barLayout;
        const offsetLeftFromCategoryCenter = -clusterWidth / 2 + clusterIndex * (barWidth + gap);

        const hitTol =
          tolerance === undefined || !Number.isFinite(tolerance) ? 0 : Math.max(0, tolerance);

        // If we can't safely compute an interval hit, don't guess when tolerance is finite.
        if (Number.isFinite(barWidth) && barWidth > 0 && Number.isFinite(offsetLeftFromCategoryCenter)) {
          let hitIndex = -1;

          const isHit = (xCenterRange: number): boolean => {
            if (!Number.isFinite(xCenterRange)) return false;
            const left = xCenterRange + offsetLeftFromCategoryCenter;
            const right = left + barWidth;
            // Expanded interval: [left - tol, right + tol)
            return xValue >= left - hitTol && xValue < right + hitTol;
          };

          if (seriesHasNaNX(data, isTuple)) {
            // NaN breaks ordering; linear scan for correctness.
            if (isTuple) {
              const tupleData = data as ReadonlyArray<TuplePoint>;