@mui/x-charts 8.14.0 → 8.14.1

package/esm/internals/plugins/featurePlugins/useChartCartesianAxis/useChartCartesianAxisRendering.selectors.js

@@ -1,4 +1,5 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
+import { isDeepEqual } from '@mui/x-internals/isDeepEqual';
 import { selectorChartDrawingArea } from "../../corePlugins/useChartDimensions/index.js";
 import { selectorChartSeriesConfig, selectorChartSeriesProcessed } from "../../corePlugins/useChartSeries/index.js";
 import { createSelector } from "../../utils/selectors.js";
@@ -14,6 +15,7 @@ import { isOrdinalScale } from "../../../scaleGuards.js";
 import { zoomScaleRange } from "./zoom.js";
 import { getAxisExtrema } from "./getAxisExtrema.js";
 import { calculateFinalDomain, calculateInitialDomainAndTickNumber } from "./domain.js";
+import { Flatbush } from "../../../Flatbush.js";
 export const createZoomMap = zoom => {
   const zoomItemMap = new Map();
   zoom.forEach(zoomItem => {
@@ -29,6 +31,7 @@ const selectorChartZoomState = state => state.zoom;
 
 export const selectorChartZoomIsInteracting = createSelector([selectorChartZoomState], zoom => zoom?.isInteracting);
 export const selectorChartZoomMap = createSelector([selectorChartZoomState], zoom => zoom?.zoomData && createZoomMap(zoom?.zoomData));
+export const selectorChartAxisZoomData = createSelector([selectorChartZoomMap, (_, axisId) => axisId], (zoomMap, axisId) => zoomMap?.get(axisId));
 export const selectorChartZoomOptionsLookup = createSelector([selectorChartRawXAxis, selectorChartRawYAxis], (xAxis, yAxis) => _extends({}, createZoomLookup('x')(xAxis), createZoomLookup('y')(yAxis)));
 export const selectorChartAxisZoomOptionsLookup = createSelector([selectorChartZoomOptionsLookup, (_, axisId) => axisId], (axisLookup, axisId) => axisLookup[axisId]);
 export const selectorDefaultXAxisTickNumber = createSelector([selectorChartDrawingArea], function selectorDefaultXAxisTickNumber(drawingArea) {
@@ -125,6 +128,10 @@ export const selectorChartFilteredXDomains = createSelector([selectorChartRawXAx
     filteredDomains[axis.id] = calculateFinalDomain(axis, 'x', axisIndex, formattedSeries, axisExtrema, rawTickNumber, preferStrictDomainInLineCharts);
   });
   return filteredDomains;
+}, {
+  memoizeOptions: {
+    resultEqualityCheck: (a, b) => isDeepEqual(a, b)
+  }
 });
 export const selectorChartFilteredYDomains = createSelector([selectorChartRawYAxis, selectorChartSeriesProcessed, selectorChartSeriesConfig, selectorChartZoomMap, selectorChartZoomOptionsLookup, selectorChartZoomAxisFilters, selectorPreferStrictDomainInLineCharts, selectorChartYDomains], (axes, formattedSeries, seriesConfig, zoomMap, zoomOptions, getFilters, preferStrictDomainInLineCharts, domains) => {
   const filteredDomains = {};
@@ -147,6 +154,10 @@ export const selectorChartFilteredYDomains = createSelector([selectorChartRawYAx
     filteredDomains[axis.id] = calculateFinalDomain(axis, 'y', axisIndex, formattedSeries, axisExtrema, rawTickNumber, preferStrictDomainInLineCharts);
   });
   return filteredDomains;
+}, {
+  memoizeOptions: {
+    resultEqualityCheck: (a, b) => isDeepEqual(a, b)
+  }
 });
 export const selectorChartNormalizedXScales = createSelector([selectorChartRawXAxis, selectorChartFilteredXDomains], function selectorChartNormalizedXScales(axes, filteredDomains) {
   const scales = {};
@@ -227,4 +238,34 @@ export const selectorChartRawAxis = createSelector([selectorChartRawXAxis, selec
     return undefined;
   }
   return axis;
+});
+export const selectorChartDefaultXAxisId = createSelector([selectorChartRawXAxis], xAxes => xAxes[0].id);
+export const selectorChartDefaultYAxisId = createSelector([selectorChartRawYAxis], yAxes => yAxes[0].id);
+const EMPTY_MAP = new Map();
+export const selectorChartSeriesEmptyFlatbushMap = () => EMPTY_MAP;
+export const selectorChartSeriesFlatbushMap = createSelector([selectorChartSeriesProcessed, selectorChartNormalizedXScales, selectorChartNormalizedYScales, selectorChartDefaultXAxisId, selectorChartDefaultYAxisId], function selectChartSeriesFlatbushMap(allSeries, xAxesScaleMap, yAxesScaleMap, defaultXAxisId, defaultYAxisId) {
+  // FIXME: Do we want to support non-scatter series here?
+  const validSeries = allSeries.scatter;
+  const flatbushMap = new Map();
+  if (!validSeries) {
+    return flatbushMap;
+  }
+  validSeries.seriesOrder.forEach(seriesId => {
+    const {
+      data,
+      xAxisId = defaultXAxisId,
+      yAxisId = defaultYAxisId
+    } = validSeries.series[seriesId];
+    const flatbush = new Flatbush(data.length);
+    const originalXScale = xAxesScaleMap[xAxisId];
+    const originalYScale = yAxesScaleMap[yAxisId];
+    for (const datum of data) {
+      // Add the points using a [0, 1] range so that we don't need to recreate the Flatbush structure when zooming.
+      // This doesn't happen in practice, though, because currently the scales depend on the drawing area.
+      flatbush.add(originalXScale(datum.x), originalYScale(datum.y));
+    }
+    flatbush.finish();
+    flatbushMap.set(seriesId, flatbush);
+  });
+  return flatbushMap;
 });

package/esm/internals/plugins/featurePlugins/useChartCartesianAxis/useChartCartesianInteraction.selectors.js

@@ -34,7 +34,10 @@ export const selectorChartAxisInteraction = createSelector([selectorChartsIntera
  */
 
 function valueGetter(value, axes, indexes, ids = axes.axisIds[0]) {
-  return Array.isArray(ids) ? ids.map((id, axisIndex) => getAxisValue(axes.axis[id], value, indexes[axisIndex])) : getAxisValue(axes.axis[ids], value, indexes);
+  return Array.isArray(ids) ? ids.map((id, axisIndex) => {
+    const axis = axes.axis[id];
+    return getAxisValue(axis.scale, axis.data, value, indexes[axisIndex]);
+  }) : getAxisValue(axes.axis[ids].scale, axes.axis[ids].data, value, indexes);
 }
 export const selectorChartsInteractionXAxisValue = createSelector([selectorChartsInteractionPointerX, selectorChartXAxis, selectorChartsInteractionXAxisIndex, optionalGetAxisId], (x, xAxes, xIndex, id) => {
   if (x === null || xAxes.axisIds.length === 0) {

package/esm/internals/plugins/featurePlugins/useChartClosestPoint/findClosestPoints.d.ts

@@ -0,0 +1,5 @@
+import { ChartDrawingArea } from "../../../../hooks/useDrawingArea.js";
+import { ScatterValueType } from "../../../../models/seriesType/scatter.js";
+import { Flatbush } from "../../../Flatbush.js";
+import { D3Scale } from "../../../../models/axis.js";
+export declare function findClosestPoints(flatbush: Flatbush, drawingArea: Pick<ChartDrawingArea, 'top' | 'left' | 'width' | 'height'>, seriesData: readonly ScatterValueType[], xScale: D3Scale, yScale: D3Scale, xZoomStart: number, xZoomEnd: number, yZoomStart: number, yZoomEnd: number, svgPointX: number, svgPointY: number, maxRadius?: number, maxResults?: number): number[];

package/esm/internals/plugins/featurePlugins/useChartClosestPoint/findClosestPoints.js

@@ -0,0 +1,33 @@
+import { isOrdinalScale } from "../../../scaleGuards.js";
+export function findClosestPoints(flatbush, drawingArea, seriesData, xScale, yScale, xZoomStart, xZoomEnd, yZoomStart, yZoomEnd, svgPointX, svgPointY, maxRadius = Infinity, maxResults = 1) {
+  const originalXScale = xScale.copy();
+  const originalYScale = yScale.copy();
+  originalXScale.range([0, 1]);
+  originalYScale.range([0, 1]);
+  const excludeIfOutsideDrawingArea = function excludeIfOutsideDrawingArea(index) {
+    const x = originalXScale(seriesData[index].x);
+    const y = originalYScale(seriesData[index].y);
+    return x >= xZoomStart && x <= xZoomEnd && y >= yZoomStart && y <= yZoomEnd;
+  };
+
+  // We need to convert the distance from the original range [0, 1] to the current drawing area
+  // so the comparison is done on pixels instead of normalized values.
+  // fx and fy are the factors to convert the distance from [0, 1] to the current drawing area.
+  const fx = xScale.range()[1] - xScale.range()[0];
+  const fy = yScale.range()[1] - yScale.range()[0];
+  const fxSq = fx * fx;
+  const fySq = fy * fy;
+  function sqDistFn(dx, dy) {
+    return fxSq * dx * dx + fySq * dy * dy;
+  }
+  const pointX = originalXScale(invertScale(xScale, svgPointX, dataIndex => seriesData[dataIndex].x));
+  const pointY = originalYScale(invertScale(yScale, svgPointY, dataIndex => seriesData[dataIndex].y));
+  return flatbush.neighbors(pointX, pointY, maxResults, maxRadius != null ? maxRadius * maxRadius : Infinity, excludeIfOutsideDrawingArea, sqDistFn);
+}
+function invertScale(scale, value, getDataPoint) {
+  if (isOrdinalScale(scale)) {
+    const dataIndex = scale.bandwidth() === 0 ? Math.floor((value - Math.min(...scale.range()) + scale.step() / 2) / scale.step()) : Math.floor((value - Math.min(...scale.range())) / scale.step());
+    return getDataPoint(dataIndex);
+  }
+  return scale.invert(value);
+}

package/esm/internals/plugins/featurePlugins/useChartClosestPoint/useChartClosestPoint.js

@@ -4,13 +4,12 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
 import useEventCallback from '@mui/utils/useEventCallback';
-import { Delaunay } from '@mui/x-charts-vendor/d3-delaunay';
-import { getValueToPositionMapper } from "../../../../hooks/useScale.js";
 import { getSVGPoint } from "../../../getSVGPoint.js";
 import { useSelector } from "../../../store/useSelector.js";
-import { selectorChartXAxis, selectorChartYAxis, selectorChartZoomIsInteracting } from "../useChartCartesianAxis/index.js";
+import { selectorChartAxisZoomData, selectorChartSeriesEmptyFlatbushMap, selectorChartSeriesFlatbushMap, selectorChartXAxis, selectorChartYAxis, selectorChartZoomIsInteracting } from "../useChartCartesianAxis/index.js";
 import { selectorChartSeriesProcessed } from "../../corePlugins/useChartSeries/useChartSeries.selectors.js";
 import { selectorChartDrawingArea } from "../../corePlugins/useChartDimensions/index.js";
+import { findClosestPoints } from "./findClosestPoints.js";
 export const useChartClosestPoint = ({
   svgRef,
   params,
@@ -36,9 +35,7 @@ export const useChartClosestPoint = ({
     series,
     seriesOrder
   } = useSelector(store, selectorChartSeriesProcessed)?.scatter ?? {};
-  const voronoiRef = React.useRef({});
-  const delauneyRef = React.useRef(undefined);
-  const lastFind = React.useRef(undefined);
+  const flatbushMap = useSelector(store, zoomIsInteracting ? selectorChartSeriesEmptyFlatbushMap : selectorChartSeriesFlatbushMap);
   const defaultXAxisId = xAxisIds[0];
   const defaultYAxisId = yAxisIds[0];
   useEnhancedEffect(() => {
@@ -48,52 +45,6 @@ export const useChartClosestPoint = ({
       }
     }));
   }, [store, disableVoronoi]);
-  useEnhancedEffect(() => {
-    // This effect generate and store the Delaunay object that's used to map coordinate to closest point.
-
-    if (zoomIsInteracting || seriesOrder === undefined || series === undefined || disableVoronoi) {
-      // If there is no scatter chart series
-      return;
-    }
-    voronoiRef.current = {};
-    let points = [];
-    seriesOrder.forEach(seriesId => {
-      const {
-        data,
-        xAxisId,
-        yAxisId
-      } = series[seriesId];
-      const xScale = xAxis[xAxisId ?? defaultXAxisId].scale;
-      const yScale = yAxis[yAxisId ?? defaultYAxisId].scale;
-      const getXPosition = getValueToPositionMapper(xScale);
-      const getYPosition = getValueToPositionMapper(yScale);
-      const seriesPoints = [];
-      const seriesIndexes = [];
-      for (let dataIndex = 0; dataIndex < data.length; dataIndex += 1) {
-        const {
-          x,
-          y
-        } = data[dataIndex];
-        const pointX = getXPosition(x);
-        const pointY = getYPosition(y);
-        if (instance.isPointInside(pointX, pointY)) {
-          seriesPoints.push(pointX);
-          seriesPoints.push(pointY);
-          seriesIndexes.push(dataIndex);
-        }
-      }
-      voronoiRef.current[seriesId] = {
-        seriesId,
-        seriesIndexes,
-        startIndex: points.length,
-        endIndex: points.length + seriesPoints.length,
-        markerSize: series[seriesId].markerSize
-      };
-      points = points.concat(seriesPoints);
-    });
-    delauneyRef.current = new Delaunay(points);
-    lastFind.current = undefined;
-  }, [zoomIsInteracting, defaultXAxisId, defaultYAxisId, series, seriesOrder, xAxis, yAxis, drawingArea, instance, disableVoronoi]);
   React.useEffect(() => {
     if (svgRef.current === null || disableVoronoi) {
       return undefined;
@@ -103,40 +54,48 @@ export const useChartClosestPoint = ({
       // Get mouse coordinate in global SVG space
       const svgPoint = getSVGPoint(element, event);
       if (!instance.isPointInside(svgPoint.x, svgPoint.y)) {
-        lastFind.current = undefined;
         return 'outside-chart';
       }
-      if (!delauneyRef.current) {
-        return 'no-point-found';
-      }
-      const closestPointIndex = delauneyRef.current.find(svgPoint.x, svgPoint.y, lastFind.current);
-      if (closestPointIndex === undefined) {
-        return 'no-point-found';
+      let closestPoint = undefined;
+      for (const seriesId of seriesOrder ?? []) {
+        const aSeries = (series ?? {})[seriesId];
+        const flatbush = flatbushMap.get(seriesId);
+        if (!flatbush) {
+          continue;
+        }
+        const xAxisId = aSeries.xAxisId ?? defaultXAxisId;
+        const yAxisId = aSeries.yAxisId ?? defaultYAxisId;
+        const xAxisZoom = selectorChartAxisZoomData(store.getSnapshot(), xAxisId);
+        const yAxisZoom = selectorChartAxisZoomData(store.getSnapshot(), yAxisId);
+        const maxRadius = voronoiMaxRadius === 'item' ? aSeries.markerSize : voronoiMaxRadius;
+        const xZoomStart = (xAxisZoom?.start ?? 0) / 100;
+        const xZoomEnd = (xAxisZoom?.end ?? 100) / 100;
+        const yZoomStart = (yAxisZoom?.start ?? 0) / 100;
+        const yZoomEnd = (yAxisZoom?.end ?? 100) / 100;
+        const xScale = xAxis[xAxisId].scale;
+        const yScale = yAxis[yAxisId].scale;
+        const closestPointIndex = findClosestPoints(flatbush, drawingArea, aSeries.data, xScale, yScale, xZoomStart, xZoomEnd, yZoomStart, yZoomEnd, svgPoint.x, svgPoint.y, maxRadius)[0];
+        if (closestPointIndex === undefined) {
+          continue;
+        }
+        const point = aSeries.data[closestPointIndex];
+        const scaledX = xScale(point.x);
+        const scaledY = yScale(point.y);
+        const distSq = (scaledX - svgPoint.x) ** 2 + (scaledY - svgPoint.y) ** 2;
+        if (closestPoint === undefined || distSq < closestPoint.distanceSq) {
+          closestPoint = {
+            dataIndex: closestPointIndex,
+            seriesId,
+            distanceSq: distSq
+          };
+        }
       }
-      lastFind.current = closestPointIndex;
-      const closestSeries = Object.values(voronoiRef.current).find(value => {
-        return 2 * closestPointIndex >= value.startIndex && 2 * closestPointIndex < value.endIndex;
-      });
-      if (closestSeries === undefined) {
+      if (closestPoint === undefined) {
         return 'no-point-found';
       }
-
-      // The point index in the series with id=closestSeries.seriesId.
-      const seriesPointIndex = (2 * closestPointIndex - voronoiRef.current[closestSeries.seriesId].startIndex) / 2;
-      const dataIndex = voronoiRef.current[closestSeries.seriesId].seriesIndexes[seriesPointIndex];
-      const maxRadius = voronoiMaxRadius === 'item' ? closestSeries.markerSize : voronoiMaxRadius;
-      if (maxRadius !== undefined) {
-        const pointX = delauneyRef.current.points[2 * closestPointIndex];
-        const pointY = delauneyRef.current.points[2 * closestPointIndex + 1];
-        const dist2 = (pointX - svgPoint.x) ** 2 + (pointY - svgPoint.y) ** 2;
-        if (dist2 > maxRadius ** 2) {
-          // The closest point is too far to be considered.
-          return 'outside-voronoi-max-radius';
-        }
-      }
       return {
-        seriesId: closestSeries.seriesId,
-        dataIndex
+        seriesId: closestPoint.seriesId,
+        dataIndex: closestPoint.dataIndex
       };
     }
 
@@ -211,7 +170,7 @@ export const useChartClosestPoint = ({
       pressHandler.cleanup();
       pressEndHandler.cleanup();
     };
-  }, [svgRef, yAxis, xAxis, voronoiMaxRadius, onItemClick, disableVoronoi, drawingArea, instance]);
+  }, [svgRef, yAxis, xAxis, voronoiMaxRadius, onItemClick, disableVoronoi, drawingArea, instance, seriesOrder, series, flatbushMap, defaultXAxisId, defaultYAxisId, store]);
 
   // Instance implementation
   const enableVoronoiCallback = useEventCallback(() => {

package/esm/models/seriesType/scatter.d.ts

@@ -23,6 +23,8 @@ export interface ScatterSeriesType extends CommonSeriesType<ScatterValueType | n
   /**
    * If true, the interaction will not use element hover for this series.
    * @default false
+   * @deprecated This prop will be removed in a future version because it is ambiguous. You can select what to disable
+   *             on hover by disabling the highlight or the tooltip separately.
    */
   disableHover?: boolean;
   /**

package/esm/themeAugmentation/components.d.ts

@@ -62,6 +62,9 @@ export interface ChartsComponents<Theme = unknown> {
     defaultProps?: ComponentsProps['MuiScatterChart'];
   };
   MuiScatter?: {};
+  MuiGauge?: {
+    styleOverrides?: ComponentsOverrides<Theme>['MuiGauge'];
+  };
 }
 declare module '@mui/material/styles' {
   interface Components<Theme = unknown> extends ChartsComponents<Theme> {}

package/esm/themeAugmentation/overrides.d.ts

@@ -1,3 +1,4 @@
+import { GaugeClassKey } from "../Gauge/index.js";
 import { BarLabelClassKey } from "../BarChart/index.js";
 import { BarElementClassKey } from "../BarChart/barElementClasses.js";
 import { ChartsAxisHighlightClassKey } from "../ChartsAxisHighlight/index.js";
@@ -18,6 +19,7 @@ export interface ChartsComponentNameToClassKey {
   MuiAreaElement: AreaElementClassKey;
   MuiLineElement: LineElementClassKey;
   MuiMarkElement: MarkElementClassKey;
+  MuiGauge: GaugeClassKey;
 }
 declare module '@mui/material/styles' {
   interface ComponentNameToClassKey extends ChartsComponentNameToClassKey {}

package/index.js

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

package/internals/Flatbush.bench.d.ts

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

package/internals/Flatbush.bench.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _Flatbush = require("./Flatbush");
+const data = [],
+  n = 1_000_000;
+
+// Generate and position the datapoints in a tangent wave pattern
+for (let i = 0; i < n; i += 1) {
+  const theta = Math.random() * 2 * Math.PI;
+  const radius = Math.pow(Math.random(), 2) * 100;
+  const waveDeviation = (Math.random() - 0.5) * 70;
+  const waveValue = Math.tan(theta) * waveDeviation;
+  data.push({
+    x: 50 + (radius + waveValue) * Math.cos(theta),
+    y: 50 + (radius + waveValue) * Math.sin(theta)
+  });
+}
+const flatbush1M = new _Flatbush.Flatbush(data.length);
+for (let i = 0; i < data.length; i += 1) {
+  flatbush1M.add(data[i].x, data[i].y);
+}
+flatbush1M.finish();
+(0, _vitest.describe)('Flatbush benchmarks', () => {
+  (0, _vitest.describe)('add + finish', () => {
+    (0, _vitest.bench)('add 1M points + finish', () => {
+      const flatbush = new _Flatbush.Flatbush(data.length);
+      for (let i = 0; i < data.length; i += 1) {
+        flatbush.add(data[i].x, data[i].y);
+      }
+      flatbush.finish();
+    });
+  });
+  (0, _vitest.describe)('search 1M points', () => {
+    (0, _vitest.bench)('search 1M points', () => {
+      flatbush1M.search(0.4, 0.4, 0.6, 0.6);
+    });
+  });
+  (0, _vitest.describe)('neighbors 1M points', () => {
+    (0, _vitest.bench)('neighbors 1M points', () => {
+      flatbush1M.neighbors(0.5, 0.5, 1, 0.04, undefined);
+    });
+  });
+});

package/internals/Flatbush.d.ts

@@ -0,0 +1,63 @@
+import FlatQueue from 'flatqueue';
+type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
+export declare class Flatbush {
+  _queue: FlatQueue<number>;
+  _boxes: TypedArrayConstructor;
+  _indices: Uint16Array | Uint32Array;
+  data: ArrayBufferLike;
+  numItems: number;
+  nodeSize: number;
+  _levelBounds: number[];
+  byteOffset: number;
+  /**
+   * Recreate a Flatbush index from raw `ArrayBuffer` or `SharedArrayBuffer` data.
+   * @param {ArrayBufferLike} data
+   * @param {number} [byteOffset=0] byte offset to the start of the Flatbush buffer in the referenced ArrayBuffer.
+   * @returns {Flatbush} index
+   */
+  static from(data: any, byteOffset?: number): Flatbush;
+  /**
+   * Create a Flatbush index that will hold a given number of items.
+   * @param {number} numItems
+   * @param {number} [nodeSize=16] Size of the tree node (16 by default).
+   * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+   * @param {ArrayBufferConstructor | SharedArrayBufferConstructor} [ArrayBufferType=ArrayBuffer] The array buffer type used to store data (`ArrayBuffer` by default).
+   * @param {ArrayBufferLike} [data] (Only used internally)
+   * @param {number} [byteOffset=0] (Only used internally)
+   */
+  constructor(numItems: number, nodeSize?: number, ArrayType?: TypedArrayConstructor, ArrayBufferType?: ArrayBufferConstructor | SharedArrayBufferConstructor, data?: ArrayBufferLike, byteOffset?: number);
+  /**
+   * Add a given rectangle to the index.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @returns {number} A zero-based, incremental number that represents the newly added rectangle.
+   */
+  add(minX: any, minY: any, maxX?: any, maxY?: any): number;
+  /** Perform indexing of the added rectangles. */
+  finish(): void;
+  /**
+   * Search the index by a bounding box.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @param {(index: number) => boolean} [filterFn] An optional function for filtering the results.
+   * @returns {number[]} An array containing the index, the x coordinate and the y coordinate of the points intersecting or touching the given bounding box.
+   */
+  search(minX: number, minY: number, maxX: number, maxY: number, filterFn?: (index: number) => boolean): number[];
+  /**
+   * Search items in order of distance from the given point.
+   * @param x
+   * @param y
+   * @param [maxResults=Infinity]
+   * @param maxDistSq
+   * @param [filterFn] An optional function for filtering the results.
+   * @param [sqDistFn] An optional function to calculate squared distance from the point to the item.
+   * @returns {number[]} An array of indices of items found.
+   */
+  neighbors(x: any, y: any, maxResults?: number, maxDistSq?: number, filterFn?: (index: number) => boolean, sqDistFn?: typeof sqDist): number[];
+}
+declare function sqDist(dx: number, dy: number): number;
+export {};