@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/store/local-visibility.js

@@ -7,21 +7,52 @@
  * @internal
  */
 export function isLocallyHidden(feature, store) {
-    if (store.isLocallyHidden(feature.id))
+    if (store.isHidden(feature.id))
         return true;
-    if (feature.groupId && store.isLocallyHidden(feature.groupId))
+    if (feature.groupId && store.isHidden(feature.groupId))
         return true;
-    if (store.isLocallyHidden(feature.layerId))
+    if (store.isHidden(feature.layerId))
         return true;
     return false;
 }
 /**
- * The list of features that should be displayed, for rendering and hit testing.
- * getOrderedFeatures (the pure list narrowed by the shared visible) with the locally
- * hidden ones removed on top of that.
+ * The features the document shows, in stacking order: listFeaturesInOrder without the ones
+ * whose own visible flag, or the one of their group or layer, is off. Local hiding is not
+ * applied.
+ *
+ * @internal
+ */
+export function listShownFeatures(store) {
+    const layers = new Map();
+    const groups = new Map();
+    const layerShown = (id) => {
+        let shown = layers.get(id);
+        if (shown === undefined) {
+            shown = store.getLayer(id)?.visible === true;
+            layers.set(id, shown);
+        }
+        return shown;
+    };
+    const groupShown = (id) => {
+        let shown = groups.get(id);
+        if (shown === undefined) {
+            shown = store.getGroup(id)?.visible !== false;
+            groups.set(id, shown);
+        }
+        return shown;
+    };
+    return store
+        .listFeaturesInOrder()
+        .filter((feature) => feature.visible &&
+        layerShown(feature.layerId) &&
+        (feature.groupId === undefined || groupShown(feature.groupId)));
+}
+/**
+ * The list of features that should be displayed, for rendering and hit testing:
+ * listShownFeatures with the locally hidden ones removed on top of that.
  *
  * @internal
  */
 export function getDisplayFeatures(store) {
-    return store.getOrderedFeatures().filter((feature) => !isLocallyHidden(feature, store));
+    return listShownFeatures(store).filter((feature) => !isLocallyHidden(feature, store));
 }

package/dist/store/lock.d.ts

@@ -27,12 +27,6 @@ export interface FeatureLockStore {
  *
  * 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;
 /**

package/dist/store/lock.js

@@ -5,12 +5,6 @@
  *
  * 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)

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

@@ -20,8 +20,8 @@
  * 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;
+import type { Group, Layer, StoreChange, UpdateSource } from '../types.js';
+export type StoreListener = (changes: StoreChange) => void;
 export declare class ChangeBus {
     #private;
     /**
@@ -41,7 +41,7 @@ export declare class ChangeBus {
     /**
      * Merges the changes into pendingChanges. Flushes immediately if outside a transaction.
      */
-    merge(changes: StateChanges): void;
+    merge(changes: StoreChange): 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 */

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

@@ -125,8 +125,20 @@ function appendChanges(target, changes, index) {
         target.mode = changes.mode;
     if (changes.uiStateChanged)
         target.uiStateChanged = true;
+    if (changes.reset === true)
+        target.reset = true;
     if (changes.metadata)
         target.metadata = changes.metadata;
+    // files
+    if (changes.files) {
+        if (!target.files)
+            target.files = {};
+        const t = target.files;
+        if (changes.files.created)
+            t.created = appendField(t.created, changes.files.created);
+        if (changes.files.deleted)
+            t.deleted = appendField(t.deleted, changes.files.deleted);
+    }
 }
 export class ChangeBus {
     /**

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

@@ -2,8 +2,8 @@
  * 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).
+ * independently of Feature / Layer / Group. The Store around it notifies the files created and
+ * deleted.
  */
 import type { FileData } from '../types.js';
 export declare class FileStore {

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

@@ -1,51 +1 @@
-/**
- * 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;
-}
+export {};

package/dist/store/memory/ui-state.js

@@ -11,115 +11,173 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _MemoryUiState_bus, _MemoryUiState_selection, _MemoryUiState_editingIds, _MemoryUiState_tentative, _MemoryUiState_boxSelection, _MemoryUiState_dragState, _MemoryUiState_selectedVertices, _MemoryUiState_followedVertices, _MemoryUiState_mode, _MemoryUiState_readOnly, _MemoryUiState_interactionLocked, _MemoryUiState_locallyHidden;
-export class MemoryUiState {
+var _MemoryClientState_bus, _MemoryClientState_selection, _MemoryClientState_editingIds, _MemoryClientState_selectedVertices, _MemoryClientState_mode, _MemoryClientState_readOnly, _MemoryClientState_interactionLocked, _MemoryClientState_locallyHidden, _MemoryDrawingState_bus, _MemoryDrawingState_tentative, _MemoryDrawingState_boxSelection, _MemoryDrawingState_dragState, _MemoryDrawingState_followedVertices;
+/**
+ * The state of this client the Store contract holds, in memory
+ *
+ * @internal
+ */
+export class MemoryClientState {
     constructor(bus) {
-        _MemoryUiState_bus.set(this, void 0);
-        _MemoryUiState_selection.set(this, { type: null, ids: [] });
-        _MemoryUiState_editingIds.set(this, []);
-        _MemoryUiState_tentative.set(this, null);
-        _MemoryUiState_boxSelection.set(this, null);
-        _MemoryUiState_dragState.set(this, null);
-        _MemoryUiState_selectedVertices.set(this, null);
-        _MemoryUiState_followedVertices.set(this, null);
-        _MemoryUiState_mode.set(this, 'select');
+        _MemoryClientState_bus.set(this, void 0);
+        _MemoryClientState_selection.set(this, { type: null, ids: [] });
+        _MemoryClientState_editingIds.set(this, []);
+        _MemoryClientState_selectedVertices.set(this, null);
+        _MemoryClientState_mode.set(this, 'select');
         // Read-only (forbids local writes to the document). Local state, not part of the document.
-        _MemoryUiState_readOnly.set(this, false);
+        _MemoryClientState_readOnly.set(this, false);
         // Interaction lock (selection is allowed, but starting an edit operation is suppressed).
         // Local state that is orthogonal to readOnly and not part of the document. It does not stop writes
         // to the Store; it only rejects the start of an editing interaction from user input, for a
         // screen where the drawing is looked at and selected but not edited.
-        _MemoryUiState_interactionLocked.set(this, false);
+        _MemoryClientState_interactionLocked.set(this, false);
         // The set of hidden ids for this client only (feature / group / layer). It is a layer separate
         // from the visible flag of the document, and rendering, hit testing and box selection all
         // respect it. Not part of the document.
-        _MemoryUiState_locallyHidden.set(this, new Set());
-        __classPrivateFieldSet(this, _MemoryUiState_bus, bus, "f");
+        _MemoryClientState_locallyHidden.set(this, new Set());
+        __classPrivateFieldSet(this, _MemoryClientState_bus, bus, "f");
     }
     // Selection
     getSelection() {
-        return { type: __classPrivateFieldGet(this, _MemoryUiState_selection, "f").type, ids: [...__classPrivateFieldGet(this, _MemoryUiState_selection, "f").ids] };
+        return { type: __classPrivateFieldGet(this, _MemoryClientState_selection, "f").type, ids: [...__classPrivateFieldGet(this, _MemoryClientState_selection, "f").ids] };
     }
     setSelection(type, ids) {
-        const previousType = __classPrivateFieldGet(this, _MemoryUiState_selection, "f").type;
-        const previousIds = [...__classPrivateFieldGet(this, _MemoryUiState_selection, "f").ids];
-        __classPrivateFieldSet(this, _MemoryUiState_selection, { type, ids: [...ids] }, "f");
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({
+        const previousType = __classPrivateFieldGet(this, _MemoryClientState_selection, "f").type;
+        const previousIds = [...__classPrivateFieldGet(this, _MemoryClientState_selection, "f").ids];
+        __classPrivateFieldSet(this, _MemoryClientState_selection, { type, ids: [...ids] }, "f");
+        __classPrivateFieldGet(this, _MemoryClientState_bus, "f").merge({
             selection: { type, ids: [...ids], previousType, previousIds },
         });
     }
-    /**
-     * Removes a deleted feature, group or layer from the selection (internal use)
-     */
-    removeFromSelection(id) {
-        const previousType = __classPrivateFieldGet(this, _MemoryUiState_selection, "f").type;
-        const previousIds = __classPrivateFieldGet(this, _MemoryUiState_selection, "f").ids;
-        if (!previousIds.includes(id))
-            return;
-        const ids = previousIds.filter((selected) => selected !== id);
-        const type = ids.length === 0 ? null : previousType;
-        __classPrivateFieldSet(this, _MemoryUiState_selection, { type, ids }, "f");
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({
-            selection: { type, ids: [...ids], previousType, previousIds: [...previousIds] },
-        });
-    }
     // Editing
     getEditingIds() {
         // Returning the internal array as is would let a retained snapshot be rewritten by a later
         // startEditing/endEditing, so a defensive copy is returned.
-        return [...__classPrivateFieldGet(this, _MemoryUiState_editingIds, "f")];
+        return [...__classPrivateFieldGet(this, _MemoryClientState_editingIds, "f")];
     }
     startEditing(ids) {
-        const newIds = ids.filter((id) => !__classPrivateFieldGet(this, _MemoryUiState_editingIds, "f").includes(id));
+        const newIds = ids.filter((id) => !__classPrivateFieldGet(this, _MemoryClientState_editingIds, "f").includes(id));
         if (newIds.length === 0)
             return;
-        __classPrivateFieldGet(this, _MemoryUiState_editingIds, "f").push(...newIds);
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ editing: { started: newIds } });
+        __classPrivateFieldGet(this, _MemoryClientState_editingIds, "f").push(...newIds);
+        __classPrivateFieldGet(this, _MemoryClientState_bus, "f").merge({ editing: { started: newIds } });
     }
     endEditing(ids) {
-        const endedIds = ids.filter((id) => __classPrivateFieldGet(this, _MemoryUiState_editingIds, "f").includes(id));
+        const endedIds = ids.filter((id) => __classPrivateFieldGet(this, _MemoryClientState_editingIds, "f").includes(id));
         if (endedIds.length === 0)
             return;
-        __classPrivateFieldSet(this, _MemoryUiState_editingIds, __classPrivateFieldGet(this, _MemoryUiState_editingIds, "f").filter((id) => !ids.includes(id)), "f");
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ editing: { ended: endedIds } });
+        __classPrivateFieldSet(this, _MemoryClientState_editingIds, __classPrivateFieldGet(this, _MemoryClientState_editingIds, "f").filter((id) => !ids.includes(id)), "f");
+        __classPrivateFieldGet(this, _MemoryClientState_bus, "f").merge({ editing: { ended: endedIds } });
+    }
+    // VertexSelection
+    getVertexSelection() {
+        return __classPrivateFieldGet(this, _MemoryClientState_selectedVertices, "f");
+    }
+    setSelectedVertices(selection) {
+        __classPrivateFieldSet(this, _MemoryClientState_selectedVertices, selection
+            ? {
+                featureId: selection.featureId,
+                vertices: selection.vertices.map((ref) => ({ ...ref })),
+            }
+            : null, "f");
+        __classPrivateFieldGet(this, _MemoryClientState_bus, "f").merge({ uiStateChanged: true });
+    }
+    // Mode
+    getMode() {
+        return __classPrivateFieldGet(this, _MemoryClientState_mode, "f");
+    }
+    setMode(mode) {
+        const previous = __classPrivateFieldGet(this, _MemoryClientState_mode, "f");
+        if (mode === previous)
+            return;
+        __classPrivateFieldSet(this, _MemoryClientState_mode, mode, "f");
+        __classPrivateFieldGet(this, _MemoryClientState_bus, "f").merge({ mode: { mode, previous } });
+    }
+    // ReadOnly
+    isReadOnly() {
+        return __classPrivateFieldGet(this, _MemoryClientState_readOnly, "f");
+    }
+    setReadOnly(value) {
+        if (__classPrivateFieldGet(this, _MemoryClientState_readOnly, "f") === value)
+            return;
+        __classPrivateFieldSet(this, _MemoryClientState_readOnly, value, "f");
+        // Whether handles are shown depends on read-only, so prompt a re-render.
+        __classPrivateFieldGet(this, _MemoryClientState_bus, "f").merge({ uiStateChanged: true });
     }
-    /** Removal from editing that accompanies a feature deletion (internal use) */
-    removeFromEditing(featureId) {
-        const idx = __classPrivateFieldGet(this, _MemoryUiState_editingIds, "f").indexOf(featureId);
-        if (idx === -1)
+    // InteractionLock
+    isInteractionLocked() {
+        return __classPrivateFieldGet(this, _MemoryClientState_interactionLocked, "f");
+    }
+    setInteractionLock(value) {
+        if (__classPrivateFieldGet(this, _MemoryClientState_interactionLocked, "f") === value)
             return;
-        __classPrivateFieldGet(this, _MemoryUiState_editingIds, "f").splice(idx, 1);
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ editing: { ended: [featureId] } });
+        __classPrivateFieldSet(this, _MemoryClientState_interactionLocked, value, "f");
+        // While the interaction lock is on, no handles are shown (only the selection box), so
+        // prompt a re-render.
+        __classPrivateFieldGet(this, _MemoryClientState_bus, "f").merge({ uiStateChanged: true });
+    }
+    // LocallyHidden
+    isHidden(id) {
+        return __classPrivateFieldGet(this, _MemoryClientState_locallyHidden, "f").has(id);
+    }
+    listHidden() {
+        return __classPrivateFieldGet(this, _MemoryClientState_locallyHidden, "f");
+    }
+    setLocallyHidden(id, hidden) {
+        const changed = hidden ? !__classPrivateFieldGet(this, _MemoryClientState_locallyHidden, "f").has(id) : __classPrivateFieldGet(this, _MemoryClientState_locallyHidden, "f").has(id);
+        if (!changed)
+            return;
+        if (hidden)
+            __classPrivateFieldGet(this, _MemoryClientState_locallyHidden, "f").add(id);
+        else
+            __classPrivateFieldGet(this, _MemoryClientState_locallyHidden, "f").delete(id);
+        __classPrivateFieldGet(this, _MemoryClientState_bus, "f").merge({ uiStateChanged: true });
+    }
+}
+_MemoryClientState_bus = new WeakMap(), _MemoryClientState_selection = new WeakMap(), _MemoryClientState_editingIds = new WeakMap(), _MemoryClientState_selectedVertices = new WeakMap(), _MemoryClientState_mode = new WeakMap(), _MemoryClientState_readOnly = new WeakMap(), _MemoryClientState_interactionLocked = new WeakMap(), _MemoryClientState_locallyHidden = new WeakMap();
+/**
+ * The state only the drawing reads, in memory
+ *
+ * @internal
+ */
+export class MemoryDrawingState {
+    constructor(bus) {
+        _MemoryDrawingState_bus.set(this, void 0);
+        _MemoryDrawingState_tentative.set(this, null);
+        _MemoryDrawingState_boxSelection.set(this, null);
+        _MemoryDrawingState_dragState.set(this, null);
+        _MemoryDrawingState_followedVertices.set(this, null);
+        __classPrivateFieldSet(this, _MemoryDrawingState_bus, bus, "f");
     }
     // Tentative
     getTentative() {
-        return __classPrivateFieldGet(this, _MemoryUiState_tentative, "f");
+        return __classPrivateFieldGet(this, _MemoryDrawingState_tentative, "f");
     }
     setTentative(state) {
-        const previous = __classPrivateFieldGet(this, _MemoryUiState_tentative, "f");
-        __classPrivateFieldSet(this, _MemoryUiState_tentative, state ? { ...state, coordinates: [...state.coordinates] } : null, "f");
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ tentative: { state: __classPrivateFieldGet(this, _MemoryUiState_tentative, "f"), previous } });
+        const previous = __classPrivateFieldGet(this, _MemoryDrawingState_tentative, "f");
+        __classPrivateFieldSet(this, _MemoryDrawingState_tentative, state ? { ...state, coordinates: [...state.coordinates] } : null, "f");
+        __classPrivateFieldGet(this, _MemoryDrawingState_bus, "f").merge({ tentative: { state: __classPrivateFieldGet(this, _MemoryDrawingState_tentative, "f"), previous } });
     }
     // BoxSelection
     getBoxSelection() {
-        return __classPrivateFieldGet(this, _MemoryUiState_boxSelection, "f");
+        return __classPrivateFieldGet(this, _MemoryDrawingState_boxSelection, "f");
     }
     setBoxSelection(box) {
-        __classPrivateFieldSet(this, _MemoryUiState_boxSelection, box
+        __classPrivateFieldSet(this, _MemoryDrawingState_boxSelection, box
             ? {
                 startPoint: [...box.startPoint],
                 endPoint: [...box.endPoint],
                 previousSelection: [...box.previousSelection],
             }
             : null, "f");
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ uiStateChanged: true });
+        __classPrivateFieldGet(this, _MemoryDrawingState_bus, "f").merge({ uiStateChanged: true });
     }
     // DragState
     getDragState() {
-        return __classPrivateFieldGet(this, _MemoryUiState_dragState, "f");
+        return __classPrivateFieldGet(this, _MemoryDrawingState_dragState, "f");
     }
     setDragState(state) {
-        __classPrivateFieldSet(this, _MemoryUiState_dragState, state
+        __classPrivateFieldSet(this, _MemoryDrawingState_dragState, state
             ? {
                 operation: state.operation,
                 activeVertex: state.activeVertex ? { ...state.activeVertex } : undefined,
@@ -128,96 +186,26 @@ export class MemoryUiState {
                 movingFeatureIds: state.movingFeatureIds ? [...state.movingFeatureIds] : undefined,
             }
             : null, "f");
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ uiStateChanged: true });
-    }
-    // VertexSelection
-    getSelectedVertices() {
-        return __classPrivateFieldGet(this, _MemoryUiState_selectedVertices, "f");
-    }
-    setSelectedVertices(selection) {
-        __classPrivateFieldSet(this, _MemoryUiState_selectedVertices, selection
-            ? {
-                featureId: selection.featureId,
-                vertexIndices: selection.vertexIndices.map((ref) => ({ ...ref })),
-            }
-            : null, "f");
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ uiStateChanged: true });
+        __classPrivateFieldGet(this, _MemoryDrawingState_bus, "f").merge({ uiStateChanged: true });
     }
     // FollowedVertices (vertices that follow along when shared vertices move together. Set only
     // during a drag)
     getFollowedVertices() {
-        return __classPrivateFieldGet(this, _MemoryUiState_followedVertices, "f");
+        return __classPrivateFieldGet(this, _MemoryDrawingState_followedVertices, "f");
     }
     setFollowedVertices(selections) {
         // Since null is written every time a drag ends, null -> null is not notified (raising
         // uiStateChanged every time would cause a wasteful re-render).
-        if (__classPrivateFieldGet(this, _MemoryUiState_followedVertices, "f") === null && (selections === null || selections.length === 0)) {
+        if (__classPrivateFieldGet(this, _MemoryDrawingState_followedVertices, "f") === null && (selections === null || selections.length === 0)) {
             return;
         }
-        __classPrivateFieldSet(this, _MemoryUiState_followedVertices, selections && selections.length > 0
+        __classPrivateFieldSet(this, _MemoryDrawingState_followedVertices, selections && selections.length > 0
             ? selections.map((selection) => ({
                 featureId: selection.featureId,
-                vertexIndices: selection.vertexIndices.map((ref) => ({ ...ref })),
+                vertices: selection.vertices.map((ref) => ({ ...ref })),
             }))
             : null, "f");
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ uiStateChanged: true });
-    }
-    // Mode
-    getMode() {
-        return __classPrivateFieldGet(this, _MemoryUiState_mode, "f");
-    }
-    setMode(mode) {
-        const previous = __classPrivateFieldGet(this, _MemoryUiState_mode, "f");
-        if (mode === previous)
-            return;
-        __classPrivateFieldSet(this, _MemoryUiState_mode, mode, "f");
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ mode: { mode, previous } });
-    }
-    // ReadOnly
-    isReadOnly() {
-        return __classPrivateFieldGet(this, _MemoryUiState_readOnly, "f");
-    }
-    setReadOnly(value) {
-        if (__classPrivateFieldGet(this, _MemoryUiState_readOnly, "f") === value)
-            return;
-        __classPrivateFieldSet(this, _MemoryUiState_readOnly, value, "f");
-        // Whether handles are shown depends on read-only, so prompt a re-render.
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ uiStateChanged: true });
-    }
-    // InteractionLock
-    isInteractionLocked() {
-        return __classPrivateFieldGet(this, _MemoryUiState_interactionLocked, "f");
-    }
-    setInteractionLock(value) {
-        if (__classPrivateFieldGet(this, _MemoryUiState_interactionLocked, "f") === value)
-            return;
-        __classPrivateFieldSet(this, _MemoryUiState_interactionLocked, value, "f");
-        // While the interaction lock is on, no handles are shown (only the selection box), so
-        // prompt a re-render.
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ uiStateChanged: true });
-    }
-    // LocallyHidden
-    isLocallyHidden(id) {
-        return __classPrivateFieldGet(this, _MemoryUiState_locallyHidden, "f").has(id);
-    }
-    getLocallyHidden() {
-        return __classPrivateFieldGet(this, _MemoryUiState_locallyHidden, "f");
-    }
-    setLocallyHidden(id, hidden) {
-        const changed = hidden ? !__classPrivateFieldGet(this, _MemoryUiState_locallyHidden, "f").has(id) : __classPrivateFieldGet(this, _MemoryUiState_locallyHidden, "f").has(id);
-        if (!changed)
-            return;
-        if (hidden)
-            __classPrivateFieldGet(this, _MemoryUiState_locallyHidden, "f").add(id);
-        else
-            __classPrivateFieldGet(this, _MemoryUiState_locallyHidden, "f").delete(id);
-        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ uiStateChanged: true });
-    }
-    /** Removes a deleted feature / group / layer from the hidden set (internal use). */
-    removeFromLocallyHidden(id) {
-        if (__classPrivateFieldGet(this, _MemoryUiState_locallyHidden, "f").delete(id)) {
-            __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ uiStateChanged: true });
-        }
+        __classPrivateFieldGet(this, _MemoryDrawingState_bus, "f").merge({ uiStateChanged: true });
     }
 }
-_MemoryUiState_bus = new WeakMap(), _MemoryUiState_selection = new WeakMap(), _MemoryUiState_editingIds = new WeakMap(), _MemoryUiState_tentative = new WeakMap(), _MemoryUiState_boxSelection = new WeakMap(), _MemoryUiState_dragState = new WeakMap(), _MemoryUiState_selectedVertices = new WeakMap(), _MemoryUiState_followedVertices = new WeakMap(), _MemoryUiState_mode = new WeakMap(), _MemoryUiState_readOnly = new WeakMap(), _MemoryUiState_interactionLocked = new WeakMap(), _MemoryUiState_locallyHidden = new WeakMap();
+_MemoryDrawingState_bus = new WeakMap(), _MemoryDrawingState_tentative = new WeakMap(), _MemoryDrawingState_boxSelection = new WeakMap(), _MemoryDrawingState_dragState = new WeakMap(), _MemoryDrawingState_followedVertices = new WeakMap();

package/dist/store/memory.d.ts

@@ -3,19 +3,12 @@ import type { Store } from './store.js';
  * The in-memory Store, the default
  *
  * `new MemoryStore()` is a complete Store (the document and the local state); it is what
- * `createMapLibreGLDraw` uses when no store is given.
+ * `createDraw` uses when no store is given.
  *
  * It keeps its own copy of what it is given and freezes what it returns. A feature, a layer
  * or a group it has returned or notified never changes afterwards (a change replaces it), and
  * writing into one throws a `TypeError` instead of changing the store behind its
  * notifications.
- *
- * @example
- * ```ts
- * // Create the store yourself to keep a reference to it (to read it in a test, say)
- * const store = new MemoryStore();
- * const draw = createMapLibreGLDraw(map, { store });
- * ```
  */
 export interface MemoryStore extends Store {
 }