@sakuzu/maplibre-gl-draw 1.0.0

package/dist/view/ui/bounds.js

@@ -0,0 +1,149 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { applyMarginToBoundingBox } from '../../shared/math/index.js';
+import { computeBoundingBox, hasZeroArea, resolvePointFrameExtentWith, } from './selection-ui/index.js';
+/**
+ * Compute the bounding box with a margin of a feature in geographic coordinates
+ *
+ * Supports every feature type:
+ * - Point: the icon size + the margin are computed in screen coordinates and converted
+ *   into geographic coordinates
+ * - LineString/Polygon: the margin is applied by applyMarginToBoundingBox
+ *
+ * @param feature The target feature
+ * @param transform The coordinate transform
+ * @param config The selection UI configuration
+ * @returns The bounding box with a margin in geographic coordinates, or null when it
+ * cannot be computed
+ */
+export function computeFeatureGeoBoundingBox(feature, transform, config, extensions) {
+    const margin = config.boundingBox.margin;
+    // Compute the bbox for the selection UI (the draw instance's custom types included)
+    const selectionBbox = computeBoundingBox(feature, extensions);
+    if (!selectionBbox)
+        return null;
+    // Zero area (a single-coordinate feature such as Point) is expanded in pixels on screen
+    if (hasZeroArea(selectionBbox)) {
+        return computeSingleCoordGeoBoundingBox(feature, selectionBbox.center, transform, margin, extensions);
+    }
+    // A bbox that has a size is expanded by the margin
+    const marginedBbox = applyMarginToBoundingBox(selectionBbox, margin, transform);
+    return {
+        ...marginedBbox,
+        center: selectionBbox.center,
+    };
+}
+/**
+ * Compute the combined geographic bounding box of several features (with a margin)
+ *
+ * @param features The array of target features
+ * @param transform The coordinate transform
+ * @param config The selection UI configuration
+ * @param extensions The draw instance's extension points (custom bounding boxes and point
+ *   frame extents)
+ * @returns The bounding box with a margin in geographic coordinates, or null when it
+ * cannot be computed
+ */
+export function computeCombinedGeoBoundingBox(features, transform, config, extensions) {
+    if (features.length === 0)
+        return null;
+    // For a single feature the OBB is returned as is
+    if (features.length === 1) {
+        return computeFeatureGeoBoundingBox(features[0], transform, config, extensions);
+    }
+    // For several features, an AABB containing all the vertices is computed
+    let minLng = Number.POSITIVE_INFINITY;
+    let maxLng = Number.NEGATIVE_INFINITY;
+    let minLat = Number.POSITIVE_INFINITY;
+    let maxLat = Number.NEGATIVE_INFINITY;
+    for (const feature of features) {
+        const bbox = computeFeatureGeoBoundingBox(feature, transform, config, extensions);
+        if (!bbox)
+            continue;
+        // Update the min/max of the 4 corners
+        const corners = [bbox.topLeft, bbox.topRight, bbox.bottomRight, bbox.bottomLeft];
+        for (const corner of corners) {
+            minLng = Math.min(minLng, corner[0]);
+            maxLng = Math.max(maxLng, corner[0]);
+            minLat = Math.min(minLat, corner[1]);
+            maxLat = Math.max(maxLat, corner[1]);
+        }
+    }
+    if (!Number.isFinite(minLng))
+        return null;
+    return {
+        topLeft: [minLng, maxLat],
+        topRight: [maxLng, maxLat],
+        bottomRight: [maxLng, minLat],
+        bottomLeft: [minLng, minLat],
+        center: [(minLng + maxLng) / 2, (minLat + maxLat) / 2],
+    };
+}
+/**
+ * Compute the bounding box with a margin of a single-coordinate feature in geographic coordinates
+ *
+ * The extent of the frame of a point (registrable per type; 12px square when unregistered)
+ * plus the margin is computed in screen coordinates and converted into geographic ones.
+ * The coordinate received is the center of the bbox (since features other than Point can
+ * also be zero-area, e.g. a MultiPoint with a single point; coordinates must not be
+ * treated as a Coordinate).
+ */
+function computeSingleCoordGeoBoundingBox(feature, coord, transform, margin, extensions) {
+    const center = transform.project(coord);
+    // The half width and half height of the frame of the point + the margin
+    const extent = extensions
+        ? extensions.resolvePointFrameExtent(feature)
+        : resolvePointFrameExtentWith(undefined, feature);
+    const halfWidth = extent.halfWidth + margin;
+    const halfHeight = extent.halfHeight + margin;
+    // Convert the 4 corners in screen coordinates into geographic coordinates
+    const topLeft = transform.unproject({ x: center.x - halfWidth, y: center.y - halfHeight });
+    const topRight = transform.unproject({ x: center.x + halfWidth, y: center.y - halfHeight });
+    const bottomRight = transform.unproject({ x: center.x + halfWidth, y: center.y + halfHeight });
+    const bottomLeft = transform.unproject({ x: center.x - halfWidth, y: center.y + halfHeight });
+    return {
+        topLeft: [topLeft.lng, topLeft.lat],
+        topRight: [topRight.lng, topRight.lat],
+        bottomRight: [bottomRight.lng, bottomRight.lat],
+        bottomLeft: [bottomLeft.lng, bottomLeft.lat],
+        center: coord,
+    };
+}
+/**
+ * Decide whether a point in geographic coordinates is inside a convex quadrilateral
+ *
+ * Uses the cross product method. It decides whether the point is inside the convex
+ * quadrilateral enclosed by the 4 corners.
+ *
+ * @param lngLat The geographic coordinate to test [lng, lat]
+ * @param bbox The bounding box in geographic coordinates
+ * @returns true when the point is inside the bbox
+ */
+export function isPointInGeoBoundingBox(lngLat, bbox) {
+    // Inside test for a convex quadrilateral (the cross product method)
+    const corners = [bbox.topLeft, bbox.topRight, bbox.bottomRight, bbox.bottomLeft];
+    // For each edge, decide which side the point is on
+    // If it is on the same side for every edge, it is inside
+    let sign = null;
+    for (let i = 0; i < 4; i++) {
+        const p1 = corners[i];
+        const p2 = corners[(i + 1) % 4];
+        // The edge vector
+        const edgeX = p2[0] - p1[0];
+        const edgeY = p2[1] - p1[1];
+        // The vector to the point
+        const toPointX = lngLat[0] - p1[0];
+        const toPointY = lngLat[1] - p1[1];
+        // The cross product (2D)
+        const cross = edgeX * toPointY - edgeY * toPointX;
+        if (sign === null) {
+            sign = cross >= 0 ? 1 : -1;
+        }
+        else {
+            if ((cross >= 0 ? 1 : -1) !== sign) {
+                return false;
+            }
+        }
+    }
+    return true;
+}

package/dist/view/ui/box-selection.d.ts

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

package/dist/view/ui/box-selection.js

@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { DEFAULT_BOX_SELECTION_STYLE_CONFIG } from '../../shared/config/rendering.js';
+import { FillShaderManager } from '../renderers/polygon/fill.js';
+import { StrokeRenderer } from '../renderers/stroke.js';
+/**
+ * BoxSelectionRenderer
+ *
+ * @internal
+ */
+export class BoxSelectionRenderer {
+    constructor(map, gl, styleConfig, pixelRatio) {
+        Object.defineProperty(this, "strokeRenderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fillShaderManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "styleConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // The rubber band is a rectangle on the screen, so it is never given elevation: its
+        // renderers are built without the draw instance's terrain (they draw flat)
+        this.strokeRenderer = new StrokeRenderer(map, gl, pixelRatio);
+        this.fillShaderManager = new FillShaderManager(gl);
+        this.styleConfig = styleConfig ?? DEFAULT_BOX_SELECTION_STYLE_CONFIG;
+    }
+    /**
+     * Make sure the shader exists
+     */
+    ensureShader(shaderData) {
+        this.strokeRenderer.ensureShader(shaderData);
+        this.fillShaderManager.ensureShader(shaderData);
+    }
+    /**
+     * Set the offset uniforms
+     */
+    setOffsetUniforms(uniforms) {
+        this.strokeRenderer.setOffsetUniforms(uniforms);
+        this.fillShaderManager.setOffsetUniforms(uniforms);
+    }
+    /**
+     * Draw the box selection UI
+     */
+    draw(boxSelection, projectionData, zoom) {
+        const { startPoint, endPoint } = boxSelection;
+        // Compute the 4 vertices of the rectangle (a closed ring)
+        const ring = [
+            [startPoint[0], startPoint[1]],
+            [endPoint[0], startPoint[1]],
+            [endPoint[0], endPoint[1]],
+            [startPoint[0], endPoint[1]],
+            [startPoint[0], startPoint[1]], // closing it
+        ];
+        // Draw the fill
+        this.fillShaderManager.drawPolygon(ring, this.styleConfig.fillColor, projectionData, zoom);
+        // Draw the frame (a dotted line)
+        const strokeStyle = {
+            width: this.styleConfig.strokeWidth,
+            color: this.styleConfig.strokeColor,
+            opacity: this.styleConfig.strokeOpacity,
+            lineStyle: 'dashed',
+            dashArray: this.styleConfig.dashArray,
+        };
+        this.strokeRenderer.draw(ring, strokeStyle, { widthUnit: 'pixels', closed: true }, zoom, projectionData);
+    }
+    /**
+     * Dispose of the resources
+     */
+    dispose() {
+        this.strokeRenderer.dispose();
+        this.fillShaderManager.dispose();
+    }
+}

package/dist/view/ui/handle-test.d.ts

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

package/dist/view/ui/handle-test.js

@@ -0,0 +1,437 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { applyMarginToBoundingBox } from '../../shared/math/index.js';
+import { nearestLongitude } from '../../shared/math/longitude.js';
+import { computeCombinedGeoBoundingBox, isPointInGeoBoundingBox } from './bounds.js';
+import { resolveMidpointCoordinate, resolveVertexCoordinate } from './handle-thinning.js';
+import { computeCircleRadiusHandle, computeMidpointHandles, computeResizeHandles, computeRotateHandle, computeVertexHandles, supportsVertexEditing, } from './handles.js';
+import { computeBoundingBox, computeCombinedBoundingBox, hasZeroArea, } from './selection-ui/index.js';
+/**
+ * A transform that projects every longitude on the copy of the world nearest to the pointer
+ *
+ * The handles are tested around the pointer. Across the antimeridian the feature on the other
+ * side of the line is drawn as a second copy, moved by 360 degrees, while its coordinates stay
+ * stored in [-180, 180] and the pointer unprojects to the unwrapped longitude of the view. The
+ * copy nearest to the pointer is the copy drawn there, so a handle is projected on it. Away from
+ * the antimeridian no longitude moves (nearestLongitude leaves anything within 180 degrees).
+ */
+function alignToPointer(transform, screenPoint) {
+    const reference = transform.unproject(screenPoint).lng;
+    return {
+        project: (lngLat) => transform.project([nearestLongitude(lngLat[0], reference), lngLat[1]]),
+        unproject: (point) => transform.unproject(point),
+    };
+}
+/**
+ * Determines, in screen coordinates, whether the point is inside the handle's rectangle
+ *
+ * Builds a rectangle from the handle's center position and radius (size/2), and determines
+ * whether the click position is inside that rectangle.
+ */
+function isPointInHandleRect(screenPoint, handleScreenPos, halfSize) {
+    return (screenPoint.x >= handleScreenPos.x - halfSize &&
+        screenPoint.x <= handleScreenPos.x + halfSize &&
+        screenPoint.y >= handleScreenPos.y - halfSize &&
+        screenPoint.y <= handleScreenPos.y + halfSize);
+}
+/**
+ * Hit test for the rotate handle
+ */
+function hitTestRotateHandle(marginedBbox, config, zoom, params) {
+    const handle = computeRotateHandle(marginedBbox, config.rotateHandle.distance, zoom);
+    const handleScreenPos = params.transform.project(handle.position);
+    const halfSize = config.rotateHandle.point.size / 2;
+    if (isPointInHandleRect(params.screenPoint, handleScreenPos, halfSize)) {
+        return { type: 'rotate' };
+    }
+    return null;
+}
+/**
+ * Hit test for the resize handles
+ *
+ * @param marginedBbox Bounding box after the margin is applied
+ * @param config Configuration of the selection UI
+ * @param params Hit test parameters
+ * @param getAdditionalHandles Callback that computes the additional handles (it receives
+ *   the bbox after the margin is applied)
+ */
+function hitTestResizeHandles(marginedBbox, config, params, getAdditionalHandles) {
+    const additionalHandles = getAdditionalHandles?.(marginedBbox);
+    const handles = computeResizeHandles(marginedBbox, additionalHandles);
+    const halfSize = config.resizeHandle.point.size / 2;
+    for (const handle of handles) {
+        const handleScreenPos = params.transform.project(handle.position);
+        if (isPointInHandleRect(params.screenPoint, handleScreenPos, halfSize)) {
+            return {
+                type: 'resize',
+                handle: handle.type,
+            };
+        }
+    }
+    return null;
+}
+/** Extra margin added to the pointer rectangle used for pre-filtering (pixels) */
+const POINTER_BOUNDS_MARGIN_PX = 2;
+/**
+ * Computes the longitude/latitude rectangle around the pointer
+ *
+ * Unprojects the four corners of the screen rectangle centered on the press point and
+ * builds their bounding box. Hit testing while thinning uses it to discard vertices outside
+ * this rectangle without projecting them. When it crosses longitude +/-180, pre-filtering
+ * is given up (null).
+ */
+function computePointerBounds(params, halfSize) {
+    const size = halfSize + POINTER_BOUNDS_MARGIN_PX;
+    const { x, y } = params.screenPoint;
+    const corners = [
+        params.transform.unproject({ x: x - size, y: y - size }),
+        params.transform.unproject({ x: x + size, y: y - size }),
+        params.transform.unproject({ x: x - size, y: y + size }),
+        params.transform.unproject({ x: x + size, y: y + size }),
+    ];
+    let minLng = Number.POSITIVE_INFINITY;
+    let minLat = Number.POSITIVE_INFINITY;
+    let maxLng = Number.NEGATIVE_INFINITY;
+    let maxLat = Number.NEGATIVE_INFINITY;
+    for (const corner of corners) {
+        minLng = Math.min(minLng, corner.lng);
+        maxLng = Math.max(maxLng, corner.lng);
+        minLat = Math.min(minLat, corner.lat);
+        maxLat = Math.max(maxLat, corner.lat);
+    }
+    // A large longitude difference despite a tiny screen rectangle means the date line was
+    // crossed
+    if (maxLng - minLng > 180)
+        return null;
+    return { minLng, minLat, maxLng, maxLat };
+}
+/**
+ * Whether the coordinate falls inside the pre-filter rectangle (always true if it is null)
+ */
+function isInPointerBounds(coord, bounds) {
+    if (!bounds)
+        return true;
+    // The rectangle is in the unwrapped longitudes of the pointer (alignToPointer)
+    const lng = nearestLongitude(coord[0], (bounds.minLng + bounds.maxLng) / 2);
+    return (lng >= bounds.minLng &&
+        lng <= bounds.maxLng &&
+        coord[1] >= bounds.minLat &&
+        coord[1] <= bounds.maxLat);
+}
+/**
+ * Hit test against the set of handles currently displayed
+ *
+ * The path used while thinning. Candidates are narrowed by the pointer rectangle before
+ * being projected, so it stays cheap however large the set is. The test itself is the same
+ * as in the full-enumeration path (isPointInHandleRect).
+ */
+function hitTestVisibleRefs(feature, refs, resolve, halfSize, params) {
+    const bounds = computePointerBounds(params, halfSize);
+    for (const ref of refs) {
+        const position = resolve(feature, ref);
+        if (!position)
+            continue;
+        if (!isInPointerBounds(position, bounds))
+            continue;
+        const handleScreenPos = params.transform.project(position);
+        if (isPointInHandleRect(params.screenPoint, handleScreenPos, halfSize)) {
+            // Do not hand out the reference stored in the cache as is (the caller keeps it)
+            return { ...ref };
+        }
+    }
+    return null;
+}
+/**
+ * Hit test for the vertex handles
+ *
+ * For a Polygon all rings (outer ring + inner rings) are covered, and for the Multi types
+ * the vertices of all parts. Because it uses the same computeVertexHandles as the
+ * rendering, every vertex that shows a handle can always be grabbed.
+ *
+ * While thinning, only the displayed set is covered. Circles that are not visible cannot be
+ * grabbed, but in exchange everything that can be grabbed is visible.
+ */
+function hitTestVertexHandles(feature, config, params) {
+    const halfSize = config.vertexHandle.point.size / 2;
+    const displayed = params.scope.thinning.getDisplayedSet(feature);
+    if (displayed) {
+        const vertexRef = hitTestVisibleRefs(feature, displayed.vertexRefs, resolveVertexCoordinate, halfSize, params);
+        return vertexRef ? { type: 'vertex', vertexRef, featureId: feature.id } : null;
+    }
+    const handles = computeVertexHandles(feature);
+    for (const handle of handles) {
+        const handleScreenPos = params.transform.project(handle.position);
+        if (isPointInHandleRect(params.screenPoint, handleScreenPos, halfSize)) {
+            return {
+                type: 'vertex',
+                vertexRef: handle.vertexRef,
+                featureId: feature.id,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Hit test for the midpoint handles
+ *
+ * For a Polygon all rings (outer ring + inner rings) are covered, and for the Multi types
+ * the edges of all parts. While thinning, only the displayed midpoints are covered.
+ */
+function hitTestMidpointHandles(feature, config, params) {
+    const halfSize = config.midpointHandle.point.size / 2;
+    const displayed = params.scope.thinning.getDisplayedSet(feature);
+    if (displayed) {
+        const vertexRef = hitTestVisibleRefs(feature, displayed.midpointRefs, resolveMidpointCoordinate, halfSize, params);
+        return vertexRef ? { type: 'midpoint', vertexRef, featureId: feature.id } : null;
+    }
+    const handles = computeMidpointHandles(feature);
+    for (const handle of handles) {
+        const handleScreenPos = params.transform.project(handle.position);
+        if (isPointInHandleRect(params.screenPoint, handleScreenPos, halfSize)) {
+            return {
+                type: 'midpoint',
+                vertexRef: handle.vertexRef,
+                featureId: feature.id,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Hit test for the radius handle of a Circle
+ */
+function hitTestCircleRadiusHandle(feature, config, params) {
+    const handle = computeCircleRadiusHandle(feature);
+    if (!handle)
+        return null;
+    const handleScreenPos = params.transform.project(handle.position);
+    const halfSize = config.radiusHandle.point.size / 2;
+    if (isPointInHandleRect(params.screenPoint, handleScreenPos, halfSize)) {
+        return { type: 'radius', featureId: feature.id };
+    }
+    return null;
+}
+/**
+ * Hit test for the auxiliary handles (provided by an extension implementation)
+ *
+ * Enumerating the handles is left to the callback (the aggregation of the providers), while
+ * the test is done with the same screen-px rectangle as the existing handles. To keep the
+ * grab feel uniform, the test size is the same as for the vertex handles (rendering is the
+ * provider's responsibility, so core knows only the positions).
+ */
+function hitTestAuxiliaryHandles(feature, config, zoom, params, getAuxiliaryHandles) {
+    const context = {
+        point: params.screenPoint,
+        project: (lngLat) => params.transform.project(lngLat),
+        unproject: (point) => params.transform.unproject(point),
+        zoom,
+    };
+    const halfSize = config.vertexHandle.point.size / 2;
+    for (const { providerId, handle } of getAuxiliaryHandles(context)) {
+        const handleScreenPos = params.transform.project(handle.position);
+        if (isPointInHandleRect(params.screenPoint, handleScreenPos, halfSize)) {
+            return {
+                type: 'auxiliary',
+                featureId: feature.id,
+                auxiliary: { providerId, handleId: handle.id, featureId: feature.id },
+                cursor: handle.cursor,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Hit test for the selection-independent auxiliary handles
+ *
+ * It can be called even when the selection is empty (hitTestHandles assumes a selection, so
+ * this is a separate entry point). The test size, the handling of the cursor and the shape
+ * of the returned HandleHitResult are identical to the auxiliary handles of the selection,
+ * and drag delegation goes through the same auxiliary path. The only difference is that
+ * "there is no feature it sits on", which is expressed by global / an empty featureId on
+ * the hit.
+ *
+ * @param getGlobalHandles Callback that enumerates the handles (when omitted, no test is
+ *   performed)
+ *
+ * @internal
+ */
+export function hitTestGlobalAuxiliaryHandles(screenPoint, transform, config, zoom, getGlobalHandles) {
+    if (!getGlobalHandles)
+        return null;
+    transform = alignToPointer(transform, screenPoint);
+    const context = {
+        point: screenPoint,
+        project: (lngLat) => transform.project(lngLat),
+        unproject: (point) => transform.unproject(point),
+        zoom,
+    };
+    const halfSize = config.vertexHandle.point.size / 2;
+    for (const { providerId, handle } of getGlobalHandles(context)) {
+        const handleScreenPos = transform.project(handle.position);
+        if (isPointInHandleRect(screenPoint, handleScreenPos, halfSize)) {
+            return {
+                type: 'auxiliary',
+                auxiliary: { providerId, handleId: handle.id, featureId: '', global: true },
+                cursor: handle.cursor,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Hit test against all handles
+ *
+ * Priority order:
+ * 1. Rotate handle
+ * 2. Resize handles (the four corners + the additional handles)
+ * 3. Auxiliary handles (provided by an extension implementation; single selection only)
+ * 4. Vertex handles
+ * 5. Midpoint handles
+ * 6. Inside of the bounding box (move)
+ *
+ * @param screenPoint Screen coordinates
+ * @param features The selected features
+ * @param transform Coordinate transform
+ * @param config Configuration of the selection UI
+ * @param zoom Zoom level
+ * @param scope The selection scope of the draw instance (extension points of the custom
+ *   types and the thinned handle sets that are displayed)
+ * @param getAdditionalResizeHandles Callback that computes the additional handles (it
+ *   receives the bbox after the margin is applied)
+ * @param getAuxiliaryHandles Callback that enumerates the auxiliary handles (when omitted,
+ *   the auxiliary handles are not tested)
+ *
+ * @internal
+ */
+export function hitTestHandles(screenPoint, features, transform, config, zoom, scope, getAdditionalResizeHandles, getAuxiliaryHandles) {
+    if (features.length === 0) {
+        return null;
+    }
+    transform = alignToPointer(transform, screenPoint);
+    // Compute the bbox with the margin in geographic coordinates (for the move test)
+    const geoBbox = computeCombinedGeoBoundingBox(features, transform, config, scope.extensions);
+    if (!geoBbox) {
+        return null;
+    }
+    // Compute the bbox without the margin (for computing the handle positions)
+    const rawBbox = computeCombinedBoundingBox(features, scope.extensions);
+    if (!rawBbox) {
+        return null;
+    }
+    // The bbox after the margin is applied (for computing the handle positions)
+    const margin = config.boundingBox.margin;
+    const marginedBbox = {
+        ...applyMarginToBoundingBox(rawBbox, margin, transform),
+        center: rawBbox.center,
+    };
+    const params = {
+        screenPoint,
+        transform,
+        scope,
+    };
+    // When only single-coordinate features (Point and the like) are selected, skip the rotate
+    // and resize handles
+    const singleFeatureBbox = features.length === 1 ? computeBoundingBox(features[0], scope.extensions) : null;
+    const isPointOnly = singleFeatureBbox !== null && hasZeroArea(singleFeatureBbox);
+    // A Circle has no rotate handle; it has a radius handle instead
+    const isCircle = features.length === 1 && features[0].type === 'Circle';
+    if (!isPointOnly) {
+        // For a Circle: the radius handle (in place of the rotate handle)
+        if (isCircle) {
+            const radiusHit = hitTestCircleRadiusHandle(features[0], config, params);
+            if (radiusHit)
+                return radiusHit;
+        }
+        else {
+            // 1. Rotate handle (anything other than a Circle)
+            const rotateHit = hitTestRotateHandle(marginedBbox, config, zoom, params);
+            if (rotateHit)
+                return rotateHit;
+        }
+        // 2. Resize handles (including the additional handles)
+        const resizeHit = hitTestResizeHandles(marginedBbox, config, params, getAdditionalResizeHandles);
+        if (resizeHit)
+            return resizeHit;
+    }
+    // 3. Auxiliary handles (single selection only; the same restriction as the existing
+    //    additional handles). They are taken after resize and before vertex. When they
+    //    overlap a vertex or a midpoint, the auxiliary handle wins (it is enough to move it
+    //    aside and then grab the vertex).
+    if (features.length === 1 && getAuxiliaryHandles) {
+        const auxiliaryHit = hitTestAuxiliaryHandles(features[0], config, zoom, params, getAuxiliaryHandles);
+        if (auxiliaryHit)
+            return auxiliaryHit;
+    }
+    // 4. Vertex handles (single selection only)
+    if (features.length === 1) {
+        const feature = features[0];
+        // Point, Text, Image, Circle and Freehand have no vertex handles (move only)
+        // Freehand does not support vertex editing (because it is a free curve)
+        if (supportsVertexEditing(feature.type)) {
+            const vertexHit = hitTestVertexHandles(feature, config, params);
+            if (vertexHit)
+                return vertexHit;
+            // 5. Midpoint handles (a MultiPoint has no edges, so the result is empty)
+            const midpointHit = hitTestMidpointHandles(feature, config, params);
+            if (midpointHit)
+                return midpointHit;
+        }
+    }
+    // 6. Inside of the bounding box (move)
+    // Convert the click position to geographic coordinates and test it
+    const geoLngLat = transform.unproject(screenPoint);
+    const geoPoint = [geoLngLat.lng, geoLngLat.lat];
+    if (isPointInGeoBoundingBox(geoPoint, geoBbox)) {
+        return { type: 'move' };
+    }
+    return null;
+}
+/**
+ * Gets the cursor that corresponds to the handle type
+ *
+ * @internal
+ */
+export function getCursorForHandle(hitResult) {
+    if (!hitResult)
+        return 'default';
+    switch (hitResult.type) {
+        case 'rotate':
+            return 'grab';
+        case 'resize': {
+            // The resize cursor that matches the handle position
+            switch (hitResult.handle) {
+                case 'resize-nw':
+                    return 'nw-resize';
+                case 'resize-n':
+                    return 'n-resize';
+                case 'resize-ne':
+                    return 'ne-resize';
+                case 'resize-e':
+                    return 'e-resize';
+                case 'resize-se':
+                    return 'se-resize';
+                case 'resize-s':
+                    return 's-resize';
+                case 'resize-sw':
+                    return 'sw-resize';
+                case 'resize-w':
+                    return 'w-resize';
+                default:
+                    return 'default';
+            }
+        }
+        case 'vertex':
+            return 'pointer';
+        case 'midpoint':
+            return 'crosshair';
+        case 'move':
+            return 'move';
+        case 'radius':
+            return 'pointer';
+        case 'auxiliary':
+            // The cursor specified by the auxiliary handle; if unset, 'pointer' as for vertices
+            return hitResult.cursor ?? 'pointer';
+        default:
+            return 'default';
+    }
+}