@sakuzu/maplibre-gl-draw 1.0.0

package/dist/dispatcher/hit-test/strategies/image.js

@@ -0,0 +1,115 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * ImageHitTestStrategy
+ *
+ * Hit testing strategy for image features.
+ * It tests using an OBB (Oriented Bounding Box).
+ */
+import { createOBB, DEFAULT_TILE_SIZE, distanceToOBB, getMetersPerPixel, metersToDegreesLat, metersToDegreesLng, } from '../../../shared/math/index.js';
+import { getImageProperties } from '../../../shared/utils/property.js';
+/**
+ * Default image style
+ * width/height: 0 = use the original size (the same as ImageRenderer)
+ */
+const DEFAULT_IMAGE_STYLE = {
+    width: 0,
+    height: 0,
+    rotation: 0,
+    opacity: 1.0,
+    imageOpacity: 1,
+};
+/**
+ * ImageHitTestStrategy
+ */
+export class ImageHitTestStrategy {
+    constructor(tileSize = DEFAULT_TILE_SIZE) {
+        Object.defineProperty(this, "geometryType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Image'
+        });
+        Object.defineProperty(this, "tileSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tileSize = tileSize;
+    }
+    /**
+     * Updates the tile size
+     */
+    setTileSize(tileSize) {
+        this.tileSize = tileSize;
+    }
+    test(feature, coordinate, toleranceLngLat) {
+        if (feature.type !== 'Image')
+            return false;
+        const dims = this.computeDims(feature);
+        if (!dims)
+            return false;
+        // The rendered image (computeQuadVertices) is rotated in latitude-normalized space.
+        // Unless the hit test also rotates and tests in latitude-normalized space, rotating in
+        // raw degree space shears the shape because of the real distance difference along the
+        // longitude axis, and part of a rotated image becomes impossible to click.
+        const { center, widthDeg, heightDeg, rotation } = dims;
+        const latCos = Math.cos((center[1] * Math.PI) / 180);
+        const dxNorm = (coordinate[0] - center[0]) * latCos;
+        const dyNorm = coordinate[1] - center[1];
+        const r = (-rotation * Math.PI) / 180;
+        const cos = Math.cos(r);
+        const sin = Math.sin(r);
+        const localX = dxNorm * cos - dyNorm * sin;
+        const localY = dxNorm * sin + dyNorm * cos;
+        const hwNorm = (widthDeg / 2) * latCos;
+        const hhNorm = heightDeg / 2;
+        const tolNorm = toleranceLngLat * latCos;
+        return Math.abs(localX) <= hwNorm + tolNorm && Math.abs(localY) <= hhNorm + tolNorm;
+    }
+    distance(feature, coordinate) {
+        if (feature.type !== 'Image')
+            return Infinity;
+        const dims = this.computeDims(feature);
+        if (!dims)
+            return Infinity;
+        // The distance is only used to decide which hit is in front (ordering). An OBB
+        // approximation is enough.
+        const obb = createOBB(dims.center[0], dims.center[1], dims.widthDeg, dims.heightDeg, dims.rotation);
+        return distanceToOBB(obb, coordinate);
+    }
+    /**
+     * Computes the dimensions (in degrees) and the rotation of an image feature
+     *
+     * It uses the same size computation logic as ImageRenderer
+     */
+    computeDims(feature) {
+        const properties = getImageProperties(feature);
+        if (!properties.imageFileId)
+            return null;
+        const coord = feature.coordinates;
+        const latitude = coord[1];
+        const style = { ...DEFAULT_IMAGE_STYLE, ...feature.style };
+        // Get the image size (the same logic as ImageRenderer)
+        // The size stored in ImageProperties takes precedence
+        // 100 is used as the fallback (for when the image has not been loaded)
+        const imageWidth = properties.imageWidth || 100;
+        const imageHeight = properties.imageHeight || 100;
+        // Use the size specified by the style, or the original size
+        const displayWidth = style.width || imageWidth;
+        const displayHeight = style.height || imageHeight;
+        // Compute the size based on the display at createdZoom
+        const createdZoom = properties.createdZoom || 14;
+        const scale = properties.scale || 1;
+        // Pixel to meter conversion at createdZoom
+        const widthMeters = getMetersPerPixel(latitude, createdZoom, this.tileSize) * displayWidth * scale;
+        const heightMeters = getMetersPerPixel(latitude, createdZoom, this.tileSize) * displayHeight * scale;
+        // Convert meters to degrees
+        const widthDeg = metersToDegreesLng(widthMeters, latitude);
+        const heightDeg = metersToDegreesLat(heightMeters);
+        // Rotation angle (the sum of both the style and the properties)
+        const rotation = (style.rotation || 0) + (properties.rotation || 0);
+        return { center: coord, widthDeg, heightDeg, rotation };
+    }
+}

package/dist/dispatcher/hit-test/strategies/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Hit Test Strategies
+ */
+export type { HitTestOptions, HitTestResult, HitTestStrategy, VertexHit } from './base.js';
+export { DEFAULT_HIT_TEST_OPTIONS, HitTestStrategyRegistry } from './base.js';
+export { CircleHitTestStrategy } from './circle.js';
+export { ImageHitTestStrategy } from './image.js';
+export { LineHitTestStrategy } from './line.js';
+export { MultiLineStringHitTestStrategy, MultiPointHitTestStrategy, MultiPolygonHitTestStrategy, } from './multi.js';
+export { PointHitTestStrategy } from './point.js';
+export { PolygonHitTestStrategy } from './polygon.js';

package/dist/dispatcher/hit-test/strategies/index.js

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export { DEFAULT_HIT_TEST_OPTIONS, HitTestStrategyRegistry } from './base.js';
+// Strategies per geometry type
+export { CircleHitTestStrategy } from './circle.js';
+export { ImageHitTestStrategy } from './image.js';
+export { LineHitTestStrategy } from './line.js';
+export { MultiLineStringHitTestStrategy, MultiPointHitTestStrategy, MultiPolygonHitTestStrategy, } from './multi.js';
+export { PointHitTestStrategy } from './point.js';
+export { PolygonHitTestStrategy } from './polygon.js';

package/dist/dispatcher/hit-test/strategies/line.d.ts

@@ -0,0 +1,17 @@
+/**
+ * LineHitTestStrategy
+ *
+ * Hit testing strategy for LineString features.
+ * Distances are measured in the local frame of hit testing (local-frame.ts).
+ */
+import type { Coordinate, Feature, FeatureType } from '../../../store/types.js';
+import type { HitTestStrategy } from './base.js';
+/**
+ * Hit testing strategy for the LineString type
+ */
+export declare class LineHitTestStrategy implements HitTestStrategy {
+    readonly geometryType: FeatureType;
+    test(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): boolean;
+    distance(feature: Feature, coordinate: Coordinate): number;
+    testDistance(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): number | null;
+}

package/dist/dispatcher/hit-test/strategies/line.js

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { latitudeScale, localPointToPolylineDistance } from '../local-frame.js';
+import { polylineDistanceWithin } from '../segment-grid.js';
+/**
+ * Hit testing strategy for the LineString type
+ */
+export class LineHitTestStrategy {
+    constructor() {
+        Object.defineProperty(this, "geometryType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'LineString'
+        });
+    }
+    test(feature, coordinate, toleranceLngLat) {
+        return this.testDistance(feature, coordinate, toleranceLngLat) !== null;
+    }
+    distance(feature, coordinate) {
+        const lineCoords = feature.coordinates;
+        // The nearest distance without a tolerance cannot be answered by the index, so this
+        // stays a full scan
+        return localPointToPolylineDistance(coordinate, lineCoords, latitudeScale(coordinate[1]));
+    }
+    testDistance(feature, coordinate, toleranceLngLat) {
+        const lineCoords = feature.coordinates;
+        return polylineDistanceWithin(lineCoords, coordinate, toleranceLngLat, latitudeScale(coordinate[1]));
+    }
+}

package/dist/dispatcher/hit-test/strategies/multi.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Hit testing strategies for the Multi geometries
+ *
+ * MultiPoint / MultiLineString / MultiPolygon are tested as "a hit if any part is hit"
+ * and "the distance is the minimum over the parts". The test logic itself reuses the
+ * strategy of the single geometry for each part. Distances are measured in the local frame
+ * of hit testing (local-frame.ts).
+ */
+import type { Coordinate, Feature, FeatureType } from '../../../store/types.js';
+import type { HitTestStrategy } from './base.js';
+/**
+ * Hit testing strategy for the MultiPoint type
+ *
+ * The coordinates are `Coordinate[]` (one part = one point).
+ */
+export declare class MultiPointHitTestStrategy implements HitTestStrategy {
+    readonly geometryType: FeatureType;
+    test(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): boolean;
+    distance(feature: Feature, coordinate: Coordinate): number;
+}
+/**
+ * Hit testing strategy for the MultiLineString type
+ *
+ * The coordinates are `Coordinate[][]` (one part = one polyline).
+ */
+export declare class MultiLineStringHitTestStrategy implements HitTestStrategy {
+    readonly geometryType: FeatureType;
+    test(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): boolean;
+    distance(feature: Feature, coordinate: Coordinate): number;
+    testDistance(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): number | null;
+}
+/**
+ * Hit testing strategy for the MultiPolygon type
+ *
+ * The coordinates are `Coordinate[][][]` (one part = an array of rings, where rings[0] is
+ * the outer ring and the rest are inner rings).
+ */
+export declare class MultiPolygonHitTestStrategy implements HitTestStrategy {
+    readonly geometryType: FeatureType;
+    private readonly polygonStrategy;
+    test(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): boolean;
+    distance(feature: Feature, coordinate: Coordinate): number;
+    testDistance(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): number | null;
+}

package/dist/dispatcher/hit-test/strategies/multi.js

@@ -0,0 +1,141 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { latitudeScale, localDistance, localPointToPolylineDistance } from '../local-frame.js';
+import { polylineDistanceWithin } from '../segment-grid.js';
+import { PolygonHitTestStrategy } from './polygon.js';
+/**
+ * Hit testing strategy for the MultiPoint type
+ *
+ * The coordinates are `Coordinate[]` (one part = one point).
+ */
+export class MultiPointHitTestStrategy {
+    constructor() {
+        Object.defineProperty(this, "geometryType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'MultiPoint'
+        });
+    }
+    test(feature, coordinate, toleranceLngLat) {
+        const parts = feature.coordinates;
+        const latScale = latitudeScale(coordinate[1]);
+        for (const part of parts) {
+            if (localDistance(coordinate, part, latScale) <= toleranceLngLat) {
+                return true;
+            }
+        }
+        return false;
+    }
+    distance(feature, coordinate) {
+        const parts = feature.coordinates;
+        const latScale = latitudeScale(coordinate[1]);
+        let min = Number.POSITIVE_INFINITY;
+        for (const part of parts) {
+            min = Math.min(min, localDistance(coordinate, part, latScale));
+        }
+        return min;
+    }
+}
+/**
+ * Hit testing strategy for the MultiLineString type
+ *
+ * The coordinates are `Coordinate[][]` (one part = one polyline).
+ */
+export class MultiLineStringHitTestStrategy {
+    constructor() {
+        Object.defineProperty(this, "geometryType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'MultiLineString'
+        });
+    }
+    test(feature, coordinate, toleranceLngLat) {
+        const parts = feature.coordinates;
+        const latScale = latitudeScale(coordinate[1]);
+        for (const part of parts) {
+            if (part.length === 0)
+                continue;
+            if (localPointToPolylineDistance(coordinate, part, latScale) <= toleranceLngLat) {
+                return true;
+            }
+        }
+        return false;
+    }
+    distance(feature, coordinate) {
+        const parts = feature.coordinates;
+        const latScale = latitudeScale(coordinate[1]);
+        let min = Number.POSITIVE_INFINITY;
+        for (const part of parts) {
+            if (part.length === 0)
+                continue;
+            min = Math.min(min, localPointToPolylineDistance(coordinate, part, latScale));
+        }
+        return min;
+    }
+    testDistance(feature, coordinate, toleranceLngLat) {
+        const parts = feature.coordinates;
+        const latScale = latitudeScale(coordinate[1]);
+        let min = Number.POSITIVE_INFINITY;
+        for (const part of parts) {
+            if (part.length === 0)
+                continue;
+            const distance = polylineDistanceWithin(part, coordinate, toleranceLngLat, latScale);
+            if (distance !== null && distance < min) {
+                min = distance;
+            }
+        }
+        return min <= toleranceLngLat ? min : null;
+    }
+}
+/**
+ * Hit testing strategy for the MultiPolygon type
+ *
+ * The coordinates are `Coordinate[][][]` (one part = an array of rings, where rings[0] is
+ * the outer ring and the rest are inner rings).
+ */
+export class MultiPolygonHitTestStrategy {
+    constructor() {
+        Object.defineProperty(this, "geometryType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'MultiPolygon'
+        });
+        Object.defineProperty(this, "polygonStrategy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new PolygonHitTestStrategy()
+        });
+    }
+    test(feature, coordinate, toleranceLngLat) {
+        const parts = feature.coordinates;
+        for (const rings of parts) {
+            if (this.polygonStrategy.testRings(rings, coordinate, toleranceLngLat)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    distance(feature, coordinate) {
+        const parts = feature.coordinates;
+        let min = Number.POSITIVE_INFINITY;
+        for (const rings of parts) {
+            min = Math.min(min, this.polygonStrategy.distanceToRings(rings, coordinate));
+        }
+        return min;
+    }
+    testDistance(feature, coordinate, toleranceLngLat) {
+        const parts = feature.coordinates;
+        let min = Number.POSITIVE_INFINITY;
+        for (const rings of parts) {
+            const distance = this.polygonStrategy.testDistanceRings(rings, coordinate, toleranceLngLat);
+            if (distance !== null && distance < min) {
+                min = distance;
+            }
+        }
+        return min <= toleranceLngLat ? min : null;
+    }
+}

package/dist/dispatcher/hit-test/strategies/point.d.ts

@@ -0,0 +1,20 @@
+/**
+ * PointHitTestStrategy
+ *
+ * Hit testing strategy for Point features.
+ * Distances are measured in the local frame of hit testing (local-frame.ts).
+ */
+import type { Coordinate, Feature, FeatureType } from '../../../store/types.js';
+import type { HitTestStrategy } from './base.js';
+/**
+ * The built-in hit test of `Point` features: hit within the tolerance of the position.
+ *
+ * The distance is measured in the local frame of the click (see {@link HitTestStrategy}).
+ * A custom type drawn as a point can reuse it, or extend it to widen the hit area.
+ */
+export declare class PointHitTestStrategy implements HitTestStrategy {
+    /** The feature type, `'Point'` */
+    readonly geometryType: FeatureType;
+    test(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): boolean;
+    distance(feature: Feature, coordinate: Coordinate): number;
+}

package/dist/dispatcher/hit-test/strategies/point.js

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { latitudeScale, localDistance } from '../local-frame.js';
+/**
+ * The built-in hit test of `Point` features: hit within the tolerance of the position.
+ *
+ * The distance is measured in the local frame of the click (see {@link HitTestStrategy}).
+ * A custom type drawn as a point can reuse it, or extend it to widen the hit area.
+ */
+export class PointHitTestStrategy {
+    constructor() {
+        /** The feature type, `'Point'` */
+        Object.defineProperty(this, "geometryType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Point'
+        });
+    }
+    test(feature, coordinate, toleranceLngLat) {
+        const pointCoord = feature.coordinates;
+        const dist = localDistance(coordinate, pointCoord, latitudeScale(coordinate[1]));
+        return dist <= toleranceLngLat;
+    }
+    distance(feature, coordinate) {
+        const pointCoord = feature.coordinates;
+        return localDistance(coordinate, pointCoord, latitudeScale(coordinate[1]));
+    }
+}

package/dist/dispatcher/hit-test/strategies/polygon.d.ts

@@ -0,0 +1,52 @@
+/**
+ * PolygonHitTestStrategy
+ *
+ * Hit testing strategy for Polygon features.
+ * Distances to the edges are measured in the local frame of hit testing (local-frame.ts).
+ * The inside test is unaffected by that frame (it only scales the latitude axis).
+ */
+import type { Coordinate, Feature, FeatureType } from '../../../store/types.js';
+import type { HitTestStrategy } from './base.js';
+/**
+ * Hit testing strategy for the Polygon type
+ */
+export declare class PolygonHitTestStrategy implements HitTestStrategy {
+    readonly geometryType: FeatureType;
+    test(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): boolean;
+    distance(feature: Feature, coordinate: Coordinate): number;
+    testDistance(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): number | null;
+    /**
+     * Hit test and distance computation for one part, an array of rings (a single scan)
+     *
+     * Returns 0 when inside, the distance to the edge when outside and that distance is
+     * within the tolerance, and null otherwise. Reused from the part iteration of
+     * MultiPolygon.
+     */
+    testDistanceRings(rings: Coordinate[][], coordinate: Coordinate, toleranceLngLat: number): number | null;
+    /**
+     * Hit test for one part, an array of rings
+     *
+     * Reused from the part iteration of MultiPolygon.
+     */
+    testRings(rings: Coordinate[][], coordinate: Coordinate, toleranceLngLat: number): boolean;
+    /**
+     * Distance to one part, an array of rings
+     *
+     * Reused from the part iteration of MultiPolygon.
+     */
+    distanceToRings(rings: Coordinate[][], coordinate: Coordinate): number;
+    /**
+     * Point in polygon test
+     *
+     * true when it is contained in the outer ring and not contained in a hole
+     */
+    private pointInPolygon;
+    /**
+     * Test for being inside a ring, using the ray casting algorithm
+     */
+    private pointInRing;
+    /**
+     * Computes the shortest distance from a point to the edges of the polygon
+     */
+    private pointToPolygonEdgeDistance;
+}

package/dist/dispatcher/hit-test/strategies/polygon.js

@@ -0,0 +1,138 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { latitudeScale, localPointToSegmentDistance } from '../local-frame.js';
+import { polylineDistanceWithin } from '../segment-grid.js';
+/**
+ * Hit testing strategy for the Polygon type
+ */
+export class PolygonHitTestStrategy {
+    constructor() {
+        Object.defineProperty(this, "geometryType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Polygon'
+        });
+    }
+    test(feature, coordinate, toleranceLngLat) {
+        const rings = feature.coordinates;
+        return this.testRings(rings, coordinate, toleranceLngLat);
+    }
+    distance(feature, coordinate) {
+        const rings = feature.coordinates;
+        return this.distanceToRings(rings, coordinate);
+    }
+    testDistance(feature, coordinate, toleranceLngLat) {
+        const rings = feature.coordinates;
+        return this.testDistanceRings(rings, coordinate, toleranceLngLat);
+    }
+    /**
+     * Hit test and distance computation for one part, an array of rings (a single scan)
+     *
+     * Returns 0 when inside, the distance to the edge when outside and that distance is
+     * within the tolerance, and null otherwise. Reused from the part iteration of
+     * MultiPolygon.
+     */
+    testDistanceRings(rings, coordinate, toleranceLngLat) {
+        if (rings.length === 0)
+            return null;
+        // 1. Test for being inside the polygon (point in polygon)
+        // Ray casting stays a full scan of every ring, because the index can only answer
+        // "the shortest distance within the tolerance", while the inside/outside test needs
+        // the total number of crossings.
+        if (this.pointInPolygon(coordinate, rings)) {
+            return 0;
+        }
+        // 2. Test the distance to the edges (per ring, a threshold switches between the full
+        // scan and the index)
+        const latScale = latitudeScale(coordinate[1]);
+        let minDistance = Number.POSITIVE_INFINITY;
+        for (const ring of rings) {
+            const distance = polylineDistanceWithin(ring, coordinate, toleranceLngLat, latScale);
+            if (distance !== null && distance < minDistance) {
+                minDistance = distance;
+            }
+        }
+        return minDistance <= toleranceLngLat ? minDistance : null;
+    }
+    /**
+     * Hit test for one part, an array of rings
+     *
+     * Reused from the part iteration of MultiPolygon.
+     */
+    testRings(rings, coordinate, toleranceLngLat) {
+        if (rings.length === 0)
+            return false;
+        // 1. Test for being inside the polygon (point in polygon)
+        if (this.pointInPolygon(coordinate, rings)) {
+            return true;
+        }
+        // 2. Test the distance to the edges (a hit when within the tolerance)
+        return this.pointToPolygonEdgeDistance(coordinate, rings) <= toleranceLngLat;
+    }
+    /**
+     * Distance to one part, an array of rings
+     *
+     * Reused from the part iteration of MultiPolygon.
+     */
+    distanceToRings(rings, coordinate) {
+        if (rings.length === 0)
+            return Number.POSITIVE_INFINITY;
+        // If it is inside, the distance is 0
+        if (this.pointInPolygon(coordinate, rings)) {
+            return 0;
+        }
+        // Distance to the edges
+        return this.pointToPolygonEdgeDistance(coordinate, rings);
+    }
+    /**
+     * Point in polygon test
+     *
+     * true when it is contained in the outer ring and not contained in a hole
+     */
+    pointInPolygon(point, rings) {
+        const [lng, lat] = point;
+        // Test against the outer ring
+        if (!this.pointInRing(lng, lat, rings[0])) {
+            return false;
+        }
+        // Test against the hole rings (false if it is inside a hole)
+        for (let i = 1; i < rings.length; i++) {
+            if (this.pointInRing(lng, lat, rings[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Test for being inside a ring, using the ray casting algorithm
+     */
+    pointInRing(x, y, ring) {
+        let inside = false;
+        const n = ring.length;
+        for (let i = 0, j = n - 1; i < n; j = i++) {
+            const [xi, yi] = ring[i];
+            const [xj, yj] = ring[j];
+            const cond1 = yi > y !== yj > y;
+            const cond2 = x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+            if (cond1 && cond2) {
+                inside = !inside;
+            }
+        }
+        return inside;
+    }
+    /**
+     * Computes the shortest distance from a point to the edges of the polygon
+     */
+    pointToPolygonEdgeDistance(point, rings) {
+        const latScale = latitudeScale(point[1]);
+        let minDistance = Number.POSITIVE_INFINITY;
+        for (const ring of rings) {
+            for (let i = 0; i < ring.length - 1; i++) {
+                const distance = localPointToSegmentDistance(point, ring[i], ring[i + 1], latScale);
+                minDistance = Math.min(minDistance, distance);
+            }
+        }
+        return minDistance;
+    }
+}

package/dist/dispatcher/hit-test/topmost.d.ts

@@ -0,0 +1,48 @@
+import type { Dataset } from '../../display/types.js';
+import type { ScreenPoint } from '../../shared/math/index.js';
+import type { Feature } from '../../store/types.js';
+import type { FeatureCompanionHitResult } from '../../view/feature-companion.js';
+/**
+ * What the frontmost hit at a screen position is: a feature of the Store, a
+ * dataset, or something that accompanies a feature.
+ *
+ * - store: a feature of the Store. It is a target of selection and editing as before
+ * - dataset: a dataset. When feature is null it means "it occludes, but
+ *   it does not fire an event" (interactive: false)
+ * - companion: something that accompanies a feature (view/feature-companion). It was hit
+ *   right after the test of the feature itself failed, and the click is received by the
+ *   provider (the selection state does not change)
+ */
+export type TopHit = {
+    kind: 'store';
+    feature: Feature;
+} | {
+    kind: 'dataset';
+    dataset: Dataset;
+    feature: Feature | null;
+    /** The row of the feature in the dataset (null together with feature) */
+    row: number | null;
+} | {
+    kind: 'companion';
+    companion: FeatureCompanionHitResult;
+};
+/**
+ * The options of a {@link HitTestTopmost} call.
+ */
+export interface TopmostHitTestOptions {
+    /**
+     * The list of the features of the Store in display order
+     *
+     * When the caller already holds `getDisplayFeatures(store)`, passing it avoids fetching
+     * it again. When omitted, this function fetches it itself.
+     */
+    orderedFeatures?: Feature[];
+}
+/**
+ * Returns the single frontmost hit at a screen position, across the Store, the
+ * datasets and the feature companions, in the same order as they are drawn.
+ *
+ * The position is in CSS px relative to the map container. It returns `null` when nothing is
+ * hit.
+ */
+export type HitTestTopmost = (point: ScreenPoint, options?: TopmostHitTestOptions) => TopHit | null;