@dynatrace/strato-components 3.6.0 → 3.7.0

package/charts/xy-chart/providers/XYChartOverlayPerformanceProvider.js

@@ -23,45 +23,119 @@ module.exports = __toCommonJS(XYChartOverlayPerformanceProvider_exports);
 var import_jsx_runtime = require("react/jsx-runtime");
 var import_react = require("react");
 var import_XYChartOverlayPerformance_context = require("../context/XYChartOverlayPerformance.context.js");
-var import_useBuildQuadtree = require("../hooks/useBuildQuadtree.js");
+var import_useAreaData = require("../hooks/useAreaData.js");
+var import_useBarData = require("../hooks/useBarData.js");
+var import_useBuildStrategy = require("../hooks/useBuildStrategy.js");
+var import_useDotData = require("../hooks/useDotData.js");
+var import_useLineData = require("../hooks/useLineData.js");
 var import_useXYChartData = require("../hooks/useXYChartData.js");
 var import_useXYChartScales = require("../hooks/useXYChartScales.js");
+var import_useXYChartTooltip = require("../hooks/useXYChartTooltip.js");
+var import_build_sorted_entries = require("../utils/build-sorted-entries.js");
 var import_query_closest_quadtree = require("../utils/query-closest-quadtree.js");
 var import_query_get_closest_point = require("../utils/query-get-closest-point.js");
 var import_query_hovered = require("../utils/query-hovered.js");
+var import_query_shared = require("../utils/query-shared.js");
+var import_query_single = require("../utils/query-single.js");
 const XYChartOverlayPerformanceProvider = ({
   children
 }) => {
   const axisIdToScales = (0, import_useXYChartScales.useXYChartScales)();
   const { datapointMetadataMap, axisIdToScaleDomain, seriesToMetadata } = (0, import_useXYChartData.useXYChartData)();
-  const seriesIdToTree = (0, import_useBuildQuadtree.useBuildQuadtree)();
-  const contextValue = (0, import_react.useMemo)(() => {
-    const queryClosest = seriesIdToTree ? (0, import_query_closest_quadtree.buildQueryClosest)(
-      seriesIdToTree,
+  const { variant } = (0, import_useXYChartTooltip.useXYChartTooltip)();
+  const isSharedVariant = variant === "shared";
+  const { filteredSeriesWithDatapoints: barSeriesData } = (0, import_useBarData.useBarData)();
+  const { filteredSeriesWithDatapoints: dotSeriesData } = (0, import_useDotData.useDotData)();
+  const { filteredSeriesWithDatapoints: lineSeriesData } = (0, import_useLineData.useLineData)();
+  const { filteredSeriesWithDatapoints: areaSeriesData } = (0, import_useAreaData.useAreaData)();
+  const getBarPixelCenter = (0, import_react.useMemo)(
+    () => (0, import_build_sorted_entries.buildGetBarPixelCenter)(
       axisIdToScales,
       seriesToMetadata,
       axisIdToScaleDomain,
       datapointMetadataMap
-    ) : (0, import_query_get_closest_point.buildQueryGetClosestPoint)(
+    ),
+    [
       axisIdToScales,
       seriesToMetadata,
+      axisIdToScaleDomain,
+      datapointMetadataMap
+    ]
+  );
+  const build = (0, import_react.useCallback)(
+    () => isSharedVariant ? (0, import_build_sorted_entries.buildSortedEntries)(
+      barSeriesData,
+      datapointMetadataMap,
+      getBarPixelCenter
+    ) : (0, import_query_closest_quadtree.buildQuadtrees)(
+      [...dotSeriesData, ...lineSeriesData, ...areaSeriesData],
+      axisIdToScales,
       datapointMetadataMap,
+      seriesToMetadata,
       axisIdToScaleDomain
-    );
+    ),
+    [
+      isSharedVariant,
+      barSeriesData,
+      datapointMetadataMap,
+      getBarPixelCenter,
+      dotSeriesData,
+      lineSeriesData,
+      areaSeriesData,
+      axisIdToScales,
+      seriesToMetadata,
+      axisIdToScaleDomain
+    ]
+  );
+  const buildResult = (0, import_useBuildStrategy.useBuildStrategy)(build);
+  const sortedEntries = isSharedVariant ? buildResult : void 0;
+  const seriesIdToTree = isSharedVariant ? void 0 : buildResult;
+  const context = (0, import_react.useMemo)(() => {
+    if (isSharedVariant) {
+      const queryAllHovered = (0, import_query_hovered.buildQueryAllHovered)(
+        axisIdToScales,
+        datapointMetadataMap,
+        seriesToMetadata,
+        axisIdToScaleDomain
+      );
+      return {
+        query: (0, import_query_shared.buildQueryShared)(
+          sortedEntries,
+          queryAllHovered,
+          getBarPixelCenter,
+          datapointMetadataMap
+        )
+      };
+    }
     const queryHovered = (0, import_query_hovered.buildQueryHovered)(
       axisIdToScales,
       datapointMetadataMap,
       seriesToMetadata,
       axisIdToScaleDomain
     );
-    return { queryClosest, queryHovered };
+    const queryClosest = seriesIdToTree ? (0, import_query_closest_quadtree.buildQueryClosest)(
+      seriesIdToTree,
+      axisIdToScales,
+      seriesToMetadata,
+      axisIdToScaleDomain,
+      datapointMetadataMap
+    ) : (0, import_query_get_closest_point.buildQueryGetClosestPoint)(
+      axisIdToScales,
+      seriesToMetadata,
+      datapointMetadataMap,
+      axisIdToScaleDomain
+    );
+    return { query: (0, import_query_single.buildQuerySingle)(queryClosest, queryHovered) };
   }, [
-    seriesIdToTree,
     axisIdToScales,
+    datapointMetadataMap,
     seriesToMetadata,
     axisIdToScaleDomain,
-    datapointMetadataMap
+    isSharedVariant,
+    sortedEntries,
+    getBarPixelCenter,
+    seriesIdToTree
   ]);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_XYChartOverlayPerformance_context.XYChartOverlayPerformanceContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_XYChartOverlayPerformance_context.XYChartOverlayPerformanceContext.Provider, { value: context, children });
 };
 XYChartOverlayPerformanceProvider.displayName = "XYChartOverlayPerformanceProvider";

package/charts/xy-chart/types/state.d.ts

@@ -2,6 +2,7 @@ import type { AREA_VARIANT, AreaSeriesWithDatapoints, AxisIdToCurrentScaleDomain
 import type { AreaDatapoint, BarDatapoint, DotDatapoint, LineDatapoint } from './xy-chart.js';
 import type { AnnotationsIntegrationSelectionState } from '../../core/components/annotations/components/indicators/types.js';
 import type { ExploreState, InteractionState } from '../../core/components/interactions-state-helpers/types.js';
+import type { SeriesQueryResult } from '../context/XYChartOverlayPerformance.context.js';
 export type RectSeriesContent = {
     datapoint: RectDatapointInternal;
     series: RectSeriesWithDatapoints;
@@ -33,6 +34,10 @@ export declare const UndefinedContent: {
     readonly type: "undefined";
 };
 export type TooltipContent = BarSeriesContent | RectSeriesContent | DotSeriesContent | LineSeriesContent | AreaSeriesContent;
+export type XYChartTooltipMetadata = {
+    preferred: TooltipContent;
+    datapoints: SeriesQueryResult[];
+};
 export type XYChartExploreState = {
     content: TooltipContent | typeof UndefinedContent;
 } & ExploreState;

package/charts/xy-chart/types/xy-chart-internals.d.ts

@@ -16,7 +16,7 @@ import type { ZoomChangeHandler } from '../../core/types/interactions.js';
 import type { MinMax } from '../../core/types/min-max.js';
 import { SeriesActionsTemplate } from '../../core/types/series-actions-template.js';
 import { XYChartAnnotationsConfigProps } from '../context/XYChartAnnotationsConfig.context.js';
-import { XYChartCustomTooltipConfig } from '../context/XYChartCustomTooltip.context.js';
+import { XYChartTooltipConfig } from '../context/XYChartTooltip.context.js';
 /**
  * Type for the validator function returned by buildValidator(VALUE_MATCHERS)
  */
@@ -155,7 +155,7 @@ export interface XYChartSlots {
     annotations?: XYChartAnnotationsConfigProps;
     select?: XYChartSelectConfig;
     colorRules?: ColorRuleProps[];
-    tooltip: XYChartCustomTooltipConfig | undefined;
+    tooltip: XYChartTooltipConfig | undefined;
 }
 export interface XYChartInternals {
     series: XYChartSlots['series'];

package/charts/xy-chart/types/xy-chart-props.d.ts

@@ -596,6 +596,13 @@ export type XYChartCustomTooltipProps = {
      */
     children?: (tooltipPayload: XYChartTooltipPayload) => ReactNode;
 };
+/**
+ * Controls whether the tooltip groups multiple datapoints at the same x-axis position.
+ * - `'single'` (default): shows one datapoint at a time.
+ * - `'shared'`: groups all bar datapoints sharing the same x-position into one tooltip.
+ * @internal
+ */
+export type _XYChartTooltipVariant = 'single' | 'shared';
 /**
  * Props for the XYChart.Tooltip slot component
  * @public
@@ -608,6 +615,13 @@ export type XYChartTooltipProps = {
      * `null` to hide the tooltip, or `undefined` to fall back to the default tooltip.
      */
     children?: (tooltipPayload: XYChartTooltipPayload) => ReactNode;
+    /**
+     * Controls whether the tooltip displays a single datapoint or groups all bar datapoints
+     * at the same x-axis position.
+     * @defaultValue 'single'
+     * @internal
+     */
+    _variant?: _XYChartTooltipVariant;
 };
 /**
  * Props for the XYChart.Legend slot component

package/charts/xy-chart/utils/build-sorted-entries.d.ts

@@ -0,0 +1,53 @@
+import type { BarSeriesQueryResult } from '../context/XYChartOverlayPerformance.context.js';
+import type { AxisIdToScales } from '../context/XYChartScales.context.js';
+import type { AxisIdToScaleDomain, BarSeriesWithDatapoints, MapDatapoints, SeriesToMetadata } from '../types/xy-chart-internals.js';
+import type { BarDatapoint } from '../types/xy-chart.js';
+export type BarSortedEntry = {
+    xPixel: number;
+    yPixel: number;
+    /**
+     * Stable cluster identifier built from the datapoint's x-domain
+     * (`x0-x1`). Bars sharing the same `boundaries` belong to the same
+     * stack / same start-end domain group.
+     */
+    boundaries: string;
+    result: BarSeriesQueryResult;
+};
+/**
+ * Sorted-entry buckets keyed by shape. Only `bar` is populated today;
+ * follow-up stories add other shapes (rect, dot, line, area).
+ *
+ * Selection state in the shared tooltip is expected to be tracked per
+ * shape, so the underlying data structure separates entries by shape
+ * even when only one is in use.
+ */
+export type SortedEntriesPerShape = {
+    bar: BarSortedEntry[];
+};
+export type BarPixelCenter = {
+    xPixel: number;
+    yPixel: number;
+    boundaries: string;
+};
+/**
+ * Maps a (series, datapoint) pair to its bar's pixel center and
+ * stack/cluster boundary. Used to anchor cluster lookups around the
+ * hovered bar's exact pixel position instead of the cursor's.
+ */
+export type GetBarPixelCenter = (series: BarSeriesWithDatapoints, datapoint: BarDatapoint) => BarPixelCenter;
+/**
+ * Build a per-series-cached `GetBarPixelCenter`. Accessor construction
+ * is non-trivial, so we memoize per series id to keep tight loops fast.
+ */
+export declare function buildGetBarPixelCenter(axisIdToScales: AxisIdToScales, seriesToMetadata: SeriesToMetadata, axisIdToScaleDomain: AxisIdToScaleDomain, datapointMetadataMap: MapDatapoints): GetBarPixelCenter;
+/**
+ * Build the per-shape sorted entries used by the shared tooltip query.
+ *
+ * Only bar series are processed. Each bar datapoint becomes one entry
+ * positioned at the bar's pixel center, with a `boundaries` key that
+ * groups bars sharing the same `x0-x1` (stacks and start-end clusters).
+ *
+ * Entries are returned sorted ascending by `xPixel` so callers can run a
+ * binary search by x-position.
+ */
+export declare function buildSortedEntries(barSeries: BarSeriesWithDatapoints[], datapointMetadataMap: MapDatapoints, getBarPixelCenter: GetBarPixelCenter): SortedEntriesPerShape;

package/charts/xy-chart/utils/build-sorted-entries.js

@@ -0,0 +1,81 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var build_sorted_entries_exports = {};
+__export(build_sorted_entries_exports, {
+  buildGetBarPixelCenter: () => buildGetBarPixelCenter,
+  buildSortedEntries: () => buildSortedEntries
+});
+module.exports = __toCommonJS(build_sorted_entries_exports);
+var import_query_hovered = require("./query-hovered.js");
+var import_value_representation = require("./value-representation.js");
+var import_safe_get = require("../../core/utils/safe-get.js");
+function buildGetBarPixelCenter(axisIdToScales, seriesToMetadata, axisIdToScaleDomain, datapointMetadataMap) {
+  const accessorsBySeries = /* @__PURE__ */ new Map();
+  return (series, datapoint) => {
+    let accessors = accessorsBySeries.get(series.id);
+    if (!accessors) {
+      const metadata = (0, import_safe_get.safeGet)(seriesToMetadata, series);
+      const xRelAccessor = (0, import_value_representation.relAccessor)(metadata.xAxis, axisIdToScaleDomain);
+      const yRelAccessor = (0, import_value_representation.relAccessor)(metadata.yAxis, axisIdToScaleDomain);
+      accessors = (0, import_query_hovered.getAccessors)(
+        series,
+        axisIdToScales,
+        datapointMetadataMap,
+        xRelAccessor,
+        yRelAccessor
+      );
+      accessorsBySeries.set(series.id, accessors);
+    }
+    const { x, y, width, height } = (0, import_query_hovered.getPixelDimensionsForDatapoint)(
+      datapoint,
+      accessors
+    );
+    return {
+      xPixel: x + width / 2,
+      yPixel: y + height / 2,
+      boundaries: `${String(datapoint.x0)}-${String(datapoint.x1)}`
+    };
+  };
+}
+function buildSortedEntries(barSeries, datapointMetadataMap, getBarPixelCenter) {
+  const bar = [];
+  for (const series of barSeries) {
+    for (const datapoint of series.data) {
+      if ((0, import_safe_get.safeGet)(datapointMetadataMap, datapoint).isGap) {
+        continue;
+      }
+      const { xPixel, yPixel, boundaries } = getBarPixelCenter(
+        series,
+        datapoint
+      );
+      bar.push({
+        xPixel,
+        yPixel,
+        boundaries,
+        result: {
+          type: series.type,
+          distance: 0,
+          datapoint,
+          series
+        }
+      });
+    }
+  }
+  bar.sort((a, b) => a.xPixel - b.xPixel);
+  return { bar };
+}

package/charts/xy-chart/utils/calculate-axes-domains.js

@@ -26,14 +26,26 @@ function getMinMax(axisId, coordinate0, coordinate1, axisIdToScaleDomain) {
     min: coordinate0,
     max: coordinate1
   };
-  const minValues = [minMax.min, coordinate0, coordinate1].filter(
-    (value) => value !== void 0
-  );
-  const maxValues = [minMax.max, coordinate0, coordinate1].filter(
-    (value) => value !== void 0
-  );
-  minMax.min = Math.min(...minValues);
-  minMax.max = Math.max(...maxValues);
+  let min = minMax.min;
+  let max = minMax.max;
+  if (coordinate0 !== void 0) {
+    if (min === void 0 || coordinate0 < min) {
+      min = coordinate0;
+    }
+    if (max === void 0 || coordinate0 > max) {
+      max = coordinate0;
+    }
+  }
+  if (coordinate1 !== void 0) {
+    if (min === void 0 || coordinate1 < min) {
+      min = coordinate1;
+    }
+    if (max === void 0 || coordinate1 > max) {
+      max = coordinate1;
+    }
+  }
+  minMax.min = min;
+  minMax.max = max;
   return minMax;
 }
 function getCategoricalDomain(axisId, v0, v1, axisIdToScaleDomain) {
@@ -47,51 +59,41 @@ function getCategoricalDomain(axisId, v0, v1, axisIdToScaleDomain) {
   return categoricalSet;
 }
 const calculateAxesDomainsMap = {
-  [import_axis.XYAxisTypeLinear]: (args) => {
-    return getMinMax(
-      args.axisId,
-      args.a0,
-      args.a1,
-      args.axisIdToScaleDomain
-    );
+  [import_axis.XYAxisTypeLinear]: (axisId, a0, a1, axisIdToScaleDomain) => {
+    return getMinMax(axisId, a0, a1, axisIdToScaleDomain);
   },
-  [import_axis.XYAxisTypeLog]: (args) => {
-    return getMinMax(
-      args.axisId,
-      args.a0,
-      args.a1,
-      args.axisIdToScaleDomain
-    );
+  [import_axis.XYAxisTypeLog]: (axisId, a0, a1, axisIdToScaleDomain) => {
+    return getMinMax(axisId, a0, a1, axisIdToScaleDomain);
   },
-  [import_axis.XYAxisTypeCategorical]: (args) => {
+  [import_axis.XYAxisTypeCategorical]: (axisId, a0, a1, axisIdToScaleDomain) => {
     return getCategoricalDomain(
-      args.axisId,
-      args.a0,
-      args.a1,
-      args.axisIdToScaleDomain
+      axisId,
+      a0,
+      a1,
+      axisIdToScaleDomain
     );
   },
-  [import_axis.XYAxisTypeTime]: (args) => {
+  [import_axis.XYAxisTypeTime]: (axisId, a0, a1, axisIdToScaleDomain) => {
     return getMinMax(
-      args.axisId,
-      args.a0?.valueOf(),
-      args.a1?.valueOf(),
-      args.axisIdToScaleDomain
+      axisId,
+      a0?.valueOf(),
+      a1?.valueOf(),
+      axisIdToScaleDomain
     );
   }
 };
 function calculateAxesDomains(xAxis, yAxis, datapoint, axisIdToScaleDomain, isSeriesVisible) {
-  const xDomain = calculateAxesDomainsMap[xAxis.type]({
-    axisId: xAxis.id,
-    a0: datapoint.x0,
-    a1: datapoint.x1,
+  const xDomain = calculateAxesDomainsMap[xAxis.type](
+    xAxis.id,
+    datapoint.x0,
+    datapoint.x1,
     axisIdToScaleDomain
-  });
-  const yDomain = isSeriesVisible || yAxis.type === import_axis.XYAxisTypeCategorical ? calculateAxesDomainsMap[yAxis.type]({
-    axisId: yAxis.id,
-    a0: datapoint.y0,
-    a1: datapoint.y1,
+  );
+  const yDomain = isSeriesVisible || yAxis.type === import_axis.XYAxisTypeCategorical ? calculateAxesDomainsMap[yAxis.type](
+    yAxis.id,
+    datapoint.y0,
+    datapoint.y1,
     axisIdToScaleDomain
-  }) : axisIdToScaleDomain.get(yAxis.id) ?? {};
+  ) : axisIdToScaleDomain.get(yAxis.id) ?? {};
   return { xDomain, yDomain };
 }

package/charts/xy-chart/utils/iterate-slots.js

@@ -110,12 +110,14 @@ const iterateSlots = (children) => {
     } else if ((0, import_is_slot.isSlot)(child, import_CustomTooltip.CustomTooltip)) {
       slots.tooltip = {
         hidden: false,
-        template: child.props.children
+        template: child.props.children,
+        variant: "single"
       };
     } else if ((0, import_is_slot.isSlot)(child, import_Tooltip.XYChartTooltipSlot)) {
       slots.tooltip = {
         hidden: child.props.hidden ?? false,
-        template: child.props.children
+        template: child.props.children,
+        variant: child.props._variant ?? "single"
       };
     }
   });

package/charts/xy-chart/utils/query-closest-quadtree.d.ts

@@ -14,9 +14,6 @@ import { type AnyLinearSeries, type AreaSeriesWithDatapoints, type AxisIdToScale
  * @returns Map from series id to its quadtree.
  */
 export declare function buildQuadtrees(seriesWithDatapoints: AnyLinearSeries[], axisIdToScales: AxisIdToScales, datapointToMetadata: MapDatapoints, seriesToMetadata: SeriesToMetadata, axisIdToScaleDomain: AxisIdToScaleDomain): SeriesToQuadtree;
-type DebouncedQuadtrees = (seriesWithDatapoints: AnyLinearSeries[], axisIdToScales: AxisIdToScales, datapointsMetadata: MapDatapoints, seriesToMetadata: SeriesToMetadata, axisIdToScaleDomain: AxisIdToScaleDomain, onDone: (trees: SeriesToQuadtree) => void) => void;
-export declare function getDebouncedQuadtrees(key: string): DebouncedQuadtrees;
-export declare function cancelDebouncedQuadtrees(key: string): void;
 /**
  * Euclidean distance between two (x,y) points.
  *
@@ -41,4 +38,3 @@ export declare function buildQueryClosest(seriesIdToQuadtree: SeriesToQuadtree,
     (arrayOfSeries: LineSeriesWithDatapoints[], position: Point): LineSeriesQueryResult | undefined;
     (arrayOfSeries: AreaSeriesWithDatapoints[], position: Point): AreaSeriesQueryResult | undefined;
 };
-export {};

package/charts/xy-chart/utils/query-closest-quadtree.js

@@ -19,13 +19,10 @@ var query_closest_quadtree_exports = {};
 __export(query_closest_quadtree_exports, {
   buildQuadtrees: () => buildQuadtrees,
   buildQueryClosest: () => buildQueryClosest,
-  cancelDebouncedQuadtrees: () => cancelDebouncedQuadtrees,
-  distanceBetweenTwoPoints: () => distanceBetweenTwoPoints,
-  getDebouncedQuadtrees: () => getDebouncedQuadtrees
+  distanceBetweenTwoPoints: () => distanceBetweenTwoPoints
 });
 module.exports = __toCommonJS(query_closest_quadtree_exports);
 var import_d3_quadtree = require("d3-quadtree");
-var import_lodash_es = require("lodash");
 var import_get_linear_accessors = require("./get-linear-accessors.js");
 var import_get_scale = require("./get-scale.js");
 var import_value_representation = require("./value-representation.js");
@@ -98,30 +95,6 @@ function buildQuadtrees(seriesWithDatapoints, axisIdToScales, datapointToMetadat
   }
   return seriesToTrees;
 }
-const DELAY = 300;
-const debounceMap = /* @__PURE__ */ new Map();
-function getDebouncedQuadtrees(key) {
-  let debounced = debounceMap.get(key);
-  if (!debounced) {
-    debounced = (0, import_lodash_es.debounce)(
-      (series, scales, metadata, seriesToMetadata, axisIdToScaleDomain, onDone) => onDone(
-        buildQuadtrees(
-          series,
-          scales,
-          metadata,
-          seriesToMetadata,
-          axisIdToScaleDomain
-        )
-      ),
-      DELAY
-    );
-    debounceMap.set(key, debounced);
-  }
-  return debounced;
-}
-function cancelDebouncedQuadtrees(key) {
-  debounceMap.get(key)?.cancel?.();
-}
 function distanceBetweenTwoPoints(x0, x1, y0, y1) {
   return Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2));
 }

package/charts/xy-chart/utils/query-hovered.d.ts

@@ -1,5 +1,5 @@
 import type { Point } from '../../core/types/point.js';
-import type { BarSeriesQueryResult, RectSeriesQueryResult } from '../context/XYChartOverlayPerformance.context.js';
+import type { BarSeriesQueryResult, RectSeriesQueryResult, SeriesQueryResult } from '../context/XYChartOverlayPerformance.context.js';
 import type { AxisIdToScales } from '../context/XYChartScales.context.js';
 import { type AxisIdToScaleDomain, type BarSeriesWithDatapoints, type RectDatapointInternal, type RectSeriesWithDatapoints, type SeriesToMetadata, type MapDatapoints } from '../types/xy-chart-internals.js';
 import type { BarDatapoint } from '../types/xy-chart.js';
@@ -15,6 +15,17 @@ interface BarAccessors {
     widthAccessor: (datapoint: BarDatapoint) => number;
     heightAccessor: (datapoint: BarDatapoint) => number;
 }
+export declare function getAccessors(series: RectSeriesWithDatapoints | BarSeriesWithDatapoints, axisIdToScales: AxisIdToScales, datapointMetadataMap: MapDatapoints, xRelAccessor?: (d: number) => number, yRelAccessor?: (d: number) => number): {
+    xAccessor: (datapoint: RectDatapointInternal) => number;
+    yAccessor: (datapoint: RectDatapointInternal) => number;
+    widthAccessor: (datapoint: RectDatapointInternal) => number;
+    heightAccessor: (datapoint: RectDatapointInternal) => number;
+} | {
+    xAccessor: (datapoint: BarDatapoint) => number;
+    yAccessor: (datapoint: BarDatapoint) => number;
+    widthAccessor: (datapoint: BarDatapoint) => number;
+    heightAccessor: (datapoint: BarDatapoint) => number;
+};
 export declare const getPixelDimensionsForDatapoint: (datapoint: RectDatapointInternal | BarDatapoint, genAccessors: RectAccessors | BarAccessors) => {
     x: number;
     y: number;
@@ -29,4 +40,6 @@ export declare function buildQueryHovered(axisIdToScales: AxisIdToScales, datapo
     (arrayOfSeries: RectSeriesWithDatapoints[], position: Point): RectSeriesQueryResult | undefined;
     (arrayOfSeries: BarSeriesWithDatapoints[], position: Point): BarSeriesQueryResult | undefined;
 };
+export type QueryAllHovered = (arrayOfSeries: (RectSeriesWithDatapoints | BarSeriesWithDatapoints)[], position: Point) => SeriesQueryResult[];
+export declare function buildQueryAllHovered(axisIdToScales: AxisIdToScales, datapointMetadataMap: MapDatapoints, seriesToMetadata: SeriesToMetadata, axisIdToScaleDomain: AxisIdToScaleDomain): QueryAllHovered;
 export {};

package/charts/xy-chart/utils/query-hovered.js

@@ -17,7 +17,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var query_hovered_exports = {};
 __export(query_hovered_exports, {
+  buildQueryAllHovered: () => buildQueryAllHovered,
   buildQueryHovered: () => buildQueryHovered,
+  getAccessors: () => getAccessors,
   getHoveredDatapoint: () => getHoveredDatapoint,
   getPixelDimensionsForDatapoint: () => getPixelDimensionsForDatapoint
 });
@@ -148,3 +150,27 @@ function buildQueryHovered(axisIdToScales, datapointMetadataMap, seriesToMetadat
   }
   return query;
 }
+function buildQueryAllHovered(axisIdToScales, datapointMetadataMap, seriesToMetadata, axisIdToScaleDomain) {
+  return (arrayOfSeries, position) => {
+    const results = [];
+    for (const series of arrayOfSeries) {
+      const datapoint = getHoveredDatapoint(
+        position,
+        series,
+        axisIdToScales,
+        datapointMetadataMap,
+        seriesToMetadata,
+        axisIdToScaleDomain
+      );
+      if (datapoint) {
+        results.push({
+          type: series.type,
+          distance: 0,
+          datapoint,
+          series
+        });
+      }
+    }
+    return results;
+  };
+}

package/charts/xy-chart/utils/query-shared.d.ts

@@ -0,0 +1,5 @@
+import type { GetBarPixelCenter, SortedEntriesPerShape } from './build-sorted-entries.js';
+import type { QueryAllHovered } from './query-hovered.js';
+import type { HoverQuery } from '../context/XYChartOverlayPerformance.context.js';
+import type { MapDatapoints } from '../types/xy-chart-internals.js';
+export declare function buildQueryShared(sortedEntries: SortedEntriesPerShape | undefined, queryAllHovered: QueryAllHovered, getBarPixelCenter: GetBarPixelCenter, datapointMetadataMap: MapDatapoints): HoverQuery;