@sakuzu/maplibre-gl-draw 1.0.0

package/dist/store/lock.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Derivation of the locked state
+ *
+ * Determines the "effective lock" of a feature. A lock is inherited top-down: if the
+ * feature itself, the group it belongs to, or the layer it belongs to is locked, then
+ * that feature is regarded as not operable (move/resize/rotate/vertex editing/delete).
+ *
+ * A lock is "forbidding operations", not "forbidding selection or display". Selection is
+ * allowed, and the operation side (drag/delete/handle display) uses this predicate to
+ * reject the operation.
+ */
+import type { Feature, Group, Layer } from './types.js';
+/**
+ * What {@link isFeatureLocked} reads: the groups and the layers
+ *
+ * {@link StoreView}, {@link Store} and {@link PluginContext} all satisfy it, so the lock
+ * decision can be made from the host and from plugins as well.
+ */
+export interface FeatureLockStore {
+    /** Returns the group with this ID, or undefined */
+    getGroup(id: string): Group | undefined;
+    /** Returns the layer with this ID, or undefined */
+    getLayer(id: string): Layer | undefined;
+}
+/**
+ * Whether the feature is effectively locked: by itself, by its group or by its layer
+ *
+ * A lock is inherited top-down. A locked feature can still be selected; it cannot be moved,
+ * resized, rotated, reshaped or deleted by the user.
+ *
+ * @example
+ * ```ts
+ * const feature = draw.getFeature(id);
+ * if (feature && !isFeatureLocked(feature, draw.getStore())) draw.deleteFeature(id);
+ * ```
+ */
+export declare function isFeatureLocked(feature: Feature, store: FeatureLockStore): boolean;
+/**
+ * What {@link isInteractionBlocked} reads: {@link FeatureLockStore} plus read-only and the
+ * interaction lock
+ */
+export interface InteractionGateStore extends FeatureLockStore {
+    /** Whether the Store is read-only */
+    isReadOnly(): boolean;
+    /** Whether the interaction lock is on */
+    isInteractionLocked(): boolean;
+}
+/**
+ * Whether the "start" of an editing interaction on this feature should be suppressed.
+ *
+ * True if any of readOnly, the interaction lock or the effective lock is set.
+ * readOnly means "an operation whose start is meaningless because writing is a no-op",
+ * the interaction lock means "suppressing operations in a read-only state", and feature
+ * locked means "the lock of that individual feature".
+ * All of them are suppression decisions at the starting point, orthogonal to the Store's
+ * write gate (which readOnly is responsible for).
+ * This predicate is used to reject at the origin of user input, such as the start of a
+ * drag or the display of selection handles.
+ */
+export declare function isInteractionBlocked(feature: Feature, store: InteractionGateStore): boolean;
+/**
+ * Whether the group is effectively locked: by itself or by the layer it belongs to
+ *
+ * @param findLayerOfGroup A function that returns the layer the group belongs to
+ *   (because groups are stored in layer.order, the caller resolves it and passes it in)
+ */
+export declare function isGroupLocked(group: Group, findLayerOfGroup: (groupId: string) => Layer | undefined): boolean;

package/dist/store/lock.js

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Whether the feature is effectively locked: by itself, by its group or by its layer
+ *
+ * A lock is inherited top-down. A locked feature can still be selected; it cannot be moved,
+ * resized, rotated, reshaped or deleted by the user.
+ *
+ * @example
+ * ```ts
+ * const feature = draw.getFeature(id);
+ * if (feature && !isFeatureLocked(feature, draw.getStore())) draw.deleteFeature(id);
+ * ```
+ */
+export function isFeatureLocked(feature, store) {
+    if (feature.locked)
+        return true;
+    if (feature.groupId) {
+        const group = store.getGroup(feature.groupId);
+        if (group?.locked)
+            return true;
+    }
+    const layer = store.getLayer(feature.layerId);
+    if (layer?.locked)
+        return true;
+    return false;
+}
+/**
+ * Whether the "start" of an editing interaction on this feature should be suppressed.
+ *
+ * True if any of readOnly, the interaction lock or the effective lock is set.
+ * readOnly means "an operation whose start is meaningless because writing is a no-op",
+ * the interaction lock means "suppressing operations in a read-only state", and feature
+ * locked means "the lock of that individual feature".
+ * All of them are suppression decisions at the starting point, orthogonal to the Store's
+ * write gate (which readOnly is responsible for).
+ * This predicate is used to reject at the origin of user input, such as the start of a
+ * drag or the display of selection handles.
+ */
+export function isInteractionBlocked(feature, store) {
+    return store.isReadOnly() || store.isInteractionLocked() || isFeatureLocked(feature, store);
+}
+/**
+ * Whether the group is effectively locked: by itself or by the layer it belongs to
+ *
+ * @param findLayerOfGroup A function that returns the layer the group belongs to
+ *   (because groups are stored in layer.order, the caller resolves it and passes it in)
+ */
+export function isGroupLocked(group, findLayerOfGroup) {
+    if (group.locked)
+        return true;
+    const layer = findLayerOfGroup(group.id);
+    return layer?.locked ?? false;
+}

package/dist/store/memory/change-bus.d.ts

@@ -0,0 +1,60 @@
+/**
+ * ChangeBus
+ *
+ * Responsible for the Store's change notification and transactions. It holds pendingChanges
+ * and flushes them to the listeners only at the outermost transaction. MemoryStore (and
+ * future Store implementations) holds one internally and delegates the transaction /
+ * listener mechanism to it.
+ *
+ * Accumulation is done by destructive appending (appendChanges). pendingChanges during a
+ * transaction is exposed only inside ChangeBus and is always recreated after a flush, so there
+ * is no need for an immutable merge (mergeChanges) that copies the arrays every time. With
+ * immutable copies, stacking N changes in one transaction costs O(N^2) in total, which made
+ * bulk import (draw.load) quadratic. Destructive appending costs an amortized O(1) per entry,
+ * so the whole accumulation stays within O(N).
+ *
+ * layers.updated / groups.updated are folded into one entry per identical ID. Updates to the
+ * same container happen many times within a single flush (layer.order changes every time one
+ * feature is created), while each entry holds a full-length snapshot of order / featureIds.
+ * Without folding, the amount retained in one transaction becomes O(N^2) and a bulk import
+ * reaches the heap limit. A folded entry keeps previous as the first state and layer/group as
+ * the last state, so as the diff of a single flush it means the same as before folding.
+ */
+import type { Group, Layer, StateChanges, UpdateSource } from '../types.js';
+export type StoreListener = (changes: StateChanges) => void;
+export declare class ChangeBus {
+    #private;
+    /**
+     * @param beforeFlush Called when the outermost operation is about to notify, before the
+     *   listeners (MemoryStore freezes the objects it built during the flush here)
+     */
+    constructor(beforeFlush?: () => void);
+    subscribe(listener: StoreListener): () => void;
+    /**
+     * Runs fn inside a transaction. Nesting is supported, and pendingChanges is flushed to the
+     * listeners at the moment the outermost transact finishes.
+     *
+     * Not atomic: when fn throws, what it changed before the throw is flushed like any other
+     * change and the exception propagates.
+     */
+    transact<T>(fn: () => T, source?: UpdateSource): T;
+    /**
+     * Merges the changes into pendingChanges. Flushes immediately if outside a transaction.
+     */
+    merge(changes: StateChanges): void;
+    /** Whether an update entry for this layer is already stacked within the same flush */
+    hasPendingLayerUpdate(id: string): boolean;
+    /** Whether an update entry for this group is already stacked within the same flush */
+    hasPendingGroupUpdate(id: string): boolean;
+    /**
+     * Stacks one layers.updated entry.
+     *
+     * Since folding leaves only the "first state" as previous, when hasPendingLayerUpdate is
+     * true the caller may pass undefined instead of building one (the existing entry's previous
+     * is used as is). When there is no entry, undefined means the state before and after the
+     * change is the same, so layer itself is used.
+     */
+    mergeLayerUpdate(layer: Layer, previous: Layer | undefined): void;
+    /** Stacks one groups.updated entry (previous is handled as in mergeLayerUpdate) */
+    mergeGroupUpdate(group: Group, previous: Group | undefined): void;
+}

package/dist/store/memory/change-bus.js

@@ -0,0 +1,232 @@
+// 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 _ChangeBus_instances, _ChangeBus_listeners, _ChangeBus_beforeFlush, _ChangeBus_transactionDepth, _ChangeBus_pendingChanges, _ChangeBus_currentSource, _ChangeBus_updateIndex, _ChangeBus_flushChanges;
+/**
+ * Appends changes destructively to target. Array categories (created/updated/deleted, etc.)
+ * are concatenated with push, and single-value categories (orderChanged/selection/mode, etc.)
+ * are overwritten. The final result matches mergeChanges (the immutable version), but target
+ * is not recreated every time.
+ */
+// If an existing array is given, push into it destructively; otherwise create and return a new
+// array. The caller only assigns the result (avoiding nested assignment expressions for lint).
+function appendField(existing, items) {
+    if (existing) {
+        existing.push(...items);
+        return existing;
+    }
+    return [...items];
+}
+/**
+ * Appends update entries while folding those with the same ID into one entry. If an entry
+ * already exists, only the current value is replaced while previous (the first state) is kept.
+ */
+function appendLayerUpdates(existing, items, index) {
+    const list = existing ?? [];
+    for (const item of items) {
+        const at = index.get(item.id);
+        if (at === undefined) {
+            index.set(item.id, list.length);
+            list.push(item);
+        }
+        else {
+            list[at] = { id: item.id, layer: item.layer, previous: list[at].previous };
+        }
+    }
+    return list;
+}
+function appendGroupUpdates(existing, items, index) {
+    const list = existing ?? [];
+    for (const item of items) {
+        const at = index.get(item.id);
+        if (at === undefined) {
+            index.set(item.id, list.length);
+            list.push(item);
+        }
+        else {
+            list[at] = { id: item.id, group: item.group, previous: list[at].previous };
+        }
+    }
+    return list;
+}
+function appendChanges(target, changes, index) {
+    // features
+    if (changes.features) {
+        if (!target.features)
+            target.features = {};
+        const t = target.features;
+        if (changes.features.created)
+            t.created = appendField(t.created, changes.features.created);
+        if (changes.features.updated)
+            t.updated = appendField(t.updated, changes.features.updated);
+        if (changes.features.deleted)
+            t.deleted = appendField(t.deleted, changes.features.deleted);
+    }
+    // layers
+    if (changes.layers) {
+        if (!target.layers)
+            target.layers = {};
+        const t = target.layers;
+        if (changes.layers.created)
+            t.created = appendField(t.created, changes.layers.created);
+        if (changes.layers.updated) {
+            t.updated = appendLayerUpdates(t.updated, changes.layers.updated, index.layers);
+        }
+        if (changes.layers.deleted)
+            t.deleted = appendField(t.deleted, changes.layers.deleted);
+        if (changes.layers.orderChanged)
+            t.orderChanged = changes.layers.orderChanged;
+    }
+    // groups
+    if (changes.groups) {
+        if (!target.groups)
+            target.groups = {};
+        const t = target.groups;
+        if (changes.groups.created)
+            t.created = appendField(t.created, changes.groups.created);
+        if (changes.groups.updated) {
+            t.updated = appendGroupUpdates(t.updated, changes.groups.updated, index.groups);
+        }
+        if (changes.groups.deleted)
+            t.deleted = appendField(t.deleted, changes.groups.deleted);
+    }
+    // layerReorder / groupReorder (dedicated, overwritten)
+    if (changes.layerReorder)
+        target.layerReorder = changes.layerReorder;
+    if (changes.groupReorder)
+        target.groupReorder = changes.groupReorder;
+    // selection (overwritten)
+    if (changes.selection)
+        target.selection = changes.selection;
+    // editing
+    if (changes.editing) {
+        if (!target.editing)
+            target.editing = {};
+        const t = target.editing;
+        if (changes.editing.started)
+            t.started = appendField(t.started, changes.editing.started);
+        if (changes.editing.ended)
+            t.ended = appendField(t.ended, changes.editing.ended);
+    }
+    // tentative / mode / metadata (overwritten)
+    if (changes.tentative)
+        target.tentative = changes.tentative;
+    if (changes.mode)
+        target.mode = changes.mode;
+    if (changes.uiStateChanged)
+        target.uiStateChanged = true;
+    if (changes.metadata)
+        target.metadata = changes.metadata;
+}
+export class ChangeBus {
+    /**
+     * @param beforeFlush Called when the outermost operation is about to notify, before the
+     *   listeners (MemoryStore freezes the objects it built during the flush here)
+     */
+    constructor(beforeFlush) {
+        _ChangeBus_instances.add(this);
+        _ChangeBus_listeners.set(this, new Set());
+        _ChangeBus_beforeFlush.set(this, void 0);
+        _ChangeBus_transactionDepth.set(this, 0);
+        _ChangeBus_pendingChanges.set(this, {});
+        _ChangeBus_currentSource.set(this, 'local');
+        _ChangeBus_updateIndex.set(this, { layers: new Map(), groups: new Map() });
+        __classPrivateFieldSet(this, _ChangeBus_beforeFlush, beforeFlush, "f");
+    }
+    subscribe(listener) {
+        __classPrivateFieldGet(this, _ChangeBus_listeners, "f").add(listener);
+        return () => {
+            __classPrivateFieldGet(this, _ChangeBus_listeners, "f").delete(listener);
+        };
+    }
+    /**
+     * Runs fn inside a transaction. Nesting is supported, and pendingChanges is flushed to the
+     * listeners at the moment the outermost transact finishes.
+     *
+     * Not atomic: when fn throws, what it changed before the throw is flushed like any other
+     * change and the exception propagates.
+     */
+    transact(fn, source = 'local') {
+        var _a, _b;
+        const wasInTransaction = __classPrivateFieldGet(this, _ChangeBus_transactionDepth, "f") > 0;
+        __classPrivateFieldSet(this, _ChangeBus_transactionDepth, (_a = __classPrivateFieldGet(this, _ChangeBus_transactionDepth, "f"), _a++, _a), "f");
+        // Set source only for the outermost transaction
+        if (!wasInTransaction) {
+            __classPrivateFieldSet(this, _ChangeBus_currentSource, source, "f");
+        }
+        try {
+            return fn();
+        }
+        finally {
+            __classPrivateFieldSet(this, _ChangeBus_transactionDepth, (_b = __classPrivateFieldGet(this, _ChangeBus_transactionDepth, "f"), _b--, _b), "f");
+            if (__classPrivateFieldGet(this, _ChangeBus_transactionDepth, "f") === 0) {
+                __classPrivateFieldGet(this, _ChangeBus_instances, "m", _ChangeBus_flushChanges).call(this);
+                __classPrivateFieldSet(this, _ChangeBus_currentSource, 'local', "f");
+            }
+        }
+    }
+    /**
+     * Merges the changes into pendingChanges. Flushes immediately if outside a transaction.
+     */
+    merge(changes) {
+        appendChanges(__classPrivateFieldGet(this, _ChangeBus_pendingChanges, "f"), changes, __classPrivateFieldGet(this, _ChangeBus_updateIndex, "f"));
+        if (__classPrivateFieldGet(this, _ChangeBus_transactionDepth, "f") === 0) {
+            __classPrivateFieldGet(this, _ChangeBus_instances, "m", _ChangeBus_flushChanges).call(this);
+        }
+    }
+    /** Whether an update entry for this layer is already stacked within the same flush */
+    hasPendingLayerUpdate(id) {
+        return __classPrivateFieldGet(this, _ChangeBus_updateIndex, "f").layers.has(id);
+    }
+    /** Whether an update entry for this group is already stacked within the same flush */
+    hasPendingGroupUpdate(id) {
+        return __classPrivateFieldGet(this, _ChangeBus_updateIndex, "f").groups.has(id);
+    }
+    /**
+     * Stacks one layers.updated entry.
+     *
+     * Since folding leaves only the "first state" as previous, when hasPendingLayerUpdate is
+     * true the caller may pass undefined instead of building one (the existing entry's previous
+     * is used as is). When there is no entry, undefined means the state before and after the
+     * change is the same, so layer itself is used.
+     */
+    mergeLayerUpdate(layer, previous) {
+        this.merge({ layers: { updated: [{ id: layer.id, layer, previous: previous ?? layer }] } });
+    }
+    /** Stacks one groups.updated entry (previous is handled as in mergeLayerUpdate) */
+    mergeGroupUpdate(group, previous) {
+        this.merge({ groups: { updated: [{ id: group.id, group, previous: previous ?? group }] } });
+    }
+}
+_ChangeBus_listeners = new WeakMap(), _ChangeBus_beforeFlush = new WeakMap(), _ChangeBus_transactionDepth = new WeakMap(), _ChangeBus_pendingChanges = new WeakMap(), _ChangeBus_currentSource = new WeakMap(), _ChangeBus_updateIndex = new WeakMap(), _ChangeBus_instances = new WeakSet(), _ChangeBus_flushChanges = function _ChangeBus_flushChanges() {
+    __classPrivateFieldGet(this, _ChangeBus_beforeFlush, "f")?.call(this);
+    if (Object.keys(__classPrivateFieldGet(this, _ChangeBus_pendingChanges, "f")).length === 0)
+        return;
+    const changes = __classPrivateFieldGet(this, _ChangeBus_pendingChanges, "f");
+    changes.source = __classPrivateFieldGet(this, _ChangeBus_currentSource, "f");
+    // Swap in a new container for the next accumulation (the flushed object is retained by the
+    // listeners, so always recreate it so that appends do not pollute it).
+    __classPrivateFieldSet(this, _ChangeBus_pendingChanges, {}, "f");
+    __classPrivateFieldSet(this, _ChangeBus_updateIndex, { layers: new Map(), groups: new Map() }, "f");
+    // Every listener gets the notification: one that throws is reported and the others still
+    // run, so the Store and its subscribers (rendering, the mode manager, the spatial index, a
+    // history) never drift apart because of another subscriber's bug.
+    for (const listener of [...__classPrivateFieldGet(this, _ChangeBus_listeners, "f")]) {
+        try {
+            listener(changes);
+        }
+        catch (error) {
+            console.error('Error in a store listener:', error);
+        }
+    }
+};

package/dist/store/memory/file-store.d.ts

@@ -0,0 +1,15 @@
+/**
+ * FileStore
+ *
+ * A Map wrapper for embedded files (FileData) such as images. It provides only CRUD,
+ * independently of Feature / Layer / Group. Change notification is unnecessary (because the
+ * rendering pipeline references the binary data directly).
+ */
+import type { FileData } from '../types.js';
+export declare class FileStore {
+    #private;
+    create(file: FileData): void;
+    get(id: string): FileData | undefined;
+    getAll(): FileData[];
+    delete(id: string): void;
+}

package/dist/store/memory/file-store.js

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+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 _FileStore_files;
+import { frozenCopy } from './frozen.js';
+export class FileStore {
+    constructor() {
+        _FileStore_files.set(this, new Map());
+    }
+    create(file) {
+        if (__classPrivateFieldGet(this, _FileStore_files, "f").has(file.id)) {
+            throw new Error(`File with id "${file.id}" already exists`);
+        }
+        __classPrivateFieldGet(this, _FileStore_files, "f").set(file.id, frozenCopy({ ...file }));
+    }
+    get(id) {
+        return __classPrivateFieldGet(this, _FileStore_files, "f").get(id);
+    }
+    getAll() {
+        return Array.from(__classPrivateFieldGet(this, _FileStore_files, "f").values());
+    }
+    delete(id) {
+        if (!__classPrivateFieldGet(this, _FileStore_files, "f").has(id)) {
+            throw new Error(`File with id "${id}" not found`);
+        }
+        __classPrivateFieldGet(this, _FileStore_files, "f").delete(id);
+    }
+}
+_FileStore_files = new WeakMap();

package/dist/store/memory/frozen.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Frozen copies for the in-memory document
+ *
+ * MemoryStore keeps its own copy of what it is given and freezes it, so that a caller's
+ * array is never shared with the store and a write into a returned object throws instead of
+ * changing the store behind its notifications and its derived index.
+ */
+import type { Feature } from '../types.js';
+/**
+ * Returns a deeply frozen copy of a JSON-like value
+ *
+ * Arrays and plain objects are copied and frozen. A value that is already frozen is taken
+ * as it is (the store's own objects, passed back in an update). Other objects (a Date, a
+ * typed array, a class instance) are kept as they are.
+ */
+export declare function frozenCopy<T>(value: T): T;
+/**
+ * Returns a frozen feature built from a base and a set of changes, copying only the fields
+ * the changes carry (the base is already the store's frozen feature)
+ */
+export declare function frozenFeature(base: Feature | undefined, changes: Partial<Feature>): Feature;

package/dist/store/memory/frozen.js

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Returns a deeply frozen copy of a JSON-like value
+ *
+ * Arrays and plain objects are copied and frozen. A value that is already frozen is taken
+ * as it is (the store's own objects, passed back in an update). Other objects (a Date, a
+ * typed array, a class instance) are kept as they are.
+ */
+export function frozenCopy(value) {
+    if (value === null || typeof value !== 'object' || Object.isFrozen(value))
+        return value;
+    if (Array.isArray(value)) {
+        const copy = new Array(value.length);
+        for (let i = 0; i < value.length; i++)
+            copy[i] = frozenCopy(value[i]);
+        return Object.freeze(copy);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return value;
+    const copy = prototype === null ? Object.create(null) : {};
+    for (const key of Object.keys(value)) {
+        const item = frozenCopy(value[key]);
+        if (key === '__proto__') {
+            // An own key named __proto__ stays an ordinary key (an assignment would replace the
+            // prototype of the copy)
+            Object.defineProperty(copy, key, {
+                value: item,
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+        }
+        else {
+            copy[key] = item;
+        }
+    }
+    return Object.freeze(copy);
+}
+/**
+ * Returns a frozen feature built from a base and a set of changes, copying only the fields
+ * the changes carry (the base is already the store's frozen feature)
+ */
+export function frozenFeature(base, changes) {
+    const feature = { ...base };
+    for (const key of Object.keys(changes)) {
+        feature[key] = frozenCopy(changes[key]);
+    }
+    return Object.freeze(feature);
+}

package/dist/store/memory/ui-state.d.ts

@@ -0,0 +1,51 @@
+/**
+ * MemoryUiState
+ *
+ * The in-memory UiState core holds for every Store (selection / editing / tentative /
+ * boxSelection / dragState / vertexSelection / mode / read-only / interaction lock / local
+ * visibility). Each setter merges its change into the ChangeBus of the Store.
+ *
+ * - Selection / mode / features being edited / Tentative are included in data change
+ *   notifications
+ * - BoxSelection / DragState / VertexSelection are UI-only state, so they only raise the
+ *   uiStateChanged flag
+ */
+import type { UiState } from '../store.js';
+import type { BoxSelection, DragState, Mode, Selection, SelectionType, TentativeState, VertexSelection } from '../types.js';
+import type { ChangeBus } from './change-bus.js';
+export declare class MemoryUiState implements UiState {
+    #private;
+    constructor(bus: ChangeBus);
+    getSelection(): Selection;
+    setSelection(type: SelectionType | null, ids: string[]): void;
+    /**
+     * Removes a deleted feature, group or layer from the selection (internal use)
+     */
+    removeFromSelection(id: string): void;
+    getEditingIds(): readonly string[];
+    startEditing(ids: string[]): void;
+    endEditing(ids: string[]): void;
+    /** Removal from editing that accompanies a feature deletion (internal use) */
+    removeFromEditing(featureId: string): void;
+    getTentative(): TentativeState | null;
+    setTentative(state: TentativeState | null): void;
+    getBoxSelection(): BoxSelection | null;
+    setBoxSelection(box: BoxSelection | null): void;
+    getDragState(): DragState | null;
+    setDragState(state: DragState | null): void;
+    getSelectedVertices(): VertexSelection | null;
+    setSelectedVertices(selection: VertexSelection | null): void;
+    getFollowedVertices(): VertexSelection[] | null;
+    setFollowedVertices(selections: VertexSelection[] | null): void;
+    getMode(): Mode;
+    setMode(mode: Mode): void;
+    isReadOnly(): boolean;
+    setReadOnly(value: boolean): void;
+    isInteractionLocked(): boolean;
+    setInteractionLock(value: boolean): void;
+    isLocallyHidden(id: string): boolean;
+    getLocallyHidden(): ReadonlySet<string>;
+    setLocallyHidden(id: string, hidden: boolean): void;
+    /** Removes a deleted feature / group / layer from the hidden set (internal use). */
+    removeFromLocallyHidden(id: string): void;
+}