@gravity-ui/charts 1.51.1 → 1.51.5

package/dist/cjs/setup-jsdom.js

@@ -1,4 +1,4 @@
-"use strict";
+import './plugins';
 // Global mocks for jsdom environment.
 // Guarded by typeof checks so this file is safe to run in the `node` environment too.
 if (typeof document !== 'undefined') {
@@ -11,10 +11,36 @@ if (typeof document !== 'undefined') {
     }
 }
 if (typeof ResizeObserver === 'undefined') {
+    const resizeObserverCallbacks = new Map();
     global.ResizeObserver = class ResizeObserver {
-        observe() { }
-        unobserve() { }
-        disconnect() { }
+        constructor(callback) {
+            this.callback = callback;
+        }
+        observe(target) {
+            if (!resizeObserverCallbacks.has(target)) {
+                resizeObserverCallbacks.set(target, new Set());
+            }
+            resizeObserverCallbacks.get(target).add(this.callback);
+        }
+        unobserve(target) {
+            var _a;
+            (_a = resizeObserverCallbacks.get(target)) === null || _a === void 0 ? void 0 : _a.delete(this.callback);
+        }
+        disconnect() {
+            resizeObserverCallbacks.forEach((callbacks) => {
+                callbacks.delete(this.callback);
+            });
+        }
+    };
+    /**
+     * Test helper: simulate a ResizeObserver notification for the given element.
+     */
+    global.__triggerResizeObserver = (target) => {
+        const callbacks = resizeObserverCallbacks.get(target);
+        if (callbacks) {
+            const entry = [{ target, contentRect: target.getBoundingClientRect() }];
+            callbacks.forEach((cb) => cb(entry, {}));
+        }
     };
 }
 if (typeof HTMLCanvasElement !== 'undefined') {

package/dist/esm/components/index.js

@@ -1,8 +1,6 @@
 import React from 'react';
-import { select } from 'd3-selection';
 import debounce from 'lodash/debounce';
 import { i18nFactory } from '../core/i18n';
-import { getUniqId } from '../core/utils';
 import { validateData } from '../core/validation';
 import { ChartInner } from './ChartInner';
 export * from './Tooltip/ChartTooltipContent';
@@ -17,11 +15,22 @@ export const Chart = React.forwardRef(function Chart(props, forwardedRef) {
         validateData(data);
         validatedData.current = data;
     }
-    const handleResize = React.useCallback(() => {
+    const handleResize = React.useCallback((options) => {
         var _a;
         const parentElement = (_a = ref.current) === null || _a === void 0 ? void 0 : _a.parentElement;
         if (parentElement) {
-            setDimensions({ width: parentElement.clientWidth, height: parentElement.clientHeight });
+            const nextDimensions = {
+                width: parentElement.clientWidth,
+                height: parentElement.clientHeight,
+            };
+            setDimensions((currentDimensions) => {
+                if (!(options === null || options === void 0 ? void 0 : options.force) &&
+                    (currentDimensions === null || currentDimensions === void 0 ? void 0 : currentDimensions.width) === nextDimensions.width &&
+                    currentDimensions.height === nextDimensions.height) {
+                    return currentDimensions;
+                }
+                return nextDimensions;
+            });
         }
     }, []);
     const debuncedHandleResize = React.useMemo(() => {
@@ -33,10 +42,10 @@ export const Chart = React.forwardRef(function Chart(props, forwardedRef) {
     React.useImperativeHandle(forwardedRef, () => ({
         reflow(options) {
             if (options === null || options === void 0 ? void 0 : options.immediate) {
-                handleResize();
+                handleResize({ force: true });
             }
             else {
-                debuncedHandleResize();
+                debuncedHandleResize({ force: true });
             }
         },
     }), [debuncedHandleResize, handleResize]);
@@ -45,19 +54,18 @@ export const Chart = React.forwardRef(function Chart(props, forwardedRef) {
         handleResize();
     }, [handleResize]);
     React.useEffect(() => {
-        const selection = select(window);
-        // https://github.com/d3/d3-selection/blob/main/README.md#handling-events
-        const eventName = `resize.${getUniqId()}`;
-        selection.on(eventName, debuncedHandleResize);
-        window.addEventListener('transitionend', handleResize, { capture: true });
-        window.addEventListener('animationend', handleResize, { capture: true });
+        var _a;
+        const parentElement = (_a = ref.current) === null || _a === void 0 ? void 0 : _a.parentElement;
+        if (!parentElement) {
+            return undefined;
+        }
+        const observer = new ResizeObserver(() => debuncedHandleResize());
+        observer.observe(parentElement);
         return () => {
-            // https://d3js.org/d3-selection/events#selection_on
-            selection.on(eventName, null);
-            window.removeEventListener('transitionend', handleResize, { capture: true });
-            window.removeEventListener('animationend', handleResize, { capture: true });
+            observer.disconnect();
+            debuncedHandleResize.cancel();
         };
-    }, [debuncedHandleResize, handleResize]);
+    }, [debuncedHandleResize]);
     React.useEffect(() => {
         if (typeof onResize === 'function') {
             onResize({ dimensions });

package/dist/esm/core/series/plugin.d.ts

@@ -0,0 +1,14 @@
+import type { ScaleOrdinal } from 'd3-scale';
+import type { ChartSeries, ChartSeriesOptions } from '../../types';
+import type { PreparedLegend, PreparedSeries } from './types';
+export interface PrepareSeriesArgs {
+    series: ChartSeries[];
+    seriesOptions?: ChartSeriesOptions;
+    legend: PreparedLegend;
+    colorScale: ScaleOrdinal<string, string>;
+    colors: string[];
+}
+export interface SeriesPlugin<T extends ChartSeries = ChartSeries> {
+    type: T['type'];
+    prepareSeries(args: PrepareSeriesArgs): PreparedSeries[] | Promise<PreparedSeries[]>;
+}

package/dist/esm/core/series/plugin.js

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

package/dist/esm/core/series/prepareSeries.d.ts

@@ -1,5 +1,5 @@
-import type { ScaleOrdinal } from 'd3-scale';
-import type { ChartData, ChartSeries, ChartSeriesOptions } from '../../types';
+import type { ChartData } from '../../types';
+import type { PrepareSeriesArgs } from './plugin';
 import type { PreparedLegend, PreparedSeries } from './types';
 export declare const getPreparedSeries: ({ seriesData, seriesOptions, colors, preparedLegend, }: {
     seriesData: ChartData["series"]["data"];
@@ -7,11 +7,4 @@ export declare const getPreparedSeries: ({ seriesData, seriesOptions, colors, pr
     colors: string[];
     preparedLegend?: PreparedLegend | null;
 }) => Promise<PreparedSeries[]>;
-export declare function prepareSeries(args: {
-    type: ChartSeries['type'];
-    series: ChartSeries[];
-    seriesOptions?: ChartSeriesOptions;
-    legend: PreparedLegend;
-    colors: string[];
-    colorScale: ScaleOrdinal<string, string>;
-}): Promise<PreparedSeries[]>;
+export declare function prepareSeries(args: PrepareSeriesArgs): Promise<PreparedSeries[]>;

package/dist/esm/core/series/prepareSeries.js

@@ -1,20 +1,7 @@
 import { group } from 'd3-array';
 import { scaleOrdinal } from 'd3-scale';
-import { ChartError } from '../../libs';
 import { getSeriesNames } from '../utils';
-import { prepareArea } from './prepare-area';
-import { prepareBarXSeries } from './prepare-bar-x';
-import { prepareBarYSeries } from './prepare-bar-y';
-import { prepareFunnelSeries } from './prepare-funnel';
-import { prepareHeatmapSeries } from './prepare-heatmap';
-import { prepareLineSeries } from './prepare-line';
-import { preparePieSeries } from './prepare-pie';
-import { prepareRadarSeries } from './prepare-radar';
-import { prepareSankeySeries } from './prepare-sankey';
-import { prepareScatterSeries } from './prepare-scatter';
-import { prepareTreemap } from './prepare-treemap';
-import { prepareWaterfallSeries } from './prepare-waterfall';
-import { prepareXRangeSeries } from './prepare-x-range';
+import { getSeriesPlugin } from './seriesRegistry';
 export const getPreparedSeries = async ({ seriesData, seriesOptions, colors, preparedLegend, }) => {
     const seriesNames = getSeriesNames(seriesData);
     const colorScale = scaleOrdinal(seriesNames, colors);
@@ -31,9 +18,7 @@ export const getPreparedSeries = async ({ seriesData, seriesOptions, colors, pre
     const list = Array.from(groupedSeries);
     for (let i = 0; i < list.length; i++) {
         const [_groupId, seriesList] = list[i];
-        const seriesType = seriesList[0].type;
         acc.push(...(await prepareSeries({
-            type: seriesType,
             series: seriesList,
             seriesOptions,
             legend: preparedLegend,
@@ -44,114 +29,6 @@ export const getPreparedSeries = async ({ seriesData, seriesOptions, colors, pre
     return acc;
 };
 export async function prepareSeries(args) {
-    const { type, series, seriesOptions, legend, colors, colorScale } = args;
-    switch (type) {
-        case 'pie': {
-            return series.reduce((acc, singleSeries) => {
-                acc.push(...preparePieSeries({
-                    series: singleSeries,
-                    seriesOptions,
-                    legend,
-                    colors,
-                }));
-                return acc;
-            }, []);
-        }
-        case 'bar-x': {
-            return prepareBarXSeries({
-                series: series,
-                legend,
-                colorScale,
-                seriesOptions,
-            });
-        }
-        case 'bar-y': {
-            return await prepareBarYSeries({
-                series: series,
-                legend,
-                colorScale,
-                seriesOptions,
-            });
-        }
-        case 'scatter': {
-            return prepareScatterSeries({ series: series, legend, colorScale });
-        }
-        case 'line': {
-            return prepareLineSeries({
-                series: series,
-                seriesOptions,
-                legend,
-                colorScale,
-            });
-        }
-        case 'area': {
-            return prepareArea({
-                series: series,
-                seriesOptions,
-                legend,
-                colorScale,
-            });
-        }
-        case 'treemap': {
-            return prepareTreemap({
-                series: series,
-                seriesOptions,
-                legend,
-                colorScale,
-            });
-        }
-        case 'waterfall': {
-            return prepareWaterfallSeries({
-                series: series,
-                legend,
-                colorScale,
-                colors,
-            });
-        }
-        case 'sankey': {
-            return prepareSankeySeries({
-                series: series,
-                seriesOptions,
-                colorScale,
-                legend,
-            });
-        }
-        case 'radar': {
-            return prepareRadarSeries({
-                series: series,
-                seriesOptions,
-                legend,
-                colors,
-            });
-        }
-        case 'heatmap': {
-            return await prepareHeatmapSeries({
-                series: series,
-                legend,
-                colorScale,
-                seriesOptions,
-            });
-        }
-        case 'funnel': {
-            return prepareFunnelSeries({
-                series: series[0],
-                seriesOptions,
-                legend,
-                colors,
-            });
-        }
-        case 'x-range': {
-            return prepareXRangeSeries({
-                series: series,
-                seriesOptions,
-                legend,
-                colorScale,
-            });
-        }
-        default: {
-            throw new ChartError({
-                message: `Series type "${type}" does not support data preparation for series that do not support the presence of axes`,
-            });
-        }
-    }
+    const plugin = getSeriesPlugin(args.series[0].type);
+    return plugin.prepareSeries(args);
 }

package/dist/esm/core/series/seriesRegistry.d.ts

@@ -0,0 +1,3 @@
+import type { SeriesPlugin } from './plugin';
+export declare function registerSeriesPlugin(plugin: SeriesPlugin): void;
+export declare function getSeriesPlugin(type: string): SeriesPlugin;

package/dist/esm/core/series/seriesRegistry.js

@@ -0,0 +1,12 @@
+import { ChartError } from '../../libs';
+const registry = new Map();
+export function registerSeriesPlugin(plugin) {
+    registry.set(plugin.type, plugin);
+}
+export function getSeriesPlugin(type) {
+    const plugin = registry.get(type);
+    if (!plugin) {
+        throw new ChartError({ message: `Unknown series type: "${type}"` });
+    }
+    return plugin;
+}

package/dist/esm/core/shapes/area/get-tooltip-data.d.ts

@@ -0,0 +1,3 @@
+import type { GetTooltipDataArgs, GetTooltipDataResult } from '../../utils/tooltip-helpers';
+import type { PreparedAreaData } from './types';
+export declare function getTooltipData(args: GetTooltipDataArgs<PreparedAreaData>): GetTooltipDataResult;

package/dist/esm/core/shapes/area/get-tooltip-data.js

@@ -0,0 +1,19 @@
+export function getTooltipData(args) {
+    const { data } = args;
+    const xLookupPoints = data.reduce((acc, d) => {
+        for (const p of d.points) {
+            if (p.y === null || p.hiddenInLine) {
+                continue;
+            }
+            acc.push({
+                data: p.data,
+                series: p.series,
+                x: p.x,
+                y0: p.y0,
+                y1: p.y,
+            });
+        }
+        return acc;
+    }, []);
+    return { chunks: [], xLookupPoints };
+}

package/dist/esm/core/shapes/bar-x/get-tooltip-data.d.ts

@@ -0,0 +1,3 @@
+import type { GetTooltipDataArgs, GetTooltipDataResult } from '../../utils/tooltip-helpers';
+import type { PreparedBarXData } from './types';
+export declare function getTooltipData(args: GetTooltipDataArgs<PreparedBarXData>): GetTooltipDataResult;

package/dist/esm/core/shapes/bar-x/get-tooltip-data.js

@@ -0,0 +1,20 @@
+import groupBy from 'lodash/groupBy';
+export function getTooltipData(args) {
+    const { data } = args;
+    const barXGroups = groupBy(data, (d) => String(d.data.x));
+    const xLookupPoints = [];
+    for (const group of Object.values(barXGroups)) {
+        const groupCenterX = group.reduce((sum, d) => sum + d.x + d.width / 2, 0) / group.length;
+        for (const d of group) {
+            xLookupPoints.push({
+                data: d.data,
+                series: d.series,
+                x: groupCenterX,
+                y0: d.y,
+                y1: d.y + d.height,
+                sourceX: d.x + d.width / 2,
+            });
+        }
+    }
+    return { chunks: [], xLookupPoints };
+}

package/dist/esm/core/shapes/bar-y/get-tooltip-data.d.ts

@@ -0,0 +1,3 @@
+import type { GetTooltipDataArgs, GetTooltipDataResult } from '../../utils/tooltip-helpers';
+import type { PreparedBarYData } from './types';
+export declare function getTooltipData(args: GetTooltipDataArgs<PreparedBarYData>): GetTooltipDataResult;

package/dist/esm/core/shapes/bar-y/get-tooltip-data.js

@@ -0,0 +1,32 @@
+import { bisector, sort } from 'd3-array';
+export function getTooltipData(args) {
+    var _a, _b;
+    const { data, position } = args;
+    const [pointerX, pointerY] = position;
+    const sorted = sort(data, (p) => p.y);
+    const closestYIndex = bisector((p) => p.y + p.height / 2).center(sorted, pointerY);
+    const closestYPoint = sorted[closestYIndex];
+    if (!closestYPoint) {
+        return { chunks: [] };
+    }
+    const selectedPoints = data.filter((p) => p.data.y === closestYPoint.data.y);
+    const closestPoints = sort(selectedPoints.filter((p) => p.y === closestYPoint.y), (p) => p.x);
+    let closestPointXValue;
+    const lastPoint = closestPoints[closestPoints.length - 1];
+    if (pointerX < ((_a = closestPoints[0]) === null || _a === void 0 ? void 0 : _a.x)) {
+        closestPointXValue = closestPoints[0].x;
+    }
+    else if (lastPoint && pointerX > lastPoint.x + lastPoint.width) {
+        closestPointXValue = lastPoint.x;
+    }
+    else {
+        closestPointXValue = (_b = closestPoints.find((p) => pointerX > p.x && pointerX < p.x + p.width)) === null || _b === void 0 ? void 0 : _b.x;
+    }
+    return {
+        chunks: selectedPoints.map((p) => ({
+            data: p.data,
+            series: p.series,
+            closest: p.x === closestPointXValue && p.y === closestYPoint.y,
+        })),
+    };
+}

package/dist/esm/core/shapes/funnel/get-tooltip-data.d.ts

@@ -0,0 +1,3 @@
+import type { GetTooltipDataArgs, GetTooltipDataResult } from '../../utils/tooltip-helpers';
+import type { PreparedFunnelData } from './types';
+export declare function getTooltipData(args: GetTooltipDataArgs<PreparedFunnelData>): GetTooltipDataResult;

package/dist/esm/core/shapes/funnel/get-tooltip-data.js

@@ -0,0 +1,21 @@
+export function getTooltipData(args) {
+    var _a;
+    const { data, position } = args;
+    const [pointerX, pointerY] = position;
+    const closestPoint = (_a = data[0]) === null || _a === void 0 ? void 0 : _a.items.find((item) => pointerX >= item.x &&
+        pointerX <= item.x + item.width &&
+        pointerY >= item.y &&
+        pointerY <= item.y + item.height);
+    if (!closestPoint) {
+        return { chunks: [] };
+    }
+    return {
+        chunks: [
+            {
+                data: closestPoint.data,
+                series: closestPoint.series,
+                closest: true,
+            },
+        ],
+    };
+}

package/dist/esm/core/shapes/funnel/prepare-data.js

@@ -128,11 +128,13 @@ export async function prepareFunnelData(args) {
         const prevSeries = series[index - 1];
         const prevItem = items[index - 1];
         if (prevSeries && prevItem && ((_e = prevSeries.connectors) === null || _e === void 0 ? void 0 : _e.enabled)) {
+            // Use the actual bottom corners of the previous segment (points[3]/[2]) so that
+            // trapezoid segments (whose bottom edge differs from the top edge) are handled correctly.
             const connectorPoints = [
-                [prevItem.x, prevItem.y + prevItem.height],
-                [prevItem.x + prevItem.width, prevItem.y + prevItem.height],
-                [funnelSegment.x + funnelSegment.width, funnelSegment.y],
-                [funnelSegment.x, funnelSegment.y],
+                prevItem.points[3],
+                prevItem.points[2],
+                funnelSegment.points[1],
+                funnelSegment.points[0],
             ];
             connectors.push({
                 linePath: getLineConnectorPaths({ points: connectorPoints }),

package/dist/esm/core/shapes/heatmap/get-tooltip-data.d.ts

@@ -0,0 +1,3 @@
+import type { GetTooltipDataArgs, GetTooltipDataResult } from '../../utils/tooltip-helpers';
+import type { PreparedHeatmapData } from './types';
+export declare function getTooltipData(args: GetTooltipDataArgs<PreparedHeatmapData>): GetTooltipDataResult;

package/dist/esm/core/shapes/heatmap/get-tooltip-data.js

@@ -0,0 +1,21 @@
+export function getTooltipData(args) {
+    var _a;
+    const { data, position } = args;
+    const [pointerX, pointerY] = position;
+    const closestPoint = (_a = data[0]) === null || _a === void 0 ? void 0 : _a.items.find((cell) => pointerX >= cell.x &&
+        pointerX <= cell.x + cell.width &&
+        pointerY >= cell.y &&
+        pointerY <= cell.y + cell.height);
+    if (!closestPoint) {
+        return { chunks: [] };
+    }
+    return {
+        chunks: [
+            {
+                data: closestPoint.data,
+                series: data[0].series,
+                closest: true,
+            },
+        ],
+    };
+}

package/dist/esm/core/shapes/line/get-tooltip-data.d.ts

@@ -0,0 +1,3 @@
+import type { GetTooltipDataArgs, GetTooltipDataResult } from '../../utils/tooltip-helpers';
+import type { PreparedLineData } from './types';
+export declare function getTooltipData(args: GetTooltipDataArgs<PreparedLineData>): GetTooltipDataResult;

package/dist/esm/core/shapes/line/get-tooltip-data.js

@@ -0,0 +1,18 @@
+export function getTooltipData(args) {
+    const { data } = args;
+    const xLookupPoints = data.reduce((acc, d) => {
+        for (const p of d.points) {
+            if (p.y !== null && p.x !== null && !p.hiddenInLine) {
+                acc.push({
+                    data: p.data,
+                    series: p.series,
+                    x: p.x,
+                    y0: p.y,
+                    y1: p.y,
+                });
+            }
+        }
+        return acc;
+    }, []);
+    return { chunks: [], xLookupPoints };
+}

package/dist/esm/core/shapes/pie/get-tooltip-data.d.ts

@@ -0,0 +1,3 @@
+import type { GetTooltipDataArgs, GetTooltipDataResult } from '../../utils/tooltip-helpers';
+import type { PreparedPieData } from './types';
+export declare function getTooltipData(args: GetTooltipDataArgs<PreparedPieData>): GetTooltipDataResult;

package/dist/esm/core/shapes/pie/get-tooltip-data.js

@@ -0,0 +1,27 @@
+import { getRadius } from '../../utils/tooltip-helpers';
+export function getTooltipData(args) {
+    const { data, position } = args;
+    const [pointerX, pointerY] = position;
+    const points = data.flatMap((d) => d.segments);
+    const closestPoint = points.find((p) => {
+        const { center } = p.data.pie;
+        const x = pointerX - center[0];
+        const y = pointerY - center[1];
+        let angle = Math.atan2(y, x) + 0.5 * Math.PI;
+        angle = angle < 0 ? Math.PI * 2 + angle : angle;
+        const polarRadius = getRadius({ center, pointer: [pointerX, pointerY] });
+        return angle >= p.startAngle && angle <= p.endAngle && polarRadius < p.data.radius;
+    });
+    if (!closestPoint) {
+        return { chunks: [] };
+    }
+    return {
+        chunks: [
+            {
+                data: closestPoint.data.series.data,
+                series: closestPoint.data.series,
+                closest: true,
+            },
+        ],
+    };
+}

package/dist/esm/core/shapes/radar/get-tooltip-data.d.ts

@@ -0,0 +1,3 @@
+import type { GetTooltipDataArgs, GetTooltipDataResult } from '../../utils/tooltip-helpers';
+import type { PreparedRadarData } from './types';
+export declare function getTooltipData(args: GetTooltipDataArgs<PreparedRadarData>): GetTooltipDataResult;

package/dist/esm/core/shapes/radar/get-tooltip-data.js

@@ -0,0 +1,35 @@
+import { Delaunay } from 'd3-delaunay';
+import { getRadius, isInsidePath } from '../../utils/tooltip-helpers';
+export function getTooltipData(args) {
+    const { data, position, boundsWidth, boundsHeight } = args;
+    const [pointerX, pointerY] = position;
+    const [radarData] = data;
+    if (!radarData) {
+        return { chunks: [] };
+    }
+    const radius = getRadius({ center: radarData.center, pointer: [pointerX, pointerY] });
+    if (radius > radarData.radius) {
+        return { chunks: [] };
+    }
+    const radarShapes = radarData.shapes.filter((shape) => isInsidePath({
+        path: shape.path,
+        point: [pointerX, pointerY],
+        width: boundsWidth,
+        height: boundsHeight,
+        strokeWidth: shape.borderWidth,
+    }));
+    const points = radarShapes.flatMap((shape) => shape.points);
+    const delaunay = Delaunay.from(points, (d) => d.position[0], (d) => d.position[1]);
+    const closestPoint = points[delaunay.find(pointerX, pointerY)];
+    if (!closestPoint) {
+        return { chunks: [] };
+    }
+    return {
+        chunks: radarData.shapes.map((shape) => ({
+            data: shape.points[closestPoint.index].data,
+            series: shape.series,
+            category: shape.series.categories[closestPoint.index],
+            closest: shape.series === closestPoint.series,
+        })),
+    };
+}

package/dist/esm/core/shapes/sankey/get-tooltip-data.d.ts

@@ -0,0 +1,3 @@
+import type { GetTooltipDataArgs, GetTooltipDataResult } from '../../utils/tooltip-helpers';
+import type { PreparedSankeyData } from './types';
+export declare function getTooltipData(args: GetTooltipDataArgs<PreparedSankeyData>): GetTooltipDataResult;

package/dist/esm/core/shapes/sankey/get-tooltip-data.js

@@ -0,0 +1,32 @@
+import { isInsidePath } from '../../utils/tooltip-helpers';
+export function getTooltipData(args) {
+    const { data, position, boundsWidth, boundsHeight } = args;
+    const [pointerX, pointerY] = position;
+    const [sankeyData] = data;
+    if (!sankeyData) {
+        return { chunks: [] };
+    }
+    const closestLink = sankeyData.links.find((d) => {
+        var _a;
+        return isInsidePath({
+            path: (_a = d.path) !== null && _a !== void 0 ? _a : '',
+            strokeWidth: d.strokeWidth,
+            point: [pointerX, pointerY],
+            width: boundsWidth,
+            height: boundsHeight,
+        });
+    });
+    if (!closestLink) {
+        return { chunks: [] };
+    }
+    return {
+        chunks: [
+            {
+                data: closestLink.source,
+                target: closestLink.target,
+                series: sankeyData.series,
+                closest: true,
+            },
+        ],
+    };
+}

package/dist/esm/core/shapes/scatter/get-tooltip-data.d.ts

@@ -0,0 +1,3 @@
+import type { GetTooltipDataArgs, GetTooltipDataResult } from '../../utils/tooltip-helpers';
+import type { PreparedScatterData } from './types';
+export declare function getTooltipData(args: GetTooltipDataArgs<PreparedScatterData>): GetTooltipDataResult;

package/dist/esm/core/shapes/scatter/get-tooltip-data.js

@@ -0,0 +1,19 @@
+import { Delaunay } from 'd3-delaunay';
+export function getTooltipData(args) {
+    const { data, position } = args;
+    const [pointerX, pointerY] = position;
+    const delaunay = Delaunay.from(data, (d) => d.point.x, (d) => d.point.y);
+    const closestPoint = data[delaunay.find(pointerX, pointerY)];
+    if (!closestPoint) {
+        return { chunks: [] };
+    }
+    return {
+        chunks: [
+            {
+                data: closestPoint.point.data,
+                series: closestPoint.point.series,
+                closest: true,
+            },
+        ],
+    };
+}