@sakuzu/maplibre-gl-draw 1.0.0

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

@@ -0,0 +1,140 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Box selection logic
+ *
+ * Responsible for handling box selection in select mode
+ */
+import { isLocallyHidden } from '../../store/local-visibility.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 function queryFeaturesInBox(boxSelection, context) {
+    const { store, spatialIndex, boxSelectionRegistry } = context;
+    const rects = boxRects(boxSelection.startPoint, boxSelection.endPoint);
+    // First obtain the candidates quickly with rbush (from each part of a box that crosses the
+    // antimeridian)
+    const candidateIds = new Set();
+    for (const rect of rects) {
+        for (const id of spatialIndex.findInBounds(rect))
+            candidateIds.add(id);
+    }
+    // Perform the precise inside-the-box test on the candidates.
+    // As with the click hit test (HitTestService.hitTestAll), hidden or locked features / their
+    // layer / their group are excluded from the selection targets (this prevents the
+    // inconsistency where box selection alone could select while ignoring locks and hiding).
+    const hitIds = [];
+    for (const id of candidateIds) {
+        const feature = store.getFeature(id);
+        if (!feature)
+            continue;
+        if (!feature.visible || feature.locked)
+            continue;
+        // What this client has hidden locally is excluded from the box selection targets too
+        // (this prevents the inconsistency of being hit by the box while invisible).
+        if (isLocallyHidden(feature, store))
+            continue;
+        const layer = store.getLayer(feature.layerId);
+        if (layer && (!layer.visible || layer.locked))
+            continue;
+        if (feature.groupId) {
+            const group = store.getGroup(feature.groupId);
+            if (group && (!group.visible || group.locked))
+                continue;
+        }
+        if (rects.some((rect) => isFeatureInBox(feature, rect, boxSelectionRegistry))) {
+            hitIds.push(feature.id);
+        }
+    }
+    return hitIds;
+}
+/**
+ * The rectangles, in longitudes within [-180, 180], that a box drawn on the screen covers
+ *
+ * The corners come from the map unprojected as they are, so a box drawn across the
+ * antimeridian has a longitude beyond ±180 at one side. It is brought back into [-180, 180]
+ * and split at the line into two rectangles, and the box as drawn is kept as well; a box as
+ * wide as the world covers every longitude.
+ */
+export function boxRects(start, end) {
+    const minY = Math.min(start[1], end[1]);
+    const maxY = Math.max(start[1], end[1]);
+    let minX = Math.min(start[0], end[0]);
+    let maxX = Math.max(start[0], end[0]);
+    if (maxX - minX >= 360)
+        return [{ minX: -180, minY, maxX: 180, maxY }];
+    // Features whose coordinates were stored beyond ±180 are still found by the box as drawn
+    const drawn = { minX, minY, maxX, maxY };
+    // Shift whole turns so that the west side is within [-180, 180)
+    const turns = Math.floor((minX + 180) / 360);
+    minX -= turns * 360;
+    maxX -= turns * 360;
+    const parts = maxX <= 180
+        ? [{ minX, minY, maxX, maxY }]
+        : [
+            { minX, minY, maxX: 180, maxY },
+            { minX: -180, minY, maxX: maxX - 360, maxY },
+        ];
+    return turns === 0 && parts.length === 1 ? parts : [...parts, drawn];
+}
+/**
+ * Decide whether a feature is inside the box
+ *
+ * Uses BoxSelectionStrategyRegistry to perform the appropriate test per feature type.
+ * - Point: whether the center coordinate is inside the box
+ * - LineString: intersection test between the geometry and the box
+ * - Polygon: intersection test between the geometry and the box
+ * - Text/Image: intersection test between the OBB (the bounding box that accounts for rotation)
+ *   and the box
+ */
+export function isFeatureInBox(feature, rect, boxSelectionRegistry) {
+    // Get the Strategy from the registry
+    const strategy = boxSelectionRegistry.get(feature.type);
+    if (strategy) {
+        return strategy.intersects(feature, rect);
+    }
+    // Fallback for custom types (a coordinate-based test)
+    return fallbackBoxSelection(feature, rect);
+}
+/**
+ * The fallback box selection test
+ *
+ * Performs a simple coordinate-based test for feature types that are not registered.
+ */
+export function fallbackBoxSelection(feature, rect) {
+    const isPointInBox = (coord) => {
+        return (coord[0] >= rect.minX &&
+            coord[0] <= rect.maxX &&
+            coord[1] >= rect.minY &&
+            coord[1] <= rect.maxY);
+    };
+    const coords = feature.coordinates;
+    // When the coordinates are a single point
+    if (Array.isArray(coords) &&
+        coords.length === 2 &&
+        typeof coords[0] === 'number' &&
+        typeof coords[1] === 'number') {
+        return isPointInBox(coords);
+    }
+    // When the coordinates are an array
+    if (Array.isArray(coords) && coords.length > 0) {
+        const firstElement = coords[0];
+        // LineString form: Coordinate[]
+        if (Array.isArray(firstElement) &&
+            firstElement.length === 2 &&
+            typeof firstElement[0] === 'number') {
+            return coords.some((coord) => isPointInBox(coord));
+        }
+        // Polygon form: Coordinate[][]
+        if (Array.isArray(firstElement) && Array.isArray(firstElement[0])) {
+            const rings = coords;
+            if (rings.length === 0)
+                return false;
+            return rings[0].some((coord) => isPointInBox(coord));
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * click / dblclick handling for SelectMode
+ *
+ * Single click: the priority order is plugin intercept -> vertex click -> feature selection
+ *   1. While a plugin is interacting, clicks inside its container are consumed; anything else
+ *      finishes it
+ *   2. A click on a vertex handle of a singly selected feature that supports vertex editing
+ *      (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.
+ *      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
+ */
+import type { MouseNormalizedEvent } from '../../dispatcher/types.js';
+import type { SelectionUIConfig } from '../../shared/config/selection.js';
+import type { ModeContext } from '../handler.js';
+/**
+ * The main logic of onClick
+ */
+export declare function handleSelectClick(event: MouseNormalizedEvent, context: ModeContext, 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;

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

@@ -0,0 +1,166 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { createCoordinateTransform } from '../../shared/math/index.js';
+import { supportsVertexEditing } from '../../shared/utils/coordinates.js';
+import { hasVertexRef, isSameVertexRef } from '../../shared/utils/vertex-ref.js';
+import { getDisplayFeatures } from '../../store/local-visibility.js';
+import { notifyFeatureCompanionClick } from '../../view/feature-companion.js';
+import { hitTestHandles } from '../../view/ui/handle-test.js';
+import { getSelectedFeatures } from '../../view/ui/helper.js';
+/**
+ * The main logic of onClick
+ */
+export function handleSelectClick(event, context, config) {
+    if (handlePluginInteractionClick(event, context)) {
+        return;
+    }
+    const { store } = context;
+    const selection = store.getSelection();
+    const selectedIds = selection.type === 'feature' ? selection.ids : [];
+    if (handleVertexClick(event, selectedIds, context, config)) {
+        return;
+    }
+    store.setSelectedVertices(null);
+    handleFeatureClick(event, selection, selectedIds, context);
+}
+/**
+ * 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 function handleSelectDoubleClick(event, context) {
+    if (context.pluginManager?.isPluginInteracting())
+        return;
+    const { store } = context;
+    const orderedFeatures = getDisplayFeatures(store);
+    // Store features are not grabbed when a dataset is in the foreground
+    const top = context.hitTestTopmost(event.point, { orderedFeatures });
+    if (top?.kind !== 'store')
+        return;
+    event.originalEvent.preventDefault();
+    const filtered = context.pluginManager?.filterSelectionCandidates([top.feature.id]) ?? [
+        top.feature.id,
+    ];
+    if (filtered.length > 0) {
+        store.setSelection('feature', filtered);
+    }
+    context.pluginManager?.handleFeatureDoubleClick(top.feature.id);
+}
+/**
+ * Click handling during a plugin interaction
+ *
+ * @returns true when the click was consumed (= the caller skips the rest of the handling)
+ */
+function handlePluginInteractionClick(event, context) {
+    const pm = context.pluginManager;
+    if (!pm?.isPluginInteracting())
+        return false;
+    const container = pm.getPluginInteractionContainer();
+    if (container) {
+        const target = event.originalEvent.target;
+        if (container.contains(target)) {
+            return true;
+        }
+    }
+    pm.finishPluginInteraction();
+    return true;
+}
+/**
+ * Click handling for vertex handles
+ *
+ * @returns true when a vertex was selected
+ */
+function handleVertexClick(event, selectedIds, context, config) {
+    if (selectedIds.length !== 1)
+        return false;
+    const { store, map } = context;
+    const selectedFeatures = getSelectedFeatures(store);
+    const feature = selectedFeatures[0];
+    // Only types that support vertex editing (LineString / Polygon / the Multi types) are subject
+    // to vertex selection
+    if (!feature || !supportsVertexEditing(feature.type))
+        return false;
+    const transform = createCoordinateTransform(map);
+    const zoom = map.getZoom();
+    const handleHit = hitTestHandles(event.point, selectedFeatures, transform, config, zoom, context.selectionScope);
+    if (handleHit?.type !== 'vertex' || handleHit.vertexRef === undefined) {
+        return false;
+    }
+    const featureId = handleHit.featureId;
+    if (!featureId)
+        return false;
+    const vertexRef = handleHit.vertexRef;
+    const currentVertexSelection = store.getSelectedVertices();
+    if (event.modifiers.shift && currentVertexSelection?.featureId === featureId) {
+        // Shift+click: add / remove a vertex of the same feature
+        const refs = currentVertexSelection.vertexIndices;
+        if (hasVertexRef(refs, vertexRef)) {
+            const newRefs = refs.filter((r) => !isSameVertexRef(r, vertexRef));
+            store.setSelectedVertices(newRefs.length === 0 ? null : { featureId, vertexIndices: newRefs });
+        }
+        else {
+            store.setSelectedVertices({ featureId, vertexIndices: [...refs, vertexRef] });
+        }
+    }
+    else {
+        store.setSelectedVertices({ featureId, vertexIndices: [vertexRef] });
+    }
+    return true;
+}
+/**
+ * Feature selection handling
+ */
+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.
+    if (top?.kind === 'companion') {
+        notifyFeatureCompanionClick(context.featureCompanions, top.companion);
+        return;
+    }
+    // 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.
+    if (top?.kind !== 'store') {
+        if (!event.modifiers.shift) {
+            store.setSelection(null, []);
+        }
+        return;
+    }
+    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)) {
+            return;
+        }
+    }
+    // Update the selection
+    const candidateIds = event.modifiers.shift
+        ? toggleSelection(selection, feature.id)
+        : [feature.id];
+    const filtered = context.pluginManager?.filterSelectionCandidates(candidateIds) ?? candidateIds;
+    if (filtered.length === 0) {
+        store.setSelection(null, []);
+    }
+    else {
+        store.setSelection('feature', filtered);
+    }
+}
+/**
+ * Toggling the selection with Shift+click
+ */
+function toggleSelection(selection, featureId) {
+    const current = selection.type === 'feature' ? [...selection.ids] : [];
+    const index = current.indexOf(featureId);
+    if (index === -1) {
+        current.push(featureId);
+    }
+    else {
+        current.splice(index, 1);
+    }
+    return current;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * cursor control for SelectMode (onMouseMove)
+ *
+ * 1. There is a selected feature and a handle was hit -> the cursor that matches the handle kind
+ *    (move / resize / vertex, etc.)
+ * 1.5. A selection-independent auxiliary handle (provided by an extension implementation) was
+ *    hit -> that handle's cursor
+ * 2. Otherwise, a Store feature or an interactive dataset is in the very
+ *    foreground -> 'pointer'
+ * 3. Otherwise (a dataset that merely occludes / nothing) -> 'default'
+ */
+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;

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

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { createCoordinateTransform } from '../../shared/math/index.js';
+import { getDisplayFeatures } from '../../store/local-visibility.js';
+import { isInteractionBlocked } from '../../store/lock.js';
+import { getCursorForHandle, hitTestGlobalAuxiliaryHandles, hitTestHandles, } from '../../view/ui/handle-test.js';
+import { computeSelectionBoundingBox, getSelectedFeatureIds, getSelectedFeatures, } from '../../view/ui/helper.js';
+import { getAdditionalResizeHandlesCallback, getAuxiliaryHandlesCallback, getGlobalAuxiliaryHandlesCallback, } from './hit-helpers.js';
+export function updateCursorForSelection(event, context, config) {
+    const { store, map } = context;
+    // Group / layer selections are also resolved to their members (so the operation cursor is
+    // shown over a group).
+    const selectedIds = getSelectedFeatureIds(store);
+    const canvas = map.getCanvas();
+    const transform = createCoordinateTransform(map);
+    // Handle hit test on the selected features
+    // No operation cursor (move / resize, etc.) is shown for a selection whose editing operations
+    // are suppressed (effective lock / read-only / interaction lock). Dragging is rejected by
+    // startDrag with the same predicate, so the cursor alone would be a lie suggesting it is
+    // possible. It falls through to the feature hit test below (pointer), matching the operation
+    // that is actually possible: "it can be selected by clicking".
+    if (selectedIds.length > 0) {
+        const selectedFeatures = getSelectedFeatures(store);
+        const blocked = selectedFeatures.some((f) => isInteractionBlocked(f, store));
+        const bbox = blocked
+            ? null
+            : computeSelectionBoundingBox(selectedFeatures, context.selectionScope.extensions);
+        if (bbox) {
+            const zoom = map.getZoom();
+            const getAdditionalHandles = getAdditionalResizeHandlesCallback(selectedFeatures, context.selectionScope);
+            const getAuxiliaryHandles = getAuxiliaryHandlesCallback(selectedFeatures, context.selectionScope);
+            const handleHit = hitTestHandles(event.point, selectedFeatures, transform, config, zoom, context.selectionScope, getAdditionalHandles, getAuxiliaryHandles);
+            if (handleHit) {
+                canvas.style.cursor = getCursorForHandle(handleHit);
+                return;
+            }
+        }
+    }
+    // Selection-independent auxiliary handles (an extension implementation's focus, etc.). They
+    // appear regardless of whether there is a selection, so they are looked at after the selection
+    // handles and before the feature hit. They are not shown in a state where they cannot be
+    // grabbed (readOnly / interaction lock) (the cursor alone would be a lie suggesting it is
+    // possible).
+    if (!store.isReadOnly() && !store.isInteractionLocked()) {
+        const globalHit = hitTestGlobalAuxiliaryHandles(event.point, transform, config, map.getZoom(), getGlobalAuxiliaryHandlesCallback(context.selectionScope));
+        if (globalHit) {
+            canvas.style.cursor = getCursorForHandle(globalHit);
+            return;
+        }
+    }
+    // Feature hit test (unified z traversal)
+    // When a dataset is in the foreground, the cursor becomes pointer only when it
+    // can fire click / hover (interactive). Showing pointer for a dataset that merely occludes
+    // would be a lie suggesting "it can be pressed".
+    const orderedFeatures = getDisplayFeatures(store);
+    const top = context.hitTestTopmost(event.point, { orderedFeatures });
+    canvas.style.cursor =
+        top === null || (top.kind === 'dataset' && !top.dataset.interactive) ? 'default' : 'pointer';
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Auxiliary handle drag: delegated to the extension implementation that provides the handle
+ */
+import type { DragNormalizedEvent } from '../../../dispatcher/types.js';
+import type { AuxiliaryHandleHit, AuxiliaryHandleProvider } from '../../../view/ui/auxiliary-handles.js';
+import type { HandleHitResult } from '../../../view/ui/handle-test.js';
+import type { DragScope } from './operation.js';
+/**
+ * Drag state for an auxiliary handle (provided by an extension implementation)
+ *
+ * Holds the grabbed handle and the provider it is delegated to. The meaning of the coordinates
+ * lives on the provider side, so core merely forwards move / end and writes nothing to the Store.
+ */
+export interface AuxiliaryState {
+    provider: AuxiliaryHandleProvider;
+    hit: AuxiliaryHandleHit;
+    /** The last drag event forwarded (for cleanup on paths where dragend is not delivered) */
+    lastEvent: DragNormalizedEvent;
+}
+/**
+ * Check whether an auxiliary handle drag can be delegated to a provider
+ *
+ * When no provider is found, or when onHandleDragStart returns false, null is returned and the
+ * caller does not start a drag (it falls through to the normal handling).
+ */
+export declare function resolveAuxiliaryDrag(hitResult: HandleHitResult, event: DragNormalizedEvent, scope: DragScope): AuxiliaryDrag | null;

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

@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/** @internal */
+export class AuxiliaryDrag {
+    constructor(state) {
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'auxiliary'
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.state = state;
+    }
+    update(event) {
+        if (!this.state)
+            return;
+        this.state.lastEvent = event;
+        this.state.provider.onHandleDragMove(event);
+    }
+    /**
+     * Tell the delegate that the auxiliary handle drag has ended
+     *
+     * On paths where no end event is delivered (when the mode side does not have an event), the
+     * last event that was forwarded is used instead. The delegate always receives end exactly once.
+     */
+    finish(event) {
+        if (!this.state)
+            return;
+        const { provider, lastEvent } = this.state;
+        this.state = null;
+        provider.onHandleDragEnd(event ?? lastEvent);
+    }
+}
+/**
+ * Check whether an auxiliary handle drag can be delegated to a provider
+ *
+ * When no provider is found, or when onHandleDragStart returns false, null is returned and the
+ * caller does not start a drag (it falls through to the normal handling).
+ */
+export function resolveAuxiliaryDrag(hitResult, event, scope) {
+    const hit = hitResult.auxiliary;
+    if (!hit)
+        return null;
+    const provider = scope?.auxiliaryHandles.get(hit.providerId);
+    if (!provider)
+        return null;
+    if (!provider.onHandleDragStart(hit, event))
+        return null;
+    return new AuxiliaryDrag({ provider, hit, lastEvent: event });
+}

package/dist/modes/select/drag/intermediate-writes.d.ts

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

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

@@ -0,0 +1,171 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Whether a feature still holds every field a drag wrote to it
+ *
+ * The values are plain data (coordinates and properties), so a structural comparison is
+ * enough. It runs only when a drag is aborted.
+ */
+function holdsFields(feature, fields) {
+    const source = feature;
+    for (const [key, value] of Object.entries(fields)) {
+        if (JSON.stringify(source[key]) !== JSON.stringify(value))
+            return false;
+    }
+    return true;
+}
+/**
+ * The intermediate writes of one drag
+ *
+ * @internal
+ */
+export class IntermediateWrites {
+    constructor() {
+        /**
+         * The last update applied to each feature touched during the drag (feature ID -> last diff
+         * written)
+         *
+         * Writes during a drag are issued as an intermediate state (isIntermediate), so the final
+         * state is rewritten as committed using the values recorded here in commit. It holds the diff
+         * as-is, including properties and not only coordinates, so scale / rotation from resize and
+         * rotate and radiusMeters from a radius change can all be committed through the same container.
+         */
+        Object.defineProperty(this, "pending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /**
+         * The value each touched field had before the drag first wrote it (feature ID -> fields)
+         *
+         * An aborted drag writes these back, so the feature returns to the shape it had when the
+         * drag started, whether or not the Store applied the intermediate updates to the real data.
+         */
+        Object.defineProperty(this, "origins", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /** Every field the drag has written so far, merged (feature ID -> fields) */
+        Object.defineProperty(this, "written", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * Write one intermediate update during the drag and record the last value for the commit
+     *
+     * During a drag, writes are issued as "an intermediate state partway through an editing
+     * operation", and the final state is committed together by commit when the drag ends.
+     * Deciding whether something is intermediate is core's responsibility; how that declaration
+     * is handled (persisted as-is, or routed through a temporary sharing path) is left to the
+     * Store implementation.
+     */
+    write(store, id, updates) {
+        this.recordOrigin(store, id, updates);
+        store.updateFeature(id, updates, { isIntermediate: true });
+        this.pending.set(id, updates);
+        this.written.set(id, { ...this.written.get(id), ...updates });
+    }
+    /**
+     * Remember the value of each field before the drag writes it for the first time
+     */
+    recordOrigin(store, id, updates) {
+        const feature = store.getFeature(id);
+        if (!feature)
+            return;
+        const origin = this.origins.get(id) ?? {};
+        const target = origin;
+        const source = feature;
+        for (const key of Object.keys(updates)) {
+            if (key in target)
+                continue;
+            target[key] = structuredClone(source[key]);
+        }
+        this.origins.set(id, origin);
+    }
+    /**
+     * Abort the intermediate updates that never reached a commit, restoring the features
+     *
+     * On a reset that does not go through the end of the drag (a cancel, a mode switch during a
+     * drag, or an external state change applied from outside), the intermediate state
+     * ends without being committed. Each feature gets the fields it had when the drag started
+     * written back as a last intermediate update, and the discard is then announced with
+     * abortIntermediateUpdates. A store that applies intermediate updates to the real data
+     * (MemoryStore) is back at the start by the restore; one that holds them apart drops them on
+     * the discard. A feature that something else changed during the drag (a change from
+     * outside) no longer holds what the drag wrote, and is left as it is. Once committed (after
+     * commit) the record is empty, so nothing happens.
+     */
+    discard(store) {
+        if (this.pending.size === 0) {
+            this.clearRecords();
+            return;
+        }
+        if (store) {
+            const ids = [...this.pending.keys()];
+            store.transact(() => {
+                for (const id of ids) {
+                    const origin = this.origins.get(id);
+                    const written = this.written.get(id);
+                    const feature = store.getFeature(id);
+                    if (!origin || !written || !feature || !holdsFields(feature, written))
+                        continue;
+                    store.updateFeature(id, origin, { isIntermediate: true });
+                }
+            });
+            store.abortIntermediateUpdates?.(ids);
+        }
+        this.pending.clear();
+        this.clearRecords();
+    }
+    /**
+     * Commit the intermediate updates made during the drag
+     *
+     * 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
+     * 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
+     * on whether the intermediate updates during the drag were applied to the Store (some Store
+     * implementations do not apply intermediate updates to the real data).
+     *
+     * Only the features that still exist are committed. A feature can disappear during a drag (a
+     * deletion from outside, the public API, a plugin); its record is not committed but discarded like
+     * an aborted drag, so the commit never updates a missing feature and never lands halfway.
+     */
+    commit(store) {
+        if (this.pending.size === 0)
+            return;
+        const vanished = [];
+        for (const id of this.pending.keys()) {
+            if (!store.getFeature(id))
+                vanished.push(id);
+        }
+        if (vanished.length > 0) {
+            store.abortIntermediateUpdates?.(vanished);
+            for (const id of vanished)
+                this.pending.delete(id);
+        }
+        if (this.pending.size > 0) {
+            store.transact(() => {
+                for (const [id, updates] of this.pending) {
+                    store.updateFeature(id, updates);
+                }
+            });
+        }
+        // A committed record is not a discard target (distinguished from the abort notification in
+        // reset)
+        this.pending.clear();
+        this.clearRecords();
+    }
+    clearRecords() {
+        this.origins.clear();
+        this.written.clear();
+    }
+}