@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

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

@@ -47,6 +47,12 @@ export interface AnchorScreenProjector {
  * draw instance (6 px by default).
  */
 export interface HitTestService {
+    /**
+     * Changes how far from a feature a click still hits it, in CSS pixels
+     *
+     * @param px The new tolerance
+     */
+    setClickTolerance(px: number): void;
     /**
      * Returns the frontmost feature that is hit, walking `orderedFeatures` from the end
      *
@@ -84,6 +90,10 @@ export interface HitTestService {
      * @returns a function that cancels the registration (see HitTestStrategyRegistry.register)
      */
     registerStrategy?(strategy: HitTestStrategy): () => void;
+    /**
+     * The strategy registered for a type, or `undefined`
+     */
+    getStrategy?(type: string): HitTestStrategy | undefined;
     /**
      * Registers, per feature type, the extra reach (in CSS pixels) for narrowing down the
      * candidates
@@ -117,4 +127,11 @@ export interface HitTestServiceImplOptions extends Partial<HitTestOptions> {
      * is tested
      */
     drawnShape?: DrawnShapeResolver;
+    /**
+     * How far the marker of a built-in point reaches from its position, in CSS pixels. When
+     * given, the built-in `Point` and `MultiPoint` strategies hit a point within that reach plus
+     * the tolerance, so a click anywhere on its marker hits it; when omitted a point is hit
+     * within the tolerance of its position alone
+     */
+    pointMarkerReachPx?: (feature: Feature) => number;
 }

package/dist/dispatcher/hit-test/service.js

@@ -1,5 +1,6 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
+import { coordinatesOf } from '../../shared/utils/coordinates.js';
 import { clickCopies, toleranceDegrees } from './local-frame.js';
 import { DEFAULT_HIT_TEST_OPTIONS, HitTestStrategyRegistry } from './strategies/base.js';
 import { CircleHitTestStrategy } from './strategies/circle.js';
@@ -22,6 +23,9 @@ const SCREEN_SPACE_TYPES = new Set(['Point', 'MultiPoint']);
  * @internal
  */
 export class HitTestServiceImpl {
+    setClickTolerance(px) {
+        this.options = { ...this.options, clickTolerance: px };
+    }
     constructor(store, spatialIndex, options = {}) {
         Object.defineProperty(this, "spatialIndex", {
             enumerable: true,
@@ -83,13 +87,14 @@ export class HitTestServiceImpl {
         const tileSize = options.tileSize ?? 512;
         // Register the default strategies
         this.registry = new HitTestStrategyRegistry();
-        this.registry.register(new PointHitTestStrategy());
+        const markerReach = options.pointMarkerReachPx;
+        this.registry.register(withReach(new PointHitTestStrategy(), markerReach));
         this.registry.register(new LineHitTestStrategy());
         this.registry.register(new PolygonHitTestStrategy());
         this.registry.register(new CircleHitTestStrategy());
         // The Multi geometries (a hit if any part is hit / the distance is the minimum over the
         // parts)
-        this.registry.register(new MultiPointHitTestStrategy());
+        this.registry.register(withReach(new MultiPointHitTestStrategy(), markerReach));
         this.registry.register(new MultiLineStringHitTestStrategy());
         this.registry.register(new MultiPolygonHitTestStrategy());
         // Freehand uses the same strategy as LineString
@@ -117,6 +122,12 @@ export class HitTestServiceImpl {
     registerStrategy(strategy) {
         return this.registry.register(strategy);
     }
+    /**
+     * The strategy registered for a type
+     */
+    getStrategy(type) {
+        return this.registry.get(type);
+    }
     /**
      * Registers the extra reach for narrowing down the candidates
      *
@@ -155,12 +166,36 @@ export class HitTestServiceImpl {
      * The radius is a square box in degrees. A latitude reach needs only radius * cos φ
      * (local-frame.ts), so the box never misses a candidate.
      */
-    expandSearchRadius(toleranceLngLat, tolerancePx, screenPoint, unproject) {
-        const reachPx = this.maxCandidateReachPx();
+    expandSearchRadius(toleranceLngLat, degPerPx, orderedFeatures) {
+        const reachPx = this.maxCandidateReachPx() + this.maxFeatureReachPx(orderedFeatures);
         if (reachPx <= 0)
             return toleranceLngLat;
-        const degPerPx = tolerancePx > 0 ? toleranceLngLat / tolerancePx : toleranceDegrees(unproject, screenPoint, 1);
-        return toleranceLngLat + reachPx * degPerPx;
+        return toleranceLngLat + reachPx * degPerPx();
+    }
+    /**
+     * The largest reach beyond its geometry among the features whose strategy has one
+     * (`HitTestStrategy.reachPx`, the markers of the points), in CSS pixels
+     *
+     * The reach depends on the style of each feature, so it is measured at query time like the
+     * rest of the appearance (the bounding boxes of the index stay those of the geometry).
+     */
+    maxFeatureReachPx(orderedFeatures) {
+        let max = 0;
+        let lastType;
+        let reachOf;
+        for (const feature of orderedFeatures) {
+            if (feature.type !== lastType) {
+                lastType = feature.type;
+                const strategy = this.registry.get(feature.type);
+                reachOf = strategy?.reachPx?.bind(strategy);
+            }
+            if (!reachOf)
+                continue;
+            const reach = reachOf(feature);
+            if (reach > max)
+                max = reach;
+        }
+        return max;
     }
     /**
      * Returns the frontmost hit in the visual stacking order
@@ -198,9 +233,16 @@ export class HitTestServiceImpl {
         // The search radius is widened by the registered extra reach
         // (registerCandidateReach). Unlike the approach of baking the appearance into the bbox
         // of the index, this does not depend on the state or the zoom. The tolerance passed to
-        // the second stage is toleranceLngLat as before (only the candidate set widens; the
-        // semantics of a hit are decided by the strategy).
-        const searchRadius = this.expandSearchRadius(toleranceLngLat, tolerance, screenPoint, unproject);
+        // the second stage is toleranceLngLat as before, widened only by the reach of a strategy
+        // (the marker of a point); the registered reach widens only the candidate set.
+        // The degrees per CSS pixel at the click, measured once and only when needed (from the
+        // tolerance already converted, or from one pixel when the tolerance is 0)
+        let degPerPxMemo;
+        const degPerPx = () => {
+            degPerPxMemo ?? (degPerPxMemo = tolerance > 0 ? toleranceLngLat / tolerance : toleranceDegrees(unproject, screenPoint, 1));
+            return degPerPxMemo;
+        };
+        const searchRadius = this.expandSearchRadius(toleranceLngLat, degPerPx, orderedFeatures);
         // The click on each copy of the world it can reach (the stored copy alone away from the
         // antimeridian; local-frame.ts)
         const copies = clickCopies(coordinate, searchRadius);
@@ -222,8 +264,7 @@ export class HitTestServiceImpl {
         // Symbols (points) are tested in screen space. This works only while the terrain is
         // enabled; when it is disabled null is returned and the conventional path is used as
         // before.
-        const degPerPx = tolerance > 0 ? toleranceLngLat / tolerance : 0;
-        const screen = this.hitTestAnchorsInScreenSpace(screenPoint, orderedFeatures, tolerance, degPerPx, selectable);
+        const screen = this.hitTestAnchorsInScreenSpace(screenPoint, orderedFeatures, tolerance, tolerance > 0 ? toleranceLngLat / tolerance : 0, selectable);
         // Stage 2: the precise test
         const results = screen ? [...screen.results] : [];
         for (const feature of visibleCandidates) {
@@ -238,6 +279,9 @@ export class HitTestServiceImpl {
             // nearest hit counts. It is tested in the shape it is drawn with (the result keeps the
             // stored feature)
             const shape = this.drawnShape(feature);
+            // What is drawn beyond the geometry (the marker of a point) is hit as well
+            const reachPx = strategy.reachPx?.(feature) ?? 0;
+            const featureTolerance = reachPx > 0 ? toleranceLngLat + reachPx * degPerPx() : toleranceLngLat;
             let best = null;
             for (let i = 0; i < copies.length; i++) {
                 if (!candidatesByCopy[i].has(feature.id))
@@ -247,9 +291,9 @@ export class HitTestServiceImpl {
                 // A strategy that has testDistance finishes the test and the distance computation in
                 // a single scan
                 if (strategy.testDistance) {
-                    distance = strategy.testDistance(shape, copy, toleranceLngLat);
+                    distance = strategy.testDistance(shape, copy, featureTolerance);
                 }
-                else if (strategy.test(shape, copy, toleranceLngLat)) {
+                else if (strategy.test(shape, copy, featureTolerance)) {
                     distance = strategy.distance(shape, copy);
                 }
                 if (distance !== null && (best === null || distance < best))
@@ -289,10 +333,12 @@ export class HitTestServiceImpl {
                 continue;
             if (!selectable(feature))
                 continue;
-            const reachPx = tolerancePx + this.candidateReachPx(feature.type);
+            const reachPx = tolerancePx +
+                this.candidateReachPx(feature.type) +
+                (this.registry.get(feature.type)?.reachPx?.(feature) ?? 0);
             const parts = feature.type === 'MultiPoint'
-                ? feature.coordinates
-                : [feature.coordinates];
+                ? coordinatesOf(feature)
+                : [coordinatesOf(feature)];
             let nearest = Number.POSITIVE_INFINITY;
             for (const coord of parts) {
                 const point = projector.project(coord);
@@ -331,3 +377,21 @@ export class HitTestServiceImpl {
         return strategy.test(this.drawnShape(feature), coordinate, toleranceLngLat);
     }
 }
+/**
+ * A built-in strategy that reaches as far as the feature is drawn (`HitTestStrategy.reachPx`)
+ *
+ * Without a reach the strategy is returned as it is.
+ */
+function withReach(strategy, reachPx) {
+    if (!reachPx)
+        return strategy;
+    return {
+        geometryType: strategy.geometryType,
+        test: (feature, coordinate, tolerance) => strategy.test(feature, coordinate, tolerance),
+        distance: (feature, coordinate) => strategy.distance(feature, coordinate),
+        ...(strategy.testDistance && {
+            testDistance: (feature, coordinate, tolerance) => strategy.testDistance?.(feature, coordinate, tolerance) ?? null,
+        }),
+        reachPx,
+    };
+}

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

@@ -51,7 +51,7 @@ export interface HitTestOptions {
 export declare const DEFAULT_HIT_TEST_OPTIONS: HitTestOptions;
 /**
  * The precise hit test of one feature type, as registered through the `hitTest` of a
- * `CustomFeatureHandler`.
+ * `FeatureTypeHandler`.
  *
  * The library first narrows the candidates with its spatial index and then calls `test` on
  * each candidate from the front; the first that returns `true` receives the click. The
@@ -60,24 +60,6 @@ export declare const DEFAULT_HIT_TEST_OPTIONS: HitTestOptions;
  * difference, divide it by cos φ of the click latitude (or multiply the tolerance by cos φ):
  * one degree of latitude is 1 / cos φ times longer on screen than one degree of longitude.
  * Distances are returned in the same unit.
- *
- * @example
- * ```ts
- * import type { HitTestStrategy } from '@sakuzu/maplibre-gl-draw';
- *
- * // A marker type hit within the tolerance around its single position
- * const markerHitTest: HitTestStrategy = {
- *   geometryType: 'Marker',
- *   test(feature, [lng, lat], tolerance) {
- *     return this.distance(feature, [lng, lat]) <= tolerance;
- *   },
- *   distance(feature, [lng, lat]) {
- *     const [x, y] = feature.coordinates as [number, number];
- *     const cos = Math.cos((lat * Math.PI) / 180);
- *     return Math.hypot(x - lng, (y - lat) / cos);
- *   },
- * };
- * ```
  */
 export interface HitTestStrategy {
     /** The feature type this strategy tests; a registration replaces the one for the type */
@@ -112,6 +94,18 @@ export interface HitTestStrategy {
      * @returns The distance (same unit) if within the tolerance, null if outside
      */
     testDistance?(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): number | null;
+    /**
+     * How far beyond its geometry the feature is drawn, in CSS pixels (the radius of the marker
+     * of a point)
+     *
+     * The service adds it to the tolerance it hands to `test` for this feature, and widens the
+     * candidate search by it, so that a click on what is drawn hits the feature. Without it,
+     * the feature is hit within the tolerance of its geometry alone.
+     *
+     * @param feature The feature to test
+     * @returns The reach in CSS pixels (0 or more)
+     */
+    reachPx?(feature: Feature): number;
 }
 /**
  * Hit testing strategy registry

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

@@ -7,6 +7,7 @@
  * It tests whether the distance from the center is within the radius.
  */
 import { haversineDistanceMeters, metersToLng } from '../../../shared/math/index.js';
+import { coordinatesOf } from '../../../shared/utils/coordinates.js';
 import { getCircleRadius } from '../../../shared/utils/property.js';
 /**
  * Hit testing strategy for the Circle type
@@ -21,7 +22,7 @@ export class CircleHitTestStrategy {
         });
     }
     test(feature, coordinate, toleranceLngLat) {
-        const center = feature.coordinates;
+        const center = coordinatesOf(feature);
         const radiusMeters = getCircleRadius(feature);
         if (radiusMeters === undefined || radiusMeters <= 0) {
             return false;
@@ -39,7 +40,7 @@ export class CircleHitTestStrategy {
         return distanceMeters <= radiusMeters + effectiveTolerance;
     }
     distance(feature, coordinate) {
-        const center = feature.coordinates;
+        const center = coordinatesOf(feature);
         const radiusMeters = getCircleRadius(feature);
         if (radiusMeters === undefined || radiusMeters <= 0) {
             return Number.POSITIVE_INFINITY;

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

@@ -7,18 +7,8 @@
  * It tests using an OBB (Oriented Bounding Box).
  */
 import { createOBB, DEFAULT_TILE_SIZE, distanceToOBB, getMetersPerPixel, metersToDegreesLat, metersToDegreesLng, } from '../../../shared/math/index.js';
+import { coordinatesOf } from '../../../shared/utils/coordinates.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
  */
@@ -88,17 +78,15 @@ export class ImageHitTestStrategy {
         const properties = getImageProperties(feature);
         if (!properties.imageFileId)
             return null;
-        const coord = feature.coordinates;
+        const coord = coordinatesOf(feature);
         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;
+        const displayWidth = imageWidth;
+        const displayHeight = imageHeight;
         // Compute the size based on the display at createdZoom
         const createdZoom = properties.createdZoom || 14;
         const scale = properties.scale || 1;
@@ -108,8 +96,8 @@ export class ImageHitTestStrategy {
         // 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);
+        // Rotation angle
+        const rotation = properties.rotation || 0;
         return { center: coord, widthDeg, heightDeg, rotation };
     }
 }

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

@@ -1,9 +1,3 @@
-/**
- * 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';
 /**

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

@@ -1,5 +1,12 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * LineHitTestStrategy
+ *
+ * Hit testing strategy for LineString features.
+ * Distances are measured in the local frame of hit testing (local-frame.ts).
+ */
+import { coordinatesOf } from '../../../shared/utils/coordinates.js';
 import { latitudeScale, localPointToPolylineDistance } from '../local-frame.js';
 import { polylineDistanceWithin } from '../segment-grid.js';
 /**
@@ -18,13 +25,13 @@ export class LineHitTestStrategy {
         return this.testDistance(feature, coordinate, toleranceLngLat) !== null;
     }
     distance(feature, coordinate) {
-        const lineCoords = feature.coordinates;
+        const lineCoords = coordinatesOf(feature);
         // 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;
+        const lineCoords = coordinatesOf(feature);
         return polylineDistanceWithin(lineCoords, coordinate, toleranceLngLat, latitudeScale(coordinate[1]));
     }
 }

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

@@ -1,11 +1,3 @@
-/**
- * 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';
 /**

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

@@ -1,5 +1,14 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * 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 { coordinatesOf } from '../../../shared/utils/coordinates.js';
 import { latitudeScale, localDistance, localPointToPolylineDistance } from '../local-frame.js';
 import { polylineDistanceWithin } from '../segment-grid.js';
 import { PolygonHitTestStrategy } from './polygon.js';
@@ -18,7 +27,7 @@ export class MultiPointHitTestStrategy {
         });
     }
     test(feature, coordinate, toleranceLngLat) {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         const latScale = latitudeScale(coordinate[1]);
         for (const part of parts) {
             if (localDistance(coordinate, part, latScale) <= toleranceLngLat) {
@@ -28,7 +37,7 @@ export class MultiPointHitTestStrategy {
         return false;
     }
     distance(feature, coordinate) {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         const latScale = latitudeScale(coordinate[1]);
         let min = Number.POSITIVE_INFINITY;
         for (const part of parts) {
@@ -52,7 +61,7 @@ export class MultiLineStringHitTestStrategy {
         });
     }
     test(feature, coordinate, toleranceLngLat) {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         const latScale = latitudeScale(coordinate[1]);
         for (const part of parts) {
             if (part.length === 0)
@@ -64,7 +73,7 @@ export class MultiLineStringHitTestStrategy {
         return false;
     }
     distance(feature, coordinate) {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         const latScale = latitudeScale(coordinate[1]);
         let min = Number.POSITIVE_INFINITY;
         for (const part of parts) {
@@ -75,7 +84,7 @@ export class MultiLineStringHitTestStrategy {
         return min;
     }
     testDistance(feature, coordinate, toleranceLngLat) {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         const latScale = latitudeScale(coordinate[1]);
         let min = Number.POSITIVE_INFINITY;
         for (const part of parts) {
@@ -111,7 +120,7 @@ export class MultiPolygonHitTestStrategy {
         });
     }
     test(feature, coordinate, toleranceLngLat) {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         for (const rings of parts) {
             if (this.polygonStrategy.testRings(rings, coordinate, toleranceLngLat)) {
                 return true;
@@ -120,7 +129,7 @@ export class MultiPolygonHitTestStrategy {
         return false;
     }
     distance(feature, coordinate) {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         let min = Number.POSITIVE_INFINITY;
         for (const rings of parts) {
             min = Math.min(min, this.polygonStrategy.distanceToRings(rings, coordinate));
@@ -128,7 +137,7 @@ export class MultiPolygonHitTestStrategy {
         return min;
     }
     testDistance(feature, coordinate, toleranceLngLat) {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         let min = Number.POSITIVE_INFINITY;
         for (const rings of parts) {
             const distance = this.polygonStrategy.testDistanceRings(rings, coordinate, toleranceLngLat);

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

@@ -4,17 +4,19 @@
  * 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';
+import type { Feature, FeatureType } from '../../../api/model.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.
+ * The distance is measured in a local frame around the click, where a degree of longitude is
+ * scaled by the cosine of the latitude. A feature type drawn as a point can reuse it, or
+ * extend it to widen the hit area. The engine uses it as the hit test of its points.
  */
-export declare class PointHitTestStrategy implements HitTestStrategy {
+export declare class PointHitTestStrategy {
     /** The feature type, `'Point'` */
     readonly geometryType: FeatureType;
-    test(feature: Feature, coordinate: Coordinate, toleranceLngLat: number): boolean;
-    distance(feature: Feature, coordinate: Coordinate): number;
+    /** Whether the feature is within `toleranceLngLat` degrees of the coordinate */
+    test(feature: Feature, coordinate: [number, number], toleranceLngLat: number): boolean;
+    /** The distance from the coordinate to the feature, in degrees of the local frame */
+    distance(feature: Feature, coordinate: [number, number]): number;
 }

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

@@ -1,11 +1,13 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
+import { coordinatesOf } from '../../../shared/utils/coordinates.js';
 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.
+ * The distance is measured in a local frame around the click, where a degree of longitude is
+ * scaled by the cosine of the latitude. A feature type drawn as a point can reuse it, or
+ * extend it to widen the hit area. The engine uses it as the hit test of its points.
  */
 export class PointHitTestStrategy {
     constructor() {
@@ -17,13 +19,15 @@ export class PointHitTestStrategy {
             value: 'Point'
         });
     }
+    /** Whether the feature is within `toleranceLngLat` degrees of the coordinate */
     test(feature, coordinate, toleranceLngLat) {
-        const pointCoord = feature.coordinates;
+        const pointCoord = coordinatesOf(feature);
         const dist = localDistance(coordinate, pointCoord, latitudeScale(coordinate[1]));
         return dist <= toleranceLngLat;
     }
+    /** The distance from the coordinate to the feature, in degrees of the local frame */
     distance(feature, coordinate) {
-        const pointCoord = feature.coordinates;
+        const pointCoord = coordinatesOf(feature);
         return localDistance(coordinate, pointCoord, latitudeScale(coordinate[1]));
     }
 }

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

@@ -1,10 +1,3 @@
-/**
- * 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';
 /**

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

@@ -1,5 +1,13 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * 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 { coordinatesOf } from '../../../shared/utils/coordinates.js';
 import { latitudeScale, localPointToSegmentDistance } from '../local-frame.js';
 import { polylineDistanceWithin } from '../segment-grid.js';
 /**
@@ -15,15 +23,15 @@ export class PolygonHitTestStrategy {
         });
     }
     test(feature, coordinate, toleranceLngLat) {
-        const rings = feature.coordinates;
+        const rings = coordinatesOf(feature);
         return this.testRings(rings, coordinate, toleranceLngLat);
     }
     distance(feature, coordinate) {
-        const rings = feature.coordinates;
+        const rings = coordinatesOf(feature);
         return this.distanceToRings(rings, coordinate);
     }
     testDistance(feature, coordinate, toleranceLngLat) {
-        const rings = feature.coordinates;
+        const rings = coordinatesOf(feature);
         return this.testDistanceRings(rings, coordinate, toleranceLngLat);
     }
     /**

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

@@ -1,4 +1,4 @@
-import type { Dataset } from '../../display/types.js';
+import type { Dataset } from '../../dataset/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';