@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/modes/handler.d.ts

@@ -1,285 +1 @@
-/**
- * ModeHandler
- *
- * Handler interface for the drawing modes.
- * Every mode implements this interface.
- */
-import type { Map as MapLibreMap } from 'maplibre-gl';
-import type { DragNormalizedEvent, KeyNormalizedEvent, MouseNormalizedEvent } from '../dispatcher/types.js';
-import type { Mode } from '../store/types.js';
-/**
- * An input whose coordinates go through snapping, as asked about by
- * {@link ModeHandler.isSnapEnabledFor}.
- *
- * Corresponds one to one with the inputs whose coordinates InputRouter passes through snapping
- * (click / mousemove / dragstart / dragmove / dragend).
- */
-export type SnapInputType = 'click' | 'mousemove' | 'dragstart' | 'dragmove' | 'dragend';
-/**
- * The services of the draw instance a mode works with, passed to
- * {@link ModeHandler.onStart}.
- *
- * Note: the redraw is triggered automatically by RenderCoordinator subscribing to Store changes,
- *       so a mode does not need to call requestRepaint() explicitly.
- */
-export interface ModeContext {
-    /** The map the draw instance is attached to */
-    map: MapLibreMap;
-    /** The Store of the document; a mode writes features through it */
-    store: import('../store/store.js').Store;
-    /**
-     * The queries of the spatial index (it is derived from the Store, so a mode only reads it)
-     */
-    spatialIndex: import('../store/spatial/spatial-index.js').SpatialQuery;
-    /** The hit test of the features of the Store alone */
-    hitTestService: import('../dispatcher/hit-test/service.js').HitTestService;
-    /**
-     * Returns the foreground hit in the visual stacking order (unified z traversal)
-     *
-     * Traverses the features of the Store and the datasets in a single
-     * stacking order. Selection, drag and cursor decisions use this one (`hitTestService.hitTest`
-     * looks only at the Store, so it would grab a feature that is occluded by a dataset).
-     */
-    hitTestTopmost: import('../dispatcher/hit-test/topmost.js').HitTestTopmost;
-    /**
-     * Provider of the companion rendering and the companion hits (the ones of this draw instance)
-     *
-     * Used to return a consumed companion hit to the provider.
-     */
-    featureCompanions: import('../view/feature-companion.js').FeatureCompanionRegistry;
-    /**
-     * The selection scope of this draw instance (the extension points of the custom feature
-     * types, the auxiliary handles and the thinned handle sets)
-     *
-     * The same object the CustomLayer draws the selection UI with, so hit testing and rendering
-     * agree, and a second draw instance on the page never takes part.
-     */
-    selectionScope: import('../view/ui/selection-scope.js').SelectionScope;
-    /** The emitter of the `draw.*` events of the draw instance */
-    eventEmitter: import('../shared/utils/event-emitter.js').EventEmitter;
-    /** The resolved colors and sizes of the selection UI */
-    selectionStyle: import('../shared/config/selection.js').SelectionUIConfig;
-    /**
-     * Topology configuration (simultaneous movement of shared vertices, and so on)
-     *
-     * When omitted, it is treated as the default value (everything disabled).
-     */
-    topology?: import('../shared/config/topology.js').TopologyConfig;
-    /**
-     * Trace configuration (whether edge tracing is enabled or disabled)
-     *
-     * When omitted, it is treated as the default value (enabled). It is the same object that
-     * draw.tracing rewrites, so a switch at runtime takes effect on the very next input.
-     */
-    trace?: import('../shared/config/trace.js').TraceConfig;
-    /**
-     * The resolved snapping options
-     *
-     * Read so that the simultaneous movement of shared vertices shares the "modifier key for
-     * temporary disabling" with snapping. When snapping is not configured, it is omitted and
-     * the default 'alt' is assumed.
-     */
-    snapOptions?: import('../snapping/types.js').ResolvedSnapOptions;
-    /** Generates the default name of a new feature (such as "Polygon 3") */
-    autoNameGenerator: import('../shared/utils/name-generator.js').AutoNameGenerator;
-    /** The box selection strategies by feature type */
-    boxSelectionRegistry: import('../dispatcher/hit-test/box-strategy.js').BoxSelectionStrategyRegistry;
-    /** The plugin manager of the draw instance (omitted when none is set up) */
-    pluginManager?: import('../plugins/plugin-manager.js').PluginManager;
-    /** Requests a mode change, as `draw.setMode` does (the same refusals apply) */
-    setMode: (mode: Mode) => void;
-    /** Generates a new unique feature id */
-    generateFeatureId: () => string;
-    /**
-     * Gets the ID of the writable layer, the layer that new features are written into
-     *
-     * The active layer when it exists, is not locked, is visible and is not locally hidden,
-     * otherwise the first such layer, otherwise an empty string. A mode reads it when it
-     * commits a feature; when it is an empty string the mode must not create the feature: it
-     * discards the drawing (clears the tentative state) and returns to select.
-     */
-    getCurrentLayerId: () => string;
-    /**
-     * Whether the line widths of the features a drawing mode creates follow the zoom (the
-     * `scaleWithZoom` option of the instance)
-     *
-     * When it is true, a mode writes the zoom of the commit into `properties.createdZoom`, and
-     * the widths of the feature grow and shrink with the map from there. When it is false, it
-     * writes no created zoom and the widths stay the same on the screen.
-     */
-    scaleWithZoom: boolean;
-    /**
-     * Gets the most recent snapping result (always null when snapping is not configured)
-     *
-     * This is the only read port through which a mode learns about snapping. InputRouter passes
-     * the coordinates of click / mousemove through snapping before delivering them to the mode,
-     * so at the time of onClick / onMouseMove the result readable here is the snapping result
-     * corresponding to the event that was just delivered (tracing reads it).
-     */
-    getSnapResult?: () => import('../snapping/types.js').SnapResult | null;
-    /**
-     * Gets a feature of a dataset (omitted when it is not configured)
-     *
-     * This is the port through which a mode resolves to a feature a snap target that was snapped
-     * to data (a dataset). It is a feature that is not in the Store, so it cannot
-     * be looked up with store.getFeature (tracing reads it).
-     */
-    getDatasetFeature?: (datasetId: string, featureId: string) => import('../store/types.js').Feature | null;
-    /**
-     * Looks up, by extent, the features of the datasets usable for tracing
-     *
-     * This is the port for adding the features of data (a dataset) to the material
-     * of the edge graph. It returns an empty array when snapping to data is disabled.
-     */
-    getDatasetTraceFeatures?: (bbox: import('../store/types.js').BoundingBox) => import('../store/types.js').Feature[];
-}
-/**
- * The implementation of an interaction mode: it receives the normalized input while it is the
- * current mode.
- *
- * Register a custom mode with `draw.registerMode(name, factory)` or `Plugin.modes`, and enter
- * it with `draw.setMode(name)`. The context is passed in `onStart()` and the implementation
- * keeps it in a field; it is not passed to the event handlers. Every handler is optional. The
- * coordinates of the pointer events have already gone through snapping (see
- * `isSnapEnabledFor`).
- *
- * @example
- * ```ts
- * import type { ModeContext, ModeHandler, MouseNormalizedEvent } from '@sakuzu/maplibre-gl-draw';
- *
- * // A mode that logs the clicked position and returns to select on Escape
- * class ProbeMode implements ModeHandler {
- *   readonly modeName = 'probe';
- *   private context: ModeContext | null = null;
- *
- *   onStart(context: ModeContext): void {
- *     this.context = context;
- *   }
- *   onClick(event: MouseNormalizedEvent): void {
- *     console.log(event.lngLat.lng, event.lngLat.lat);
- *   }
- *   onKeyDown(event: { key: string }): void {
- *     if (event.key === 'Escape') this.context?.setMode('select');
- *   }
- * }
- *
- * draw.registerMode('probe', () => new ProbeMode());
- * draw.setMode('probe');
- * ```
- */
-export interface ModeHandler {
-    /** The name the mode is registered under */
-    readonly modeName: Mode;
-    /**
-     * Whether the mode writes new features into a layer
-     *
-     * A mode that declares true is entered only while a layer can be written (while
-     * `ModeContext.getCurrentLayerId` returns a non-empty string); otherwise setMode is ignored
-     * and the current mode is kept. The built-in drawing modes declare it, and a plugin mode
-     * that creates features declares it to get the same gate. The declaration does not remove
-     * the check at commit time: the layer can stop being writable while the mode is active.
-     */
-    readonly writesFeatures?: boolean;
-    /** Called when the mode becomes the current mode; keep the context for later */
-    onStart?(context: ModeContext): void;
-    /** Called when another mode replaces it or the draw instance is destroyed */
-    onStop?(): void;
-    /** Called on a click */
-    onClick?(event: MouseNormalizedEvent): void;
-    /** Called on a double click */
-    onDoubleClick?(event: MouseNormalizedEvent): void;
-    /** Called on a mouse move */
-    onMouseMove?(event: MouseNormalizedEvent): void;
-    /**
-     * Called on a mouse down
-     * @returns returning true consumes the event (stops the propagation to MapLibre)
-     */
-    onMouseDown?(event: MouseNormalizedEvent): boolean | undefined;
-    /** Called on a mouse up */
-    onMouseUp?(event: MouseNormalizedEvent): void;
-    /** Called when a drag starts */
-    onDragStart?(event: DragNormalizedEvent): void;
-    /** Called during a drag */
-    onDragMove?(event: DragNormalizedEvent): void;
-    /** Called when a drag ends */
-    onDragEnd?(event: DragNormalizedEvent): void;
-    /**
-     * Called when a press ends without a release (a second finger touched the screen, or the
-     * browser cancelled the touch)
-     *
-     * Nothing is decided: the mode abandons the press, restores what the press changed and
-     * gives the pan back to MapLibre. It can arrive before onDragStart (a press that has not
-     * become a drag yet). The coordinates are the last known position.
-     */
-    onDragCancel?(event: DragNormalizedEvent): void;
-    /** Called on a key down (normalized) */
-    onKeyDown?(event: KeyNormalizedEvent): void;
-    /** Called on a key up (normalized) */
-    onKeyUp?(event: KeyNormalizedEvent): void;
-    /**
-     * Called after an external state change
-     *
-     * Used to reset the internal state of the mode after an external state change
-     * (a change applied from outside the mode) has been carried out.
-     * Example: when the state is changed externally while drawing in the Circle mode,
-     * the drawing state is reset.
-     */
-    onExternalStateChange?(): void;
-    /**
-     * Called after a selection change
-     *
-     * Used to update the internal state of the mode when the selection is changed from a plugin.
-     */
-    onSelectionChange?(): void;
-    /**
-     * Undoes a vertex while drawing
-     *
-     * Called when Cmd+Z/Ctrl+Z is pressed while drawing a LineString/Polygon.
-     * @returns whether the undo was carried out
-     */
-    undoVertex?(): boolean;
-    /**
-     * Redoes a vertex that was undone
-     *
-     * Called when Cmd+Shift+Z/Ctrl+Y is pressed while drawing.
-     * @returns whether the redo was carried out
-     */
-    redoVertex?(): boolean;
-    /**
-     * Returns the feature to prefer when snapping candidates are tied
-     *
-     * Read by InputRouter right before it passes the coordinates through snapping, and passed as
-     * the preferFeature of SnapContext. A drawing mode returns the anchor of the trace (the
-     * boundary it started tracing along), which prevents the snap target from jumping to another
-     * feature whose coordinates overlap exactly.
-     *
-     * @returns the feature to prefer, or null if there is none
-     */
-    getSnapPreference?(): {
-        featureId: string;
-        datasetId?: string;
-    } | null;
-    /**
-     * Returns, per input type, whether snapping is to be applied
-     *
-     * Read by InputRouter right before it passes the coordinates through snapping. An input type
-     * for which false is returned does not go through SnapService and reaches the mode with its
-     * raw coordinates. When this is omitted (and when true is returned), snapping is applied as
-     * before.
-     *
-     * The tolerance (10 pixels by default) is a value premised on "once per click", so in a
-     * drag-driven drawing that passes several hundred points in a single stroke (freehand), the
-     * intermediate sample points are pulled one after another to nearby vertices and a line drawn
-     * straight ends up bent. A port that can be switched off per input type is provided so that
-     * only the inside of the stroke can be let through untouched (the start point and the end
-     * point can remain snapped).
-     *
-     * @param inputType the type of the input for which snapping is about to be applied
-     * @returns true if snapping is to be applied
-     */
-    isSnapEnabledFor?(inputType: SnapInputType): boolean;
-}
-/**
- * Creates a new {@link ModeHandler}; called every time the mode is entered.
- */
-export type ModeFactory = () => ModeHandler;
+export {};

package/dist/modes/manager.d.ts

@@ -1,4 +1,4 @@
-import type { ModeHandler } from './handler.js';
+import type { EngineModeHandler } from './handler.js';
 /**
  * Options of ModeManagerImpl
  */
@@ -11,5 +11,5 @@ export interface ModeManagerOptions {
      * `writesFeatures`). When it returns false the request is ignored and the current mode is
      * kept, like the interaction lock. When it is omitted, every registered mode can be entered.
      */
-    canEnter?: (handler: ModeHandler) => boolean;
+    canEnter?: (handler: EngineModeHandler) => boolean;
 }

package/dist/modes/manager.js

@@ -103,6 +103,9 @@ export class ModeManagerImpl {
                 this.unregisterMode(mode);
         };
     }
+    hasMode(mode) {
+        return this.factories.has(mode);
+    }
     unregisterMode(mode) {
         if (!this.factories.has(mode))
             return;

package/dist/modes/select/box-selection.d.ts

@@ -1,12 +1,12 @@
 import type { BoxSelection, Coordinate, Feature } from '../../store/types.js';
-import type { ModeContext } from '../handler.js';
+import type { EngineModeContext } from '../handler.js';
 /**
  * Detect the features inside the box
  *
  * First the candidates are obtained quickly through the SpatialIndex (rbush),
  * and then a precise inside-the-box test is performed.
  */
-export declare function queryFeaturesInBox(boxSelection: BoxSelection, context: ModeContext): string[];
+export declare function queryFeaturesInBox(boxSelection: BoxSelection, context: EngineModeContext): string[];
 type Rect = {
     minX: number;
     minY: number;
@@ -37,7 +37,7 @@ export declare function isFeatureInBox(feature: Feature, rect: {
     minY: number;
     maxX: number;
     maxY: number;
-}, boxSelectionRegistry: ModeContext['boxSelectionRegistry']): boolean;
+}, boxSelectionRegistry: EngineModeContext['boxSelectionRegistry']): boolean;
 /**
  * The fallback box selection test
  *

package/dist/modes/select/box-selection.js

@@ -5,6 +5,7 @@
  *
  * Responsible for handling box selection in select mode
  */
+import { coordinatesOf } from '../../shared/utils/coordinates.js';
 import { isLocallyHidden } from '../../store/local-visibility.js';
 /**
  * Detect the features inside the box
@@ -111,7 +112,7 @@ export function fallbackBoxSelection(feature, rect) {
             coord[1] >= rect.minY &&
             coord[1] <= rect.maxY);
     };
-    const coords = feature.coordinates;
+    const coords = coordinatesOf(feature);
     // When the coordinates are a single point
     if (Array.isArray(coords) &&
         coords.length === 2 &&

package/dist/modes/select/click-handler.d.ts

@@ -8,25 +8,25 @@
  *      (LineString / Polygon / the Multi types) -> vertex selection
  *   3. Unified z traversal (hitTestTopmost) -> if it is a Store feature, the selection is
  *      updated / shift+click toggles / re-clicking an already selected feature is delegated to
- *      pluginManager.handleFeatureClick.
+ *      plugins.handleFeatureClick.
  *      If a dataset is in the foreground, Store features are not grabbed and it
  *      is treated as clearing the selection.
  *      If a feature companion is in the foreground, the click is consumed and passed to the
  *      provider (the selection is left unchanged)
  *
- * Double click: selects the feature and notifies pluginManager.handleFeatureDoubleClick
+ * Double click: selects the feature and notifies plugins.handleFeatureDoubleClick
  */
 import type { MouseNormalizedEvent } from '../../dispatcher/types.js';
 import type { SelectionUIConfig } from '../../shared/config/selection.js';
-import type { ModeContext } from '../handler.js';
+import type { EngineModeContext } from '../handler.js';
 /**
  * The main logic of onClick
  */
-export declare function handleSelectClick(event: MouseNormalizedEvent, context: ModeContext, config: SelectionUIConfig): void;
+export declare function handleSelectClick(event: MouseNormalizedEvent, context: EngineModeContext, config: SelectionUIConfig): void;
 /**
  * The main logic of onDoubleClick
  *
  * A double click on a feature is consumed (its default action is prevented, so MapLibre does
  * not zoom); a double click on the empty map is left to MapLibre.
  */
-export declare function handleSelectDoubleClick(event: MouseNormalizedEvent, context: ModeContext): void;
+export declare function handleSelectDoubleClick(event: MouseNormalizedEvent, context: EngineModeContext): void;

package/dist/modes/select/click-handler.js

@@ -30,7 +30,7 @@ export function handleSelectClick(event, context, config) {
  * not zoom); a double click on the empty map is left to MapLibre.
  */
 export function handleSelectDoubleClick(event, context) {
-    if (context.pluginManager?.isPluginInteracting())
+    if (context.plugins?.isPluginInteracting())
         return;
     const { store } = context;
     const orderedFeatures = getDisplayFeatures(store);
@@ -39,13 +39,11 @@ export function handleSelectDoubleClick(event, context) {
     if (top?.kind !== 'store')
         return;
     event.originalEvent.preventDefault();
-    const filtered = context.pluginManager?.filterSelectionCandidates([top.feature.id]) ?? [
-        top.feature.id,
-    ];
+    const filtered = context.plugins?.filterSelectionCandidates([top.feature.id]) ?? [top.feature.id];
     if (filtered.length > 0) {
         store.setSelection('feature', filtered);
     }
-    context.pluginManager?.handleFeatureDoubleClick(top.feature.id);
+    context.plugins?.handleFeatureDoubleClick(top.feature.id, event);
 }
 /**
  * Click handling during a plugin interaction
@@ -53,7 +51,7 @@ export function handleSelectDoubleClick(event, context) {
  * @returns true when the click was consumed (= the caller skips the rest of the handling)
  */
 function handlePluginInteractionClick(event, context) {
-    const pm = context.pluginManager;
+    const pm = context.plugins;
     if (!pm?.isPluginInteracting())
         return false;
     const container = pm.getPluginInteractionContainer();
@@ -91,20 +89,20 @@ function handleVertexClick(event, selectedIds, context, config) {
     if (!featureId)
         return false;
     const vertexRef = handleHit.vertexRef;
-    const currentVertexSelection = store.getSelectedVertices();
+    const currentVertexSelection = store.getVertexSelection();
     if (event.modifiers.shift && currentVertexSelection?.featureId === featureId) {
         // Shift+click: add / remove a vertex of the same feature
-        const refs = currentVertexSelection.vertexIndices;
+        const refs = currentVertexSelection.vertices;
         if (hasVertexRef(refs, vertexRef)) {
             const newRefs = refs.filter((r) => !isSameVertexRef(r, vertexRef));
-            store.setSelectedVertices(newRefs.length === 0 ? null : { featureId, vertexIndices: newRefs });
+            store.setSelectedVertices(newRefs.length === 0 ? null : { featureId, vertices: newRefs });
         }
         else {
-            store.setSelectedVertices({ featureId, vertexIndices: [...refs, vertexRef] });
+            store.setSelectedVertices({ featureId, vertices: [...refs, vertexRef] });
         }
     }
     else {
-        store.setSelectedVertices({ featureId, vertexIndices: [vertexRef] });
+        store.setSelectedVertices({ featureId, vertices: [vertexRef] });
     }
     return true;
 }
@@ -114,17 +112,21 @@ function handleVertexClick(event, selectedIds, context, config) {
 function handleFeatureClick(event, selection, selectedIds, context) {
     const { store } = context;
     const orderedFeatures = getDisplayFeatures(store);
-    const top = context.hitTestTopmost(event.point, { orderedFeatures });
-    // A feature companion is in the foreground: the provider receives the click and core changes
-    // the selection in no way at all (not even clearing it as an empty click would). Core does not
-    // know what the companion is, so its job ends at consuming the click and reporting it.
+    let top = context.hitTestTopmost(event.point, { orderedFeatures });
+    // A feature companion is in the foreground: the provider receives the click. When it consumes
+    // it, core changes the selection in no way at all (not even clearing it as an empty click
+    // would); when it leaves it, the click is one on the feature that owns the companion
     if (top?.kind === 'companion') {
-        notifyFeatureCompanionClick(context.featureCompanions, top.companion);
-        return;
+        if (notifyFeatureCompanionClick(context.featureCompanions, top.companion, event))
+            return;
+        const owner = store.getFeature(top.companion.featureId);
+        if (!owner)
+            return;
+        top = { kind: 'store', feature: owner };
     }
     // When there is nothing, and when a dataset is in the foreground, Store
     // features are not grabbed. A dataset's click fires only when the intercepting side
-    // (display/interaction) is interactive.
+    // (dataset/interaction) is interactive.
     if (top?.kind !== 'store') {
         if (!event.modifiers.shift) {
             store.setSelection(null, []);
@@ -134,7 +136,7 @@ function handleFeatureClick(event, selection, selectedIds, context) {
     const feature = top.feature;
     // Re-clicking an already selected feature -> delegate to the plugins
     if (!event.modifiers.shift && selectedIds.length === 1 && selectedIds.includes(feature.id)) {
-        if (context.pluginManager?.handleFeatureClick(feature.id)) {
+        if (context.plugins?.handleFeatureClick(feature.id, event)) {
             return;
         }
     }
@@ -142,7 +144,7 @@ function handleFeatureClick(event, selection, selectedIds, context) {
     const candidateIds = event.modifiers.shift
         ? toggleSelection(selection, feature.id)
         : [feature.id];
-    const filtered = context.pluginManager?.filterSelectionCandidates(candidateIds) ?? candidateIds;
+    const filtered = context.plugins?.filterSelectionCandidates(candidateIds) ?? candidateIds;
     if (filtered.length === 0) {
         store.setSelection(null, []);
     }

package/dist/modes/select/cursor-handler.d.ts

@@ -11,5 +11,5 @@
  */
 import type { MouseNormalizedEvent } from '../../dispatcher/types.js';
 import type { SelectionUIConfig } from '../../shared/config/selection.js';
-import type { ModeContext } from '../handler.js';
-export declare function updateCursorForSelection(event: MouseNormalizedEvent, context: ModeContext, config: SelectionUIConfig): void;
+import type { EngineModeContext } from '../handler.js';
+export declare function updateCursorForSelection(event: MouseNormalizedEvent, context: EngineModeContext, config: SelectionUIConfig): void;

package/dist/modes/select/drag/intermediate-writes.js

@@ -128,7 +128,7 @@ export class IntermediateWrites {
      *
      * The last value of every feature that was touched (including features that followed along
      * through a shared vertex) is rewritten as a committed update (no options), gathered into a
-     * single store.transact. Because it is notified as one StateChanges, a subscriber that records
+     * single store.transact. Because it is notified as one StoreChange, a subscriber that records
      * changes can treat this batch as a single step with its existing mechanism.
      *
      * The committed value is simply the last diff that was recorded. That way it does not depend

package/dist/modes/select/drag/move.js

@@ -1,6 +1,6 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
-import { mapCoordinatesDeep } from '../../../shared/utils/coordinates.js';
+import { coordinatesOf, geometryFromCoordinates, mapCoordinatesDeep, } from '../../../shared/utils/coordinates.js';
 import { dragStartLngLat } from './operation.js';
 /**
  * Translate coordinates
@@ -35,7 +35,7 @@ export class MoveDrag {
             const initialCoords = this.state.initialCoordinates.get(id);
             if (feature && initialCoords) {
                 const newCoords = translateCoordinates(initialCoords, dx, dy);
-                writes.write(store, id, { coordinates: newCoords });
+                writes.write(store, id, { geometry: geometryFromCoordinates(feature.type, newCoords) });
             }
         }
     }
@@ -48,7 +48,7 @@ export function startMoveDrag(event, featureIds, store) {
     for (const id of featureIds) {
         const feature = store.getFeature(id);
         if (feature) {
-            initialCoordinates.set(id, JSON.parse(JSON.stringify(feature.coordinates)));
+            initialCoordinates.set(id, JSON.parse(JSON.stringify(coordinatesOf(feature))));
         }
     }
     return new MoveDrag({

package/dist/modes/select/drag/operation.d.ts

@@ -8,14 +8,14 @@
  */
 import type { DragNormalizedEvent } from '../../../dispatcher/types.js';
 import type { Feature } from '../../../store/types.js';
-import type { ModeContext } from '../../handler.js';
+import type { EngineModeContext } from '../../handler.js';
 /** The Store a drag writes to */
-export type DragStore = ModeContext['store'];
+export type DragStore = EngineModeContext['store'];
 /**
  * The selection scope of the draw instance the drag belongs to (the resize and rotate
  * strategies of custom types, and the auxiliary handle providers). Null before a drag starts
  */
-export type DragScope = ModeContext['selectionScope'] | null;
+export type DragScope = EngineModeContext['selectionScope'] | null;
 /**
  * The drag start position (the exact position before the 3-pixel movement)
  */

package/dist/modes/select/drag/radius.js

@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
-import { haversineDistanceMeters, initialBearingDegrees } from '../../../geometry/index.js';
+import { haversineDistanceMeters, initialBearingDegrees } from '../../../geometry/distance.js';
+import { drawProperties } from '../../../shared/properties.js';
+import { coordinatesOf } from '../../../shared/utils/coordinates.js';
 /** @internal */
 export class RadiusDrag {
     constructor(state) {
@@ -31,8 +33,7 @@ export class RadiusDrag {
         const updates = {
             properties: {
                 ...feature.properties,
-                radiusMeters: newRadiusMeters,
-                radiusHandleAngle: newAngle,
+                ...drawProperties({ radiusMeters: newRadiusMeters, radiusHandleAngle: newAngle }),
             },
         };
         writes.write(store, this.state.featureId, updates);
@@ -45,5 +46,5 @@ export function startRadiusDrag(featureId, store) {
     const feature = store.getFeature(featureId);
     if (feature?.type !== 'Circle')
         return null;
-    return new RadiusDrag({ featureId, center: feature.coordinates });
+    return new RadiusDrag({ featureId, center: coordinatesOf(feature) });
 }

package/dist/modes/select/drag/transform.d.ts

@@ -5,12 +5,12 @@ import type { DragNormalizedEvent } from '../../../dispatcher/types.js';
 import type { HandleType } from '../../../shared/config/constants.js';
 import type { Feature } from '../../../store/types.js';
 import type { BoundingBoxCoords } from '../../../view/ui/selection-ui/index.js';
-import type { ModeContext } from '../../handler.js';
+import type { EngineModeContext } from '../../handler.js';
 import type { DragScope, DragStore } from './operation.js';
 /**
  * Start a resize drag from a bounding box handle
  */
-export declare function startResizeDrag(event: DragNormalizedEvent, handle: HandleType, bbox: BoundingBoxCoords, features: Feature[], map: ModeContext['map'], scope: DragScope): ResizeDrag;
+export declare function startResizeDrag(event: DragNormalizedEvent, handle: HandleType, bbox: BoundingBoxCoords, features: Feature[], map: EngineModeContext['map'], scope: DragScope): ResizeDrag;
 /**
  * Start a rotate drag from the rotation handle, and set the DragState it draws from
  */

package/dist/modes/select/drag/transform.js

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 import { computeResize, startResize } from '../../../operations/resize.js';
 import { computeRotation, getRotationDelta, startRotation } from '../../../operations/rotate.js';
+import { drawProperties } from '../../../shared/properties.js';
+import { geometryFromCoordinates } from '../../../shared/utils/coordinates.js';
 import { computeBoundingBox } from '../../../view/ui/selection-ui/index.js';
 import { dragStartLngLat, selectedFeaturesOf } from './operation.js';
 // === Resize operation ===
@@ -33,19 +35,21 @@ export class ResizeDrag {
             const resizeResults = computeResize(this.state, event.lngLat, [feature], this.scope?.extensions);
             const result = resizeResults.get(feature.id);
             if (result) {
-                const updates = { coordinates: result.coordinates };
+                const updates = {
+                    geometry: geometryFromCoordinates(feature.type, result.coordinates),
+                };
                 // Update the scale property when there is one (Text, Image, etc.)
                 if (result.scale !== undefined) {
                     updates.properties = {
                         ...feature.properties,
-                        scale: result.scale,
+                        ...drawProperties({ scale: result.scale }),
                     };
                 }
                 // For a Circle, also update the radiusMeters property
                 if (result.radiusMeters !== undefined && feature.type === 'Circle') {
                     updates.properties = {
                         ...feature.properties,
-                        radiusMeters: result.radiusMeters,
+                        ...drawProperties({ radiusMeters: result.radiusMeters }),
                     };
                 }
                 // For a custom resize, also update the width / height properties (Note, etc.)
@@ -95,12 +99,14 @@ export class RotateDrag {
         for (const [id, result] of rotateResults) {
             const feature = store.getFeature(id);
             if (feature) {
-                const updates = { coordinates: result.coordinates };
+                const updates = {
+                    geometry: geometryFromCoordinates(feature.type, result.coordinates),
+                };
                 // Update the rotation property when there is one (Text, Image, Note, etc.)
                 if (result.rotation !== undefined) {
                     updates.properties = {
                         ...feature.properties,
-                        rotation: result.rotation,
+                        ...drawProperties({ rotation: result.rotation }),
                     };
                 }
                 writes.write(store, id, updates);