@sakuzu/maplibre-gl-draw 1.0.0

package/dist/modes/select/mode.js

@@ -0,0 +1,397 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SelectMode_context, _SelectMode_dragHandler, _SelectMode_config;
+import { DEFAULT_SELECTION_CONFIG } from '../../shared/config/selection.js';
+import { createCoordinateTransform } from '../../shared/math/index.js';
+import { getDisplayFeatures } from '../../store/local-visibility.js';
+import { computeCombinedGeoBoundingBox, isPointInGeoBoundingBox } from '../../view/ui/bounds.js';
+import { hitTestGlobalAuxiliaryHandles, hitTestHandles } from '../../view/ui/handle-test.js';
+import { computeSelectionBoundingBox, getSelectedFeatureIds, getSelectedFeatures, } from '../../view/ui/helper.js';
+import { queryFeaturesInBox } from './box-selection.js';
+import { handleSelectClick, handleSelectDoubleClick } from './click-handler.js';
+import { updateCursorForSelection } from './cursor-handler.js';
+import { SelectModeDragHandler } from './drag-handler.js';
+import { getAdditionalResizeHandlesCallback, getAuxiliaryHandlesCallback, getGlobalAuxiliaryHandlesCallback, } from './hit-helpers.js';
+import { handleDeleteShortcut, handleEscapeShortcut, handleGroupShortcut, handleNudgeShortcut, handleUngroupShortcut, } from './shortcut-handler.js';
+/**
+ * Whether the selection is a feature selection of exactly these IDs, in this order
+ */
+function selectsExactly(selection, ids) {
+    if (ids.length === 0)
+        return selection.type === null && selection.ids.length === 0;
+    return (selection.type === 'feature' &&
+        selection.ids.length === ids.length &&
+        selection.ids.every((id, i) => id === ids[i]));
+}
+/** @internal */
+export class SelectMode {
+    constructor() {
+        Object.defineProperty(this, "modeName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'select'
+        });
+        _SelectMode_context.set(this, void 0);
+        _SelectMode_dragHandler.set(this, new SelectModeDragHandler());
+        _SelectMode_config.set(this, DEFAULT_SELECTION_CONFIG);
+    }
+    // ============================================================================
+    // Lifecycle
+    // ============================================================================
+    onStart(context) {
+        __classPrivateFieldSet(this, _SelectMode_context, context, "f");
+        context.map.getCanvas().style.cursor = 'default';
+        // If there are features awaiting editing, notify plugins and clear the editing state
+        const editingIds = context.store.getEditingIds();
+        if (editingIds.length > 0) {
+            for (const id of editingIds) {
+                const feature = context.store.getFeature(id);
+                if (feature) {
+                    context.pluginManager?.notifyFeatureCreated(feature.id, feature.type);
+                }
+            }
+            context.store.endEditing([...editingIds]);
+        }
+    }
+    onStop() {
+        const { store, map, pluginManager } = __classPrivateFieldGet(this, _SelectMode_context, "f");
+        pluginManager?.finishPluginInteraction();
+        __classPrivateFieldGet(this, _SelectMode_dragHandler, "f").reset(store);
+        if (store.getBoxSelection())
+            store.setBoxSelection(null);
+        if (store.getSelectedVertices())
+            store.setSelectedVertices(null);
+        if (!map.dragPan.isEnabled())
+            map.dragPan.enable();
+        // Clear the selection when switching modes (not notified as a change)
+        store.transact(() => {
+            store.setSelection(null, []);
+        }, 'silent');
+    }
+    /**
+     * Called after a state change from the outside (a change applied from outside the mode).
+     * Resets the mode's internal state to keep it consistent.
+     */
+    onExternalStateChange() {
+        const { store } = __classPrivateFieldGet(this, _SelectMode_context, "f");
+        __classPrivateFieldGet(this, _SelectMode_dragHandler, "f").reset(store);
+        // The selection and the vertex selection follow the change by themselves (the Store
+        // drops what was deleted or hidden and the vertices whose coordinates changed)
+        if (store.getDragState())
+            store.setDragState(null);
+        if (store.getBoxSelection())
+            store.setBoxSelection(null);
+    }
+    // ============================================================================
+    // Mouse: down / up
+    // ============================================================================
+    /**
+     * Disable dragPan when a handle or a feature is hit on mouse down.
+     * @returns true when there was a hit (the event is consumed)
+     */
+    onMouseDown(event) {
+        const { pluginManager, map, store } = __classPrivateFieldGet(this, _SelectMode_context, "f");
+        // During a plugin interaction: consume clicks inside the container
+        if (pluginManager?.isPluginInteracting()) {
+            const container = pluginManager.getPluginInteractionContainer();
+            if (container) {
+                const target = event.originalEvent.target;
+                if (container.contains(target))
+                    return true;
+            }
+        }
+        // Shift+drag = start of a box selection: return false to avoid stopPropagation
+        if (event.modifiers.shift) {
+            map.dragPan.disable();
+            return false;
+        }
+        // While the interaction lock is on, dragPan is not disabled even on a
+        // handle / feature hit, and the drag is passed straight through to the map pan. While
+        // locked, moving / resizing / rotating / vertex editing are forbidden (drag-handler does not
+        // start them because of isInteractionBlocked), so this prevents the defect where dragging
+        // from on top of a feature kills the pan alone. Returning true here would make InputRouter
+        // call preventDefault and stop MapLibre's pan along with it, so false is always returned to
+        // let the event pass through. Selection by click is handled separately by
+        // onClick, so it is unaffected. Shift box selection is already handled above.
+        if (store.isInteractionLocked())
+            return false;
+        const orderedFeatures = getDisplayFeatures(store);
+        const selectedFeatures = getSelectedFeatures(store);
+        const transform = createCoordinateTransform(map);
+        // Test against the handles of the selected features / inside their bbox
+        if (selectedFeatures.length > 0) {
+            const bbox = computeSelectionBoundingBox(selectedFeatures, __classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope.extensions);
+            if (bbox) {
+                const zoom = map.getZoom();
+                const getAdditionalHandles = getAdditionalResizeHandlesCallback(selectedFeatures, __classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope);
+                const getAuxiliaryHandles = getAuxiliaryHandlesCallback(selectedFeatures, __classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope);
+                const handleHit = hitTestHandles(event.point, selectedFeatures, transform, __classPrivateFieldGet(this, _SelectMode_config, "f"), zoom, __classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope, getAdditionalHandles, getAuxiliaryHandles);
+                if (handleHit) {
+                    map.dragPan.disable();
+                    return true;
+                }
+            }
+            const geoBbox = computeCombinedGeoBoundingBox(selectedFeatures, transform, __classPrivateFieldGet(this, _SelectMode_config, "f"), __classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope.extensions);
+            if (geoBbox) {
+                const geoLngLat = transform.unproject(event.point);
+                const geoPoint = [geoLngLat.lng, geoLngLat.lat];
+                if (isPointInGeoBoundingBox(geoPoint, geoBbox)) {
+                    map.dragPan.disable();
+                    return true;
+                }
+            }
+        }
+        // Selection-independent auxiliary handles (an extension implementation's focus, etc.). They
+        // appear even when the selection is empty, so they are taken after the selection handle test
+        // and before the feature hit test. They cannot be grabbed while readOnly (this prevents
+        // dragPan alone from dying even though no drag starts).
+        if (!store.isReadOnly()) {
+            const globalHit = hitTestGlobalAuxiliaryHandles(event.point, transform, __classPrivateFieldGet(this, _SelectMode_config, "f"), map.getZoom(), getGlobalAuxiliaryHandlesCallback(__classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope));
+            if (globalHit) {
+                map.dragPan.disable();
+                return true;
+            }
+        }
+        // Feature hit test (unified z traversal)
+        // Nothing is grabbed when a dataset is in the foreground. dragPan is also
+        // left alive so that the map can be panned even from on top of the data.
+        const top = __classPrivateFieldGet(this, _SelectMode_context, "f").hitTestTopmost(event.point, { orderedFeatures });
+        if (top?.kind === 'store') {
+            map.dragPan.disable();
+            return true;
+        }
+        return false;
+    }
+    onMouseUp() {
+        if (!__classPrivateFieldGet(this, _SelectMode_dragHandler, "f").isActive()) {
+            __classPrivateFieldGet(this, _SelectMode_context, "f").map.dragPan.enable();
+        }
+    }
+    // ============================================================================
+    // Click / DoubleClick
+    // ============================================================================
+    onClick(event) {
+        if (__classPrivateFieldGet(this, _SelectMode_dragHandler, "f").isActive())
+            return;
+        handleSelectClick(event, __classPrivateFieldGet(this, _SelectMode_context, "f"), __classPrivateFieldGet(this, _SelectMode_config, "f"));
+    }
+    onDoubleClick(event) {
+        handleSelectDoubleClick(event, __classPrivateFieldGet(this, _SelectMode_context, "f"));
+    }
+    // ============================================================================
+    // Drag
+    // ============================================================================
+    onDragStart(event) {
+        if (__classPrivateFieldGet(this, _SelectMode_context, "f").pluginManager?.isPluginInteracting())
+            return;
+        const { store, map } = __classPrivateFieldGet(this, _SelectMode_context, "f");
+        // Group / layer selections are also resolved to their members (so dragging the selection box
+        // moves a group as one).
+        const selectedIds = getSelectedFeatureIds(store);
+        const transform = createCoordinateTransform(map);
+        const dragStartPoint = event.dragStartPoint ?? event.point;
+        // Shift+drag = box selection
+        if (event.modifiers.shift) {
+            const geoLngLat = map.unproject([dragStartPoint.x, dragStartPoint.y]);
+            const startPoint = [geoLngLat.lng, geoLngLat.lat];
+            store.setBoxSelection({
+                startPoint,
+                endPoint: startPoint,
+                previousSelection: [...selectedIds],
+            });
+            map.dragPan.disable();
+            map.triggerRepaint();
+            return;
+        }
+        // While the interaction lock is on, the drag is passed straight through to
+        // the map pan. Neither the selection is changed nor a drag operation started (paired with
+        // onMouseDown not disabling dragPan; starting a move selection here would select a feature
+        // during a pan). Shift box selection is already handled above, so it is preserved.
+        if (store.isInteractionLocked())
+            return;
+        // A handle hit on the selected features -> start the corresponding drag operation
+        if (selectedIds.length > 0) {
+            const selectedFeatures = getSelectedFeatures(store);
+            if (selectedFeatures.length > 0) {
+                const bbox = computeSelectionBoundingBox(selectedFeatures, __classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope.extensions);
+                if (bbox) {
+                    const zoom = map.getZoom();
+                    const getAdditionalHandles = getAdditionalResizeHandlesCallback(selectedFeatures, __classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope);
+                    const getAuxiliaryHandles = getAuxiliaryHandlesCallback(selectedFeatures, __classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope);
+                    const handleHit = hitTestHandles(dragStartPoint, selectedFeatures, transform, __classPrivateFieldGet(this, _SelectMode_config, "f"), zoom, __classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope, getAdditionalHandles, getAuxiliaryHandles);
+                    if (handleHit) {
+                        __classPrivateFieldGet(this, _SelectMode_dragHandler, "f").startDrag(handleHit, event, __classPrivateFieldGet(this, _SelectMode_context, "f"), bbox);
+                        return;
+                    }
+                }
+            }
+        }
+        // Selection-independent auxiliary handles (an extension implementation's focus, etc.). When
+        // no selection handle was hit, they are taken before grabbing a feature. Whether delegation
+        // is accepted and the readOnly test are decided by drag-handler.
+        const globalHit = hitTestGlobalAuxiliaryHandles(dragStartPoint, transform, __classPrivateFieldGet(this, _SelectMode_config, "f"), map.getZoom(), getGlobalAuxiliaryHandlesCallback(__classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope));
+        if (globalHit) {
+            __classPrivateFieldGet(this, _SelectMode_dragHandler, "f").startDrag(globalHit, event, __classPrivateFieldGet(this, _SelectMode_context, "f"), null);
+            return;
+        }
+        // When no handle was hit: select the feature -> move operation
+        // When a dataset is in the foreground, nothing is grabbed and no drag is
+        // started (dragPan is alive, so it becomes a map pan).
+        const orderedFeatures = getDisplayFeatures(store);
+        const top = __classPrivateFieldGet(this, _SelectMode_context, "f").hitTestTopmost(dragStartPoint, { orderedFeatures });
+        if (top?.kind !== 'store')
+            return;
+        const hitFeatureId = top.feature.id;
+        if (!selectedIds.includes(hitFeatureId)) {
+            const filtered = __classPrivateFieldGet(this, _SelectMode_context, "f").pluginManager?.filterSelectionCandidates([hitFeatureId]) ?? [
+                hitFeatureId,
+            ];
+            if (filtered.length === 0)
+                return;
+            store.setSelection('feature', filtered);
+        }
+        const newSelectedFeatures = getSelectedFeatures(store);
+        const bbox = computeSelectionBoundingBox(newSelectedFeatures, __classPrivateFieldGet(this, _SelectMode_context, "f").selectionScope.extensions);
+        const moveHit = { type: 'move' };
+        __classPrivateFieldGet(this, _SelectMode_dragHandler, "f").startDrag(moveHit, event, __classPrivateFieldGet(this, _SelectMode_context, "f"), bbox);
+    }
+    onDragMove(event) {
+        const { store, map, pluginManager } = __classPrivateFieldGet(this, _SelectMode_context, "f");
+        const boxSelection = store.getBoxSelection();
+        // Update the box selection
+        if (boxSelection) {
+            const geoLngLat = map.unproject([event.point.x, event.point.y]);
+            const endPoint = [geoLngLat.lng, geoLngLat.lat];
+            const updatedBoxSelection = { ...boxSelection, endPoint };
+            store.setBoxSelection(updatedBoxSelection);
+            // Live selection preview (a frame that selects the same features changes nothing)
+            const hitIds = queryFeaturesInBox(updatedBoxSelection, __classPrivateFieldGet(this, _SelectMode_context, "f"));
+            const filtered = hitIds.length > 0 ? (pluginManager?.filterSelectionCandidates(hitIds) ?? hitIds) : hitIds;
+            if (!selectsExactly(store.getSelection(), filtered)) {
+                if (filtered.length === 0) {
+                    store.setSelection(null, []);
+                }
+                else {
+                    store.setSelection('feature', filtered);
+                }
+            }
+            return;
+        }
+        if (__classPrivateFieldGet(this, _SelectMode_dragHandler, "f").isActive()) {
+            __classPrivateFieldGet(this, _SelectMode_dragHandler, "f").updateDrag(event, __classPrivateFieldGet(this, _SelectMode_context, "f"));
+        }
+    }
+    onDragEnd(event) {
+        const { store, map, pluginManager } = __classPrivateFieldGet(this, _SelectMode_context, "f");
+        const boxSelection = store.getBoxSelection();
+        // Commit the box selection
+        if (boxSelection) {
+            const hitIds = queryFeaturesInBox(boxSelection, __classPrivateFieldGet(this, _SelectMode_context, "f"));
+            const filtered = hitIds.length > 0 ? (pluginManager?.filterSelectionCandidates(hitIds) ?? hitIds) : hitIds;
+            if (filtered.length === 0) {
+                store.setSelection(null, []);
+            }
+            else {
+                store.setSelection('feature', filtered);
+            }
+            store.setBoxSelection(null);
+            map.dragPan.enable();
+            return;
+        }
+        if (__classPrivateFieldGet(this, _SelectMode_dragHandler, "f").isActive()) {
+            __classPrivateFieldGet(this, _SelectMode_dragHandler, "f").endDrag(__classPrivateFieldGet(this, _SelectMode_context, "f"), event);
+        }
+    }
+    /**
+     * The press ended without a release (a second finger, or the browser cancelled the touch)
+     *
+     * Nothing is committed: a box selection returns to the selection it started from, a drag
+     * operation is abandoned, and the pan goes back to MapLibre (which also covers a press that
+     * disabled it in onMouseDown and never became a drag).
+     */
+    onDragCancel() {
+        const { store, map } = __classPrivateFieldGet(this, _SelectMode_context, "f");
+        const boxSelection = store.getBoxSelection();
+        if (boxSelection) {
+            if (boxSelection.previousSelection.length === 0) {
+                store.setSelection(null, []);
+            }
+            else {
+                store.setSelection('feature', [...boxSelection.previousSelection]);
+            }
+            store.setBoxSelection(null);
+        }
+        if (__classPrivateFieldGet(this, _SelectMode_dragHandler, "f").isActive()) {
+            __classPrivateFieldGet(this, _SelectMode_dragHandler, "f").reset(store);
+        }
+        if (store.getDragState())
+            store.setDragState(null);
+        if (!map.dragPan.isEnabled())
+            map.dragPan.enable();
+    }
+    // ============================================================================
+    // Keyboard / MouseMove
+    // ============================================================================
+    onKeyDown(event) {
+        const { pluginManager, store } = __classPrivateFieldGet(this, _SelectMode_context, "f");
+        // Skip destructive key operations during a plugin interaction
+        if (pluginManager?.isPluginInteracting()) {
+            if (event.key === 'Escape') {
+                pluginManager.cancelPluginInteraction();
+            }
+            return;
+        }
+        // Escape during a drag cancels the drag (the InputNormalizer already turns a real
+        // Escape into dragcancel; this covers synthetic input)
+        if (event.key === 'Escape' && (__classPrivateFieldGet(this, _SelectMode_dragHandler, "f").isActive() || store.getBoxSelection())) {
+            this.onDragCancel();
+            return;
+        }
+        // Arrow keys: move the selection by a few pixels. A used key is not also a map pan
+        if (handleNudgeShortcut(__classPrivateFieldGet(this, _SelectMode_context, "f"), event.key, event.modifiers)) {
+            event.originalEvent.preventDefault();
+            return;
+        }
+        const isMetaOrCtrl = event.modifiers.meta || event.modifiers.ctrl;
+        // Cmd+G / Ctrl+G: group
+        if (event.key.toLowerCase() === 'g' && isMetaOrCtrl && !event.modifiers.shift) {
+            event.originalEvent.preventDefault();
+            handleGroupShortcut(__classPrivateFieldGet(this, _SelectMode_context, "f"));
+            return;
+        }
+        // Shift+Cmd+G / Shift+Ctrl+G: ungroup
+        if (event.key.toLowerCase() === 'g' && isMetaOrCtrl && event.modifiers.shift) {
+            event.originalEvent.preventDefault();
+            handleUngroupShortcut(__classPrivateFieldGet(this, _SelectMode_context, "f"));
+            return;
+        }
+        // Delete / Backspace: delete the selection
+        if (event.key === 'Delete' || event.key === 'Backspace') {
+            handleDeleteShortcut(__classPrivateFieldGet(this, _SelectMode_context, "f"));
+            return;
+        }
+        // Escape: cancel the box selection / clear the selection
+        if (event.key === 'Escape') {
+            handleEscapeShortcut(__classPrivateFieldGet(this, _SelectMode_context, "f"));
+        }
+    }
+    onMouseMove(event) {
+        if (__classPrivateFieldGet(this, _SelectMode_dragHandler, "f").isActive() || __classPrivateFieldGet(this, _SelectMode_context, "f").pluginManager?.isPluginInteracting()) {
+            return;
+        }
+        updateCursorForSelection(event, __classPrivateFieldGet(this, _SelectMode_context, "f"), __classPrivateFieldGet(this, _SelectMode_config, "f"));
+    }
+}
+_SelectMode_context = new WeakMap(), _SelectMode_dragHandler = new WeakMap(), _SelectMode_config = new WeakMap();

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

@@ -0,0 +1,40 @@
+import type { ModeContext } from '../handler.js';
+/**
+ * Handling of the group shortcut (Cmd+G / Ctrl+G).
+ *
+ * The behavior is identical to the API's groupSelection (the key, the menu and the API place the
+ * new group at the same position).
+ */
+export declare function handleGroupShortcut(context: ModeContext): void;
+/**
+ * Handling of the ungroup shortcut (Shift+Cmd+G / Shift+Ctrl+G).
+ *
+ * The behavior is identical to the API's ungroupSelection (keeping the key, the menu and the API
+ * consistent): a group selection is dissolved, and for a member feature selection only that
+ * member leaves.
+ */
+export declare function handleUngroupShortcut(context: ModeContext): void;
+/**
+ * Handling of the Delete / Backspace key: deletes what is selected, exactly like
+ * `draw.deleteSelection()` (vertices, features, groups or layers; locked items are kept).
+ */
+export declare function handleDeleteShortcut(context: ModeContext): void;
+/**
+ * Handling of the arrow keys: moves the selected features by a few pixels on the screen
+ *
+ * One key press is one committed change (one notification). Like a drag, nothing moves while
+ * any selected feature is blocked (read-only, the interaction lock or a lock of its own).
+ *
+ * @returns whether the key was used (a selection was moved); otherwise the key is left to
+ *   the map (MapLibre pans with it)
+ */
+export declare function handleNudgeShortcut(context: ModeContext, key: string, modifiers: {
+    shift: boolean;
+    ctrl: boolean;
+    alt: boolean;
+    meta: boolean;
+}): boolean;
+/**
+ * Handling of the Escape key
+ */
+export declare function handleEscapeShortcut(context: ModeContext): void;

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

@@ -0,0 +1,128 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Shortcut key handler
+ *
+ * Responsible for handling keyboard shortcuts in select mode
+ */
+import { groupSelection, ungroupSelection } from '../../operations/layer-operations.js';
+import { deleteSelection } from '../../operations/selection-operations.js';
+import { mapCoordinatesDeep } from '../../shared/utils/coordinates.js';
+import { isInteractionBlocked } from '../../store/lock.js';
+import { getSelectedFeatureIds } from '../../view/ui/helper.js';
+/** The distance an arrow key moves the selection (pixels; with Shift, NUDGE_LARGE) */
+const NUDGE_SMALL = 1;
+const NUDGE_LARGE = 10;
+/** Screen direction of each arrow key */
+const ARROW_DIRECTIONS = {
+    ArrowLeft: [-1, 0],
+    ArrowRight: [1, 0],
+    ArrowUp: [0, -1],
+    ArrowDown: [0, 1],
+};
+/**
+ * Handling of the group shortcut (Cmd+G / Ctrl+G).
+ *
+ * The behavior is identical to the API's groupSelection (the key, the menu and the API place the
+ * new group at the same position).
+ */
+export function handleGroupShortcut(context) {
+    const { store, autoNameGenerator, generateFeatureId } = context;
+    if (store.isReadOnly() || store.isInteractionLocked())
+        return;
+    groupSelection(store, generateFeatureId, autoNameGenerator);
+}
+/**
+ * Handling of the ungroup shortcut (Shift+Cmd+G / Shift+Ctrl+G).
+ *
+ * The behavior is identical to the API's ungroupSelection (keeping the key, the menu and the API
+ * consistent): a group selection is dissolved, and for a member feature selection only that
+ * member leaves.
+ */
+export function handleUngroupShortcut(context) {
+    const { store } = context;
+    if (store.isReadOnly() || store.isInteractionLocked())
+        return;
+    ungroupSelection(store);
+}
+/**
+ * Handling of the Delete / Backspace key: deletes what is selected, exactly like
+ * `draw.deleteSelection()` (vertices, features, groups or layers; locked items are kept).
+ */
+export function handleDeleteShortcut(context) {
+    deleteSelection(context.store);
+}
+/**
+ * Handling of the arrow keys: moves the selected features by a few pixels on the screen
+ *
+ * One key press is one committed change (one notification). Like a drag, nothing moves while
+ * any selected feature is blocked (read-only, the interaction lock or a lock of its own).
+ *
+ * @returns whether the key was used (a selection was moved); otherwise the key is left to
+ *   the map (MapLibre pans with it)
+ */
+export function handleNudgeShortcut(context, key, modifiers) {
+    const direction = ARROW_DIRECTIONS[key];
+    if (!direction || modifiers.ctrl || modifiers.alt || modifiers.meta)
+        return false;
+    const { store, map } = context;
+    const features = getSelectedFeatureIds(store)
+        .map((id) => store.getFeature(id))
+        .filter((f) => f !== undefined);
+    if (features.length === 0)
+        return false;
+    if (features.some((f) => isInteractionBlocked(f, store)))
+        return false;
+    // One offset in degrees for every feature, taken at a point of the selection, so the
+    // features keep their relative placement (the same translation as a move drag)
+    const reference = firstCoordinate(features[0].coordinates);
+    if (!reference)
+        return false;
+    const step = modifiers.shift ? NUDGE_LARGE : NUDGE_SMALL;
+    const from = map.project(reference);
+    const to = map.unproject([from.x + direction[0] * step, from.y + direction[1] * step]);
+    const dx = to.lng - reference[0];
+    const dy = to.lat - reference[1];
+    store.transact(() => {
+        for (const feature of features) {
+            const coordinates = mapCoordinatesDeep(feature.coordinates, (c) => [c[0] + dx, c[1] + dy]);
+            store.updateFeature(feature.id, { coordinates });
+        }
+    });
+    return true;
+}
+function firstCoordinate(coordinates) {
+    let value = coordinates;
+    while (Array.isArray(value) && Array.isArray(value[0]))
+        value = value[0];
+    return Array.isArray(value) && typeof value[0] === 'number' ? value : null;
+}
+/**
+ * Handling of the Escape key
+ */
+export function handleEscapeShortcut(context) {
+    const { store, map } = context;
+    const boxSelection = store.getBoxSelection();
+    if (boxSelection) {
+        // Cancel when a box selection is in progress (restore the selection as it was when the drag
+        // started)
+        if (boxSelection.previousSelection.length === 0) {
+            store.setSelection(null, []);
+        }
+        else {
+            store.setSelection('feature', boxSelection.previousSelection);
+        }
+        store.setBoxSelection(null);
+        map.dragPan.enable();
+        map.triggerRepaint();
+        return;
+    }
+    // Clear the vertex selection when vertices are selected
+    const selectedVertices = store.getSelectedVertices();
+    if (selectedVertices) {
+        store.setSelectedVertices(null);
+        return;
+    }
+    // Clear the feature selection
+    store.setSelection(null, []);
+}

package/dist/operations/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Operations module
+ *
+ * Only the symbols that src/index.ts publishes are listed here (see "The public
+ * surface" in CONTRIBUTING.md). Internal code imports from the defining file.
+ */
+export type { ResizeState } from './resize.js';
+export type { TraceGraph, TraceGraphEdge, TraceGraphEndpoint, TraceGraphNode, } from './trace-graph.js';
+export { buildTraceGraph, findTracePath } from './trace-graph.js';

package/dist/operations/index.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export { buildTraceGraph, findTracePath } from './trace-graph.js';

package/dist/operations/layer-operations.d.ts

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