@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/view/terrain/drape/pass.js

@@ -16,6 +16,7 @@
  * When it does not hold, the caller drops to the previous vertex displacement path (a
  * two-stage arrangement). The condition for dropping is decided here by `canDrape`.
  */
+import { coordinatesOf } from '../../../shared/utils/coordinates.js';
 import { getCreatedZoom } from '../../../shared/utils/property.js';
 import { getDisplayFeatures, isLocallyHidden } from '../../../store/local-visibility.js';
 import { layerDrawFactors } from '../../renderers/draw-factors.js';
@@ -229,7 +230,7 @@ function collectStoreFeature(context, feature, layer, source, bakedOpacity) {
  *
  * So that the retained batch side does not draw the same features that were put on, the caller
  * tells the dataset "the polygons and lines are drawn by the drape"
- * (`drapedDatasets`). The test here and `collectFeature` in `display/retained.ts` form a
+ * (`drapedDatasets`). The test here and `collectFeature` in `dataset/retained.ts` form a
  * pair, so the condition must never be changed on only one side.
  */
 function collectDataset(context, dataset, source) {
@@ -252,7 +253,7 @@ function collectDataset(context, dataset, source) {
             if (rings.length === 0)
                 continue;
             const width = widthOf(feature, strokeStyle.width, context.pixelRatio);
-            pushElement(context, feature.coordinates, 0, rings, {
+            pushElement(context, coordinatesOf(feature), 0, rings, {
                 fill: fillColor,
                 stroke: [
                     strokeStyle.color[0],
@@ -281,7 +282,7 @@ function collectDataset(context, dataset, source) {
         if (paths.length === 0)
             continue;
         const width = widthOf(feature, strokeStyle.width, context.pixelRatio);
-        pushElement(context, feature.coordinates, 1, paths, {
+        pushElement(context, coordinatesOf(feature), 1, paths, {
             fill: [0, 0, 0, 0],
             stroke: [
                 strokeStyle.color[0],
@@ -313,14 +314,14 @@ function widthOf(feature, width, pixelRatio) {
 /** The rings of a polygon (with the closing point dropped) */
 function polygonRings(feature) {
     return feature.type === 'Polygon'
-        ? openRings(feature.coordinates)
-        : feature.coordinates.flatMap((part) => openRings(part));
+        ? openRings(coordinatesOf(feature))
+        : coordinatesOf(feature).flatMap((part) => openRings(part));
 }
 /** The paths of a line */
 function linePaths(feature) {
     const paths = feature.type === 'LineString' || feature.type === 'Freehand'
-        ? [feature.coordinates]
-        : feature.coordinates;
+        ? [coordinatesOf(feature)]
+        : coordinatesOf(feature);
     return paths.filter((path) => path.length >= 2);
 }
 /** Pushes an element */

package/dist/view/terrain/polygon.d.ts

@@ -2,19 +2,23 @@
  * The injection point for terrain subdivision of polygons
  *
  * Called from the polygon renderers (polygon/sdf-polygon.ts and polygon/batch.ts). When the
- * terrain is disabled, `getTerrainTessellationStep(context)` returns null and the caller does
+ * terrain is disabled, `terrainStepOf(context)` returns null and the caller does
  * nothing. Rendering without terrain therefore does not change by a single byte.
  */
+import type { TerrainAnchors } from '../../api/extension/context.js';
+import type { RenderContext } from '../../api/extension/render.js';
 import type { Coordinate } from '../../store/types.js';
 import type { TerrainContext } from './context.js';
 import { type MercatorRect, type TessellationStep } from './tessellation.js';
 /**
- * Returns the subdivision step of the terrain mesh for the current frame.
+ * Returns the subdivision step of the terrain mesh for the current frame, to cut a shape so
+ * that it follows the terrain (pass it to `densifyPath`).
  *
- * @param context The terrain state of the draw instance
- * @returns The step, or `null` when the terrain is disabled
+ * @param terrain - The render context of the draw call, or its `terrain`
+ * @returns The step, or `null` when the terrain is disabled (or the object was not handed out
+ *   by the engine)
  */
-export declare function getTerrainTessellationStep(context: TerrainContext): TessellationStep | null;
+export declare function terrainTessellationStep(terrain: RenderContext | TerrainAnchors): TessellationStep | null;
 /**
  * Decides the effective step for a single feature
  *

package/dist/view/terrain/polygon.js

@@ -1,16 +1,30 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
+import { terrainStateOf } from './binding.js';
 import { TERRAIN_MAX_BATCH_SUBDIVISION_CELLS, TERRAIN_MAX_COARSEN_STEPS, TERRAIN_MAX_SUBDIVISION_POINTS, TERRAIN_MAX_TILED_SUBDIVISION_POINTS, } from './metrics.js';
 import { getTerrainRenderState } from './state.js';
 import { cellsInRegion, densifyRings, mercatorX, mercatorY, rectsIntersect, subdivideTriangles, } from './tessellation.js';
 import { tilingSignature } from './tiling.js';
 /**
- * Returns the subdivision step of the terrain mesh for the current frame.
+ * Returns the subdivision step of the terrain mesh for the current frame, to cut a shape so
+ * that it follows the terrain (pass it to `densifyPath`).
+ *
+ * @param terrain - The render context of the draw call, or its `terrain`
+ * @returns The step, or `null` when the terrain is disabled (or the object was not handed out
+ *   by the engine)
+ */
+export function terrainTessellationStep(terrain) {
+    const state = terrainStateOf(terrain);
+    return state ? terrainStepOf(state) : null;
+}
+/**
+ * {@link terrainTessellationStep} over the terrain state of an instance
  *
  * @param context The terrain state of the draw instance
  * @returns The step, or `null` when the terrain is disabled
+ * @internal
  */
-export function getTerrainTessellationStep(context) {
+export function terrainStepOf(context) {
     const terrain = getTerrainRenderState(context);
     if (!terrain.active || !(terrain.stepGrid > 0))
         return null;

package/dist/view/terrain/state.d.ts

@@ -6,7 +6,7 @@
  * (`context.ts`; how a shared global broke with several instances is written there). Every
  * accessor takes that context explicitly: the renderers of a CustomLayer receive their
  * instance's context at construction, and extension renderers receive it in the draw context
- * (`CustomRendererDrawContext.terrain`). Nothing here reads "the instance drawn last".
+ * (`FrameDrawContext.terrain`). Nothing here reads "the instance drawn last".
  *
  * When the terrain is disabled, `INACTIVE_TERRAIN_STATE` is held and the shader's
  * `u_terrain_on` becomes 0. The vertex computation when it is 0 is exactly identical to

package/dist/view/terrain/state.js

@@ -8,7 +8,7 @@
  * (`context.ts`; how a shared global broke with several instances is written there). Every
  * accessor takes that context explicitly: the renderers of a CustomLayer receive their
  * instance's context at construction, and extension renderers receive it in the draw context
- * (`CustomRendererDrawContext.terrain`). Nothing here reads "the instance drawn last".
+ * (`FrameDrawContext.terrain`). Nothing here reads "the instance drawn last".
  *
  * When the terrain is disabled, `INACTIVE_TERRAIN_STATE` is held and the shader's
  * `u_terrain_on` becomes 0. The vertex computation when it is 0 is exactly identical to

package/dist/view/terrain/tessellation.d.ts

@@ -47,7 +47,7 @@ export interface MercatorRect {
 }
 /**
  * How finely a line or a fill is subdivided to follow the terrain mesh, as
- * {@link getTerrainTessellationStep} returns it.
+ * {@link terrainTessellationStep} returns it.
  */
 export interface TessellationStep {
     /**
@@ -193,7 +193,7 @@ export declare function latFromMercatorY(y: number): number;
  * on the original line).
  *
  * @param path The vertices `[lng, lat]` in degrees
- * @param step The step from {@link getTerrainTessellationStep}
+ * @param step The step from {@link terrainTessellationStep}
  * @returns The densified vertices. The input itself for fewer than 2 positions or a step of
  *   0; insertion stops when `step.maxPoints` is reached
  */

package/dist/view/terrain/tessellation.js

@@ -91,7 +91,7 @@ export function latFromMercatorY(y) {
  * on the original line).
  *
  * @param path The vertices `[lng, lat]` in degrees
- * @param step The step from {@link getTerrainTessellationStep}
+ * @param step The step from {@link terrainTessellationStep}
  * @returns The densified vertices. The input itself for fewer than 2 positions or a step of
  *   0; insertion stops when `step.maxPoints` is reached
  */

package/dist/view/ui/auxiliary-handles.d.ts

@@ -2,10 +2,10 @@
  * Extension point for the auxiliary handles
  *
  * A general-purpose hook for showing and grabbing handles on the selected feature that are
- * "neither a vertex nor a resize handle". All core holds is the hit testing and the drag
- * delegation; drawing the handles is the responsibility of the registering side (the plugin
- * of an extension implementation). core knows nothing at all about the meaning of a handle
- * (it only carries the position and the identifier).
+ * "neither a vertex nor a resize handle". Core draws them with the look of the vertex handles
+ * (the selection UI), hit tests them at the same size and delegates their drags. core knows
+ * nothing at all about the meaning of a handle (it only carries the position and the
+ * identifier).
  *
  * There are two ways to emit handles: those bound to the selected feature (getHandles) and
  * those that can always be emitted regardless of the selection (getGlobalHandles). The
@@ -72,31 +72,8 @@ export interface AuxiliaryHandleHit {
  * A source of handles on the selected feature that are neither vertices nor resize handles,
  * and the receiver of their drags.
  *
- * Register one with `draw.registerAuxiliaryHandleProvider(provider)`. The library hit tests
- * the handles and delegates their drags; drawing them is the provider's job (with an overlay
- * renderer, for example).
- *
- * @example
- * ```ts
- * import type { AuxiliaryHandleProvider } from '@sakuzu/maplibre-gl-draw';
- *
- * // A handle 20 px above the first vertex of the selected line, which logs its drag
- * const labelHandle: AuxiliaryHandleProvider = {
- *   id: 'label-handle',
- *   getHandles(feature, ctx) {
- *     if (feature.type !== 'LineString') return [];
- *     const first = (feature.coordinates as [number, number][])[0];
- *     const p = ctx.project(first);
- *     const { lng, lat } = ctx.unproject({ x: p.x, y: p.y - 20 });
- *     return [{ id: 'label', position: [lng, lat], cursor: 'move' }];
- *   },
- *   onHandleDragStart: () => true,
- *   onHandleDragMove: (event) => console.log(event.lngLat),
- *   onHandleDragEnd: () => {},
- * };
- *
- * const unregister = draw.registerAuxiliaryHandleProvider(labelHandle);
- * ```
+ * A `HandleProvider` of `draw.extensions.handleProviders` is installed as one. The engine draws
+ * the handles with the look of the vertex handles, hit tests them and delegates their drags.
  */
 export interface AuxiliaryHandleProvider {
     /** Identifier unique within the registry (re-registering with the same id overwrites) */

package/dist/view/ui/bounds.js

@@ -1,7 +1,7 @@
 // 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';
+import { computeBoundingBox, hasZeroArea, resolvePointFrameCornersWith, } from './selection-ui/index.js';
 /**
  * Compute the bounding box with a margin of a feature in geographic coordinates
  *
@@ -82,7 +82,8 @@ export function computeCombinedGeoBoundingBox(features, transform, config, exten
 /**
  * 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)
+ * The extent of the frame of a point (registrable per type; the marker of a built-in point, or
+ * a 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
@@ -90,17 +91,12 @@ export function computeCombinedGeoBoundingBox(features, transform, config, exten
  */
 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;
+    // The corners of the frame of the point (its outline, or its extent) + the margin
+    const corners = extensions
+        ? extensions.resolvePointFrameCorners(feature, center, margin)
+        : resolvePointFrameCornersWith(undefined, undefined, feature, center, 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 });
+    const [topLeft, topRight, bottomRight, bottomLeft] = corners.map((corner) => transform.unproject(corner));
     return {
         topLeft: [topLeft.lng, topLeft.lat],
         topRight: [topRight.lng, topRight.lat],

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

@@ -216,8 +216,8 @@ function hitTestCircleRadiusHandle(feature, config, params) {
  *
  * 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).
+ * grab feel uniform, the test size is the same as for the vertex handles, which is also the
+ * size the selection UI draws them at.
  */
 function hitTestAuxiliaryHandles(feature, config, zoom, params, getAuxiliaryHandles) {
     const context = {

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

@@ -14,7 +14,7 @@
  */
 import { HANDLE_THINNING_THRESHOLD, MIDPOINT_MIN_EDGE_PX, MIN_HANDLE_SPACING_PX, THINNING_REFRESH_DEBOUNCE_MS, } from '../../shared/config/selection.js';
 import { mercatorMidpoint } from '../../shared/math/globe-subdivision.js';
-import { supportsVertexEditing } from '../../shared/utils/coordinates.js';
+import { coordinatesOf, supportsVertexEditing } from '../../shared/utils/coordinates.js';
 import { isSameVertexRef } from '../../shared/utils/vertex-ref.js';
 /**
  * Decomposes a feature into scan units
@@ -26,15 +26,15 @@ import { isSameVertexRef } from '../../shared/utils/vertex-ref.js';
 function collectHandleRuns(feature) {
     const runs = [];
     if (feature.type === 'LineString') {
-        pushLineRun(runs, feature.coordinates);
+        pushLineRun(runs, coordinatesOf(feature));
     }
     else if (feature.type === 'Polygon') {
-        pushPolygonRuns(runs, feature.coordinates);
+        pushPolygonRuns(runs, coordinatesOf(feature));
     }
     else if (feature.type === 'MultiPoint') {
         // Splitting a MultiPoint per part would adopt every point and defeat the thinning, so
         // all parts are scanned as a single sequence
-        const points = feature.coordinates;
+        const points = coordinatesOf(feature);
         runs.push({
             coords: points,
             vertexCount: points.length,
@@ -44,13 +44,13 @@ function collectHandleRuns(feature) {
         });
     }
     else if (feature.type === 'MultiLineString') {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         for (let part = 0; part < parts.length; part++) {
             pushLineRun(runs, parts[part], part);
         }
     }
     else if (feature.type === 'MultiPolygon') {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         for (let part = 0; part < parts.length; part++) {
             pushPolygonRuns(runs, parts[part], part);
         }
@@ -112,25 +112,25 @@ export function countPotentialHandles(feature) {
     if (feature.type === 'Point')
         return 1;
     if (feature.type === 'LineString') {
-        return countLineHandles(feature.coordinates.length);
+        return countLineHandles(coordinatesOf(feature).length);
     }
     if (feature.type === 'Polygon') {
-        return countPolygonHandles(feature.coordinates);
+        return countPolygonHandles(coordinatesOf(feature));
     }
     if (feature.type === 'MultiPoint') {
         // Each coordinate is the vertex handle of one part. There are no edges
-        return feature.coordinates.length;
+        return coordinatesOf(feature).length;
     }
     if (feature.type === 'MultiLineString') {
         let total = 0;
-        for (const part of feature.coordinates) {
+        for (const part of coordinatesOf(feature)) {
             total += countLineHandles(part.length);
         }
         return total;
     }
     if (feature.type === 'MultiPolygon') {
         let total = 0;
-        for (const part of feature.coordinates) {
+        for (const part of coordinatesOf(feature)) {
             total += countPolygonHandles(part);
         }
         return total;
@@ -254,23 +254,23 @@ export function includeRequiredVertexRefs(set, required) {
 function getRefCoords(feature, ref) {
     const part = ref.part ?? 0;
     if (feature.type === 'Point') {
-        return [feature.coordinates];
+        return [coordinatesOf(feature)];
     }
     if (feature.type === 'LineString') {
-        return feature.coordinates;
+        return coordinatesOf(feature);
     }
     if (feature.type === 'Polygon') {
-        return feature.coordinates[ref.ring] ?? null;
+        return coordinatesOf(feature)[ref.ring] ?? null;
     }
     if (feature.type === 'MultiPoint') {
-        const point = feature.coordinates[part];
+        const point = coordinatesOf(feature)[part];
         return point ? [point] : null;
     }
     if (feature.type === 'MultiLineString') {
-        return feature.coordinates[part] ?? null;
+        return coordinatesOf(feature)[part] ?? null;
     }
     if (feature.type === 'MultiPolygon') {
-        return feature.coordinates[part]?.[ref.ring] ?? null;
+        return coordinatesOf(feature)[part]?.[ref.ring] ?? null;
     }
     return null;
 }

package/dist/view/ui/handles.js

@@ -1,8 +1,9 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
-import { destinationPoint } from '../../geometry/index.js';
+import { destinationPoint } from '../../geometry/distance.js';
 import { mercatorMidpoint } from '../../shared/math/globe-subdivision.js';
 import { applyMarginToBoundingBox, clampLatitude } from '../../shared/math/index.js';
+import { coordinatesOf } from '../../shared/utils/coordinates.js';
 import { getCircleRadius, getRadiusHandleAngle } from '../../shared/utils/property.js';
 import { hasVertexRef, isSameVertexRef } from '../../shared/utils/vertex-ref.js';
 import { includeRequiredVertexRefs, resolveMidpointCoordinate, resolveVertexCoordinate, } from './handle-thinning.js';
@@ -164,18 +165,18 @@ export function computeVertexHandles(feature, visibleSet) {
     const handles = [];
     if (feature.type === 'Point') {
         // A Point is a single vertex
-        const coord = feature.coordinates;
+        const coord = coordinatesOf(feature);
         handles.push({ type: 'vertex', position: coord, vertexRef: { ring: 0, index: 0 } });
     }
     else if (feature.type === 'LineString') {
-        collectLineVertexHandles(feature.coordinates, handles);
+        collectLineVertexHandles(coordinatesOf(feature), handles);
     }
     else if (feature.type === 'Polygon') {
-        collectPolygonVertexHandles(feature.coordinates, handles);
+        collectPolygonVertexHandles(coordinatesOf(feature), handles);
     }
     else if (feature.type === 'MultiPoint') {
         // Each coordinate is one part. ring / index are always 0
-        const points = feature.coordinates;
+        const points = coordinatesOf(feature);
         for (let part = 0; part < points.length; part++) {
             handles.push({
                 type: 'vertex',
@@ -185,13 +186,13 @@ export function computeVertexHandles(feature, visibleSet) {
         }
     }
     else if (feature.type === 'MultiLineString') {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         for (let part = 0; part < parts.length; part++) {
             collectLineVertexHandles(parts[part], handles, part);
         }
     }
     else if (feature.type === 'MultiPolygon') {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         for (let part = 0; part < parts.length; part++) {
             collectPolygonVertexHandles(parts[part], handles, part);
         }
@@ -208,7 +209,7 @@ export function computeCircleRadiusHandle(feature) {
     if (feature.type !== 'Circle') {
         return null;
     }
-    const center = feature.coordinates;
+    const center = coordinatesOf(feature);
     const radiusMeters = getCircleRadius(feature);
     const radiusHandleAngle = getRadiusHandleAngle(feature);
     if (!radiusMeters || radiusMeters <= 0) {
@@ -227,7 +228,7 @@ export function computeCircleCenterHandle(feature) {
     if (feature.type !== 'Circle') {
         return null;
     }
-    const center = feature.coordinates;
+    const center = coordinatesOf(feature);
     return {
         type: 'center',
         position: center,
@@ -283,19 +284,19 @@ export function computeMidpointHandles(feature, visibleSet) {
     }
     const handles = [];
     if (feature.type === 'LineString') {
-        collectLineMidpointHandles(feature.coordinates, handles);
+        collectLineMidpointHandles(coordinatesOf(feature), handles);
     }
     else if (feature.type === 'Polygon') {
-        collectPolygonMidpointHandles(feature.coordinates, handles);
+        collectPolygonMidpointHandles(coordinatesOf(feature), handles);
     }
     else if (feature.type === 'MultiLineString') {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         for (let part = 0; part < parts.length; part++) {
             collectLineMidpointHandles(parts[part], handles, part);
         }
     }
     else if (feature.type === 'MultiPolygon') {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         for (let part = 0; part < parts.length; part++) {
             collectPolygonMidpointHandles(parts[part], handles, part);
         }
@@ -528,6 +529,13 @@ export class SelectionHandlesRenderer {
         const handles = computeVertexHandles(feature).filter((h) => hasVertexRef(followedVertices, h.vertexRef));
         this.drawHandlesWithStyle(handles, this.config.vertexHandle.followed, zoom);
     }
+    /**
+     * Draws the auxiliary handles of the extensions with the look of the vertex handles, the
+     * size their hit test uses
+     */
+    drawAuxiliaryHandles(positions, zoom) {
+        this.drawHandlesWithStyle(positions.map((position) => ({ position })), this.config.vertexHandle.point, zoom);
+    }
     /**
      * Draws a group of handles with a single style
      *

package/dist/view/ui/helper.d.ts

@@ -16,4 +16,4 @@ import type { Store } from '../../store/store.js';
  * @param store The Store to read the selection from
  * @returns The feature ids. An empty array when nothing is selected
  */
-export declare function getSelectedFeatureIds(store: Store): string[];
+export declare function getSelectedFeatureIds(store: Store): readonly string[];

package/dist/view/ui/helper.js

@@ -32,7 +32,7 @@ function featureIdsInLayer(store, layerId) {
     if (!layer)
         return [];
     const ids = [];
-    for (const itemId of layer.order) {
+    for (const itemId of layer.items) {
         if (store.getFeature(itemId)) {
             ids.push(itemId);
         }

package/dist/view/ui/index.d.ts

@@ -9,7 +9,7 @@ export { getCursorForHandle, hitTestGlobalAuxiliaryHandles, hitTestHandles, } fr
 export type { HandleInfo } from './handles.js';
 export { computeMidpointHandles, computeResizeHandles, computeRotateHandle, computeVertexHandles, SelectionHandlesRenderer, } from './handles.js';
 export { computeSelectionBoundingBox, getSelectedFeatureIds, getSelectedFeatures, } from './helper.js';
-export type { AdditionalHandleInfo, AdditionalResizeHandlesCalculator, BoundingBoxCoords, CustomBoundingBoxCalculator, CustomResizeCalculator, PointFrameExtent, PointFrameExtentProvider, ResizeStrategy, SelectionExtensionRegistry, } from './selection-ui/index.js';
+export type { AdditionalHandleInfo, AdditionalResizeHandlesCalculator, BoundingBoxCoords, CustomBoundingBoxCalculator, PointFrameExtent, PointFrameExtentProvider, ResizeStrategy, SelectionExtensionRegistry, TypeResizeCalculator, } from './selection-ui/index.js';
 export { computeBoundingBox, computeCombinedBoundingBox, createSelectionExtensionRegistry, DEFAULT_POINT_FRAME_SIZE, rotateBoundingBox, SelectionUIRenderer, } from './selection-ui/index.js';
 export type { TentativeRendererDeps } from './tentative.js';
 export { TentativeRenderer } from './tentative.js';

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

@@ -15,10 +15,12 @@ import { createSelectionExtensionRegistry, } from './selection-ui/extension-regi
 /**
  * Creates the selection scope of one draw instance
  *
+ * @param options.defaultPointFrameExtent - The extent of the frame of a point whose type
+ *   registers none (see createSelectionExtensionRegistry)
  * @internal
  */
-export function createSelectionScope() {
-    const extensions = createSelectionExtensionRegistry();
+export function createSelectionScope(options = {}) {
+    const extensions = createSelectionExtensionRegistry(options.defaultPointFrameExtent);
     const auxiliaryHandles = createAuxiliaryHandleRegistry();
     const thinning = new HandleThinningCache();
     return {

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

@@ -13,6 +13,7 @@
 import { circleBoundingBox } from '../../../geometry/circle.js';
 import { pixelsToDegreesLat, pixelsToDegreesLng } from '../../../shared/math/index.js';
 import { fromPlane, toPlane } from '../../../shared/math/mercator-plane.js';
+import { coordinatesOf } from '../../../shared/utils/coordinates.js';
 import { getCircleRadius, getCreatedZoom, getImageProperties, } from '../../../shared/utils/property.js';
 import { getBoundingBox } from '../../../store/spatial/index.js';
 /**
@@ -45,7 +46,7 @@ export function computeBoundingBox(feature, extensions) {
         return customCalculator(feature, extensions.getTileSize());
     }
     if (feature.type === 'Point') {
-        const coord = feature.coordinates;
+        const coord = coordinatesOf(feature);
         return {
             topLeft: coord,
             topRight: coord,
@@ -80,7 +81,7 @@ export function computeBoundingBox(feature, extensions) {
  * The frame of a Circle: the extent of the geodesic circle as it is drawn, around its center
  */
 function computeCircleBoundingBox(feature) {
-    const center = feature.coordinates;
+    const center = coordinatesOf(feature);
     const radiusMeters = getCircleRadius(feature);
     const extent = radiusMeters && radiusMeters > 0 ? circleBoundingBox(center, radiusMeters) : null;
     if (!extent) {
@@ -108,13 +109,12 @@ function computeCircleBoundingBox(feature) {
  * (the same method as computeQuadVertices in quad-shader.ts).
  */
 function computeOrientedBoundingBox(feature) {
-    const coord = feature.coordinates;
+    const coord = coordinatesOf(feature);
     const [lng, lat] = coord;
     const tileSize = 512;
     const props = getImageProperties(feature);
-    const style = feature.style;
-    const imageWidth = style?.width || props.imageWidth || 100;
-    const imageHeight = style?.height || props.imageHeight || 100;
+    const imageWidth = props.imageWidth || 100;
+    const imageHeight = props.imageHeight || 100;
     const scale = props.scale ?? 1;
     // getImageProperties().createdZoom returns 0 when it is missing, so ?? does not work.
     // getCreatedZoom(number|undefined) is used so that 14 is the default when it is missing.