@sakuzu/maplibre-gl-draw 1.0.0

package/dist/store/draw-store.js

@@ -0,0 +1,396 @@
+// 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 _DrawStore_instances, _DrawStore_document, _DrawStore_bus, _DrawStore_ui, _DrawStore_write, _DrawStore_receive, _DrawStore_forget, _DrawStore_pruneInvisible, _DrawStore_pruneVertices;
+/**
+ * DrawStore
+ *
+ * The Store core works with: a DocumentStore (the in-memory one, or one the host gave) and
+ * the local UiState of this client behind one gate.
+ *
+ *   - Read-only is enforced here, at the write methods, and nowhere else. A refused write
+ *     returns false and touches nothing. The DocumentStore never sees the gate, so changes
+ *     applied to the document from elsewhere are not stopped by it.
+ *   - The notifications of the document are forwarded into the ChangeBus of the local state,
+ *     so a listener gets one StateChanges per transaction with both kinds of change.
+ *   - Deletions reach the local state: the id of a deleted feature, group or layer leaves the
+ *     selection, the features being edited and the locally hidden set, whatever deleted it.
+ *   - The selection holds only what can be seen: a change that hides a selected item (its own
+ *     visible flag, the one of its group or layer, or local hiding) takes it out of the
+ *     selection, and the vertex selection ends when its feature is deleted or its coordinates
+ *     change other than by a drag. This is the only place that keeps these invariants; the
+ *     modes and the public API rely on it.
+ */
+import { ChangeBus } from './memory/change-bus.js';
+import { MemoryUiState } from './memory/ui-state.js';
+/**
+ * Returns the Store for a store option: a Store is used as it is, a DocumentStore gets the
+ * local state and the read-only gate of core around it
+ *
+ * @internal
+ */
+export function toStore(store) {
+    return store instanceof DrawStore ? store : new DrawStore(store);
+}
+/**
+ * The Store of core over a DocumentStore
+ *
+ * @internal
+ */
+export class DrawStore {
+    constructor(document) {
+        _DrawStore_instances.add(this);
+        _DrawStore_document.set(this, void 0);
+        _DrawStore_bus.set(this, new ChangeBus());
+        _DrawStore_ui.set(this, new MemoryUiState(__classPrivateFieldGet(this, _DrawStore_bus, "f")));
+        __classPrivateFieldSet(this, _DrawStore_document, document, "f");
+        document.subscribe((changes) => __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_receive).call(this, changes));
+    }
+    // ============================================================================
+    // The document: reads
+    // ============================================================================
+    getFeature(id) {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getFeature(id);
+    }
+    getAllFeatures() {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getAllFeatures();
+    }
+    getOrderedFeatures() {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getOrderedFeatures();
+    }
+    getLayer(id) {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getLayer(id);
+    }
+    getAllLayers() {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getAllLayers();
+    }
+    getLayerOrder() {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getLayerOrder();
+    }
+    getGroup(id) {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getGroup(id);
+    }
+    getAllGroups() {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getAllGroups();
+    }
+    getFile(id) {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getFile(id);
+    }
+    getAllFiles() {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getAllFiles();
+    }
+    getMetadata() {
+        return __classPrivateFieldGet(this, _DrawStore_document, "f").getMetadata();
+    }
+    // ============================================================================
+    // The document: writes (gated by read-only)
+    // ============================================================================
+    createFeature(feature) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").createFeature(feature));
+    }
+    updateFeature(id, updates, options) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").updateFeature(id, updates, options));
+    }
+    abortIntermediateUpdates(ids) {
+        __classPrivateFieldGet(this, _DrawStore_document, "f").abortIntermediateUpdates?.(ids);
+    }
+    deleteFeature(id) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => {
+            __classPrivateFieldGet(this, _DrawStore_document, "f").deleteFeature(id);
+            // At once, so that the rest of a transaction already sees the selection without it
+            __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_forget).call(this, id);
+        });
+    }
+    createLayer(layer) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").createLayer(layer));
+    }
+    updateLayer(id, updates) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").updateLayer(id, updates));
+    }
+    deleteLayer(id) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").deleteLayer(id));
+    }
+    setLayerOrder(order) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").setLayerOrder(order));
+    }
+    reorderInLayer(itemId, layerId, newIndex) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").reorderInLayer(itemId, layerId, newIndex));
+    }
+    reorderInGroup(featureId, groupId, newIndex) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").reorderInGroup(featureId, groupId, newIndex));
+    }
+    createGroup(group) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").createGroup(group));
+    }
+    updateGroup(id, updates) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").updateGroup(id, updates));
+    }
+    deleteGroup(id) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").deleteGroup(id));
+    }
+    createFile(file) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").createFile(file));
+    }
+    deleteFile(id) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").deleteFile(id));
+    }
+    setMetadata(metadata) {
+        return __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_write).call(this, () => __classPrivateFieldGet(this, _DrawStore_document, "f").setMetadata(metadata));
+    }
+    // ============================================================================
+    // The local state
+    // ============================================================================
+    getSelection() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").getSelection();
+    }
+    setSelection(type, ids) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setSelection(type, ids);
+    }
+    getEditingIds() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").getEditingIds();
+    }
+    startEditing(ids) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").startEditing(ids);
+    }
+    endEditing(ids) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").endEditing(ids);
+    }
+    getTentative() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").getTentative();
+    }
+    setTentative(state) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setTentative(state);
+    }
+    getBoxSelection() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").getBoxSelection();
+    }
+    setBoxSelection(box) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setBoxSelection(box);
+    }
+    getDragState() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").getDragState();
+    }
+    setDragState(state) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setDragState(state);
+    }
+    getSelectedVertices() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").getSelectedVertices();
+    }
+    setSelectedVertices(selection) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setSelectedVertices(selection);
+    }
+    getFollowedVertices() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").getFollowedVertices();
+    }
+    setFollowedVertices(selections) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setFollowedVertices(selections);
+    }
+    getMode() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").getMode();
+    }
+    setMode(mode) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setMode(mode);
+    }
+    isReadOnly() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").isReadOnly();
+    }
+    setReadOnly(value) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setReadOnly(value);
+    }
+    isInteractionLocked() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").isInteractionLocked();
+    }
+    setInteractionLock(value) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setInteractionLock(value);
+    }
+    isLocallyHidden(id) {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").isLocallyHidden(id);
+    }
+    getLocallyHidden() {
+        return __classPrivateFieldGet(this, _DrawStore_ui, "f").getLocallyHidden();
+    }
+    setLocallyHidden(id, hidden) {
+        __classPrivateFieldGet(this, _DrawStore_bus, "f").transact(() => {
+            __classPrivateFieldGet(this, _DrawStore_ui, "f").setLocallyHidden(id, hidden);
+            if (hidden)
+                __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_pruneInvisible).call(this);
+        }, 'local');
+    }
+    // ============================================================================
+    // Subscription and transactions
+    // ============================================================================
+    subscribe(listener) {
+        return __classPrivateFieldGet(this, _DrawStore_bus, "f").subscribe(listener);
+    }
+    transact(fn, source = 'local') {
+        return __classPrivateFieldGet(this, _DrawStore_bus, "f").transact(() => __classPrivateFieldGet(this, _DrawStore_document, "f").transact(fn, source), source);
+    }
+}
+_DrawStore_document = new WeakMap(), _DrawStore_bus = new WeakMap(), _DrawStore_ui = new WeakMap(), _DrawStore_instances = new WeakSet(), _DrawStore_write = function _DrawStore_write(fn) {
+    if (__classPrivateFieldGet(this, _DrawStore_ui, "f").isReadOnly())
+        return false;
+    this.transact(fn);
+    return true;
+}, _DrawStore_receive = function _DrawStore_receive(changes) {
+    __classPrivateFieldGet(this, _DrawStore_bus, "f").transact(() => {
+        __classPrivateFieldGet(this, _DrawStore_bus, "f").merge(documentPart(changes));
+        for (const feature of changes.features?.deleted ?? [])
+            __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_forget).call(this, feature.id);
+        for (const group of changes.groups?.deleted ?? [])
+            __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_forget).call(this, group.id);
+        for (const layer of changes.layers?.deleted ?? [])
+            __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_forget).call(this, layer.id);
+        if (mayHide(changes))
+            __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_pruneInvisible).call(this);
+        __classPrivateFieldGet(this, _DrawStore_instances, "m", _DrawStore_pruneVertices).call(this, changes);
+    }, changes.source ?? 'local');
+}, _DrawStore_forget = function _DrawStore_forget(id) {
+    if (__classPrivateFieldGet(this, _DrawStore_document, "f").getFeature(id) || __classPrivateFieldGet(this, _DrawStore_document, "f").getGroup(id))
+        return;
+    if (__classPrivateFieldGet(this, _DrawStore_document, "f").getLayer(id))
+        return;
+    __classPrivateFieldGet(this, _DrawStore_ui, "f").removeFromSelection(id);
+    __classPrivateFieldGet(this, _DrawStore_ui, "f").removeFromEditing(id);
+    __classPrivateFieldGet(this, _DrawStore_ui, "f").removeFromLocallyHidden(id);
+}, _DrawStore_pruneInvisible = function _DrawStore_pruneInvisible() {
+    const selection = __classPrivateFieldGet(this, _DrawStore_ui, "f").getSelection();
+    const type = selection.type;
+    if (type === null || selection.ids.length === 0)
+        return;
+    const shown = createShownLookup(__classPrivateFieldGet(this, _DrawStore_document, "f"), __classPrivateFieldGet(this, _DrawStore_ui, "f"));
+    const kept = selection.ids.filter((id) => shown(type, id));
+    if (kept.length !== selection.ids.length) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setSelection(kept.length > 0 ? type : null, kept);
+    }
+}, _DrawStore_pruneVertices = function _DrawStore_pruneVertices(changes) {
+    const vertices = __classPrivateFieldGet(this, _DrawStore_ui, "f").getSelectedVertices();
+    if (!vertices)
+        return;
+    const featureId = vertices.featureId;
+    if (!__classPrivateFieldGet(this, _DrawStore_document, "f").getFeature(featureId)) {
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setSelectedVertices(null);
+        return;
+    }
+    const local = changes.source !== 'remote';
+    for (const entry of changes.features?.updated ?? []) {
+        if (entry.id !== featureId)
+            continue;
+        // The frames and the commit of a local drag keep the vertices being dragged selected
+        if (local && (entry.isIntermediate || __classPrivateFieldGet(this, _DrawStore_ui, "f").getDragState() !== null))
+            continue;
+        if (sameCoordinates(entry.feature.coordinates, entry.previous.coordinates))
+            continue;
+        __classPrivateFieldGet(this, _DrawStore_ui, "f").setSelectedVertices(null);
+        return;
+    }
+};
+/**
+ * Whether a notification can hide something that was visible: a change of the visible flag
+ * of a feature, or of its place (a feature moved into a hidden layer or group), and any
+ * update of a group or a layer
+ */
+function mayHide(changes) {
+    if (changes.layers?.updated?.length || changes.groups?.updated?.length)
+        return true;
+    for (const { feature, previous } of changes.features?.updated ?? []) {
+        if (feature.visible !== previous.visible)
+            return true;
+        if (feature.layerId !== previous.layerId || feature.groupId !== previous.groupId)
+            return true;
+    }
+    return false;
+}
+/**
+ * Whether a selected item can be seen: it exists, its own visible flag and the ones of its
+ * group and layer are on, and neither it nor its group nor its layer is hidden locally.
+ * Each layer and group is looked up once per call site (a document can take time to read a
+ * layer).
+ */
+function createShownLookup(document, ui) {
+    const layers = new Map();
+    const groups = new Map();
+    const layerShown = (id) => {
+        let shown = layers.get(id);
+        if (shown === undefined) {
+            const layer = document.getLayer(id);
+            shown = layer?.visible === true && !ui.isLocallyHidden(id);
+            layers.set(id, shown);
+        }
+        return shown;
+    };
+    const groupShown = (id) => {
+        let shown = groups.get(id);
+        if (shown === undefined) {
+            const group = document.getGroup(id);
+            const layerId = group ? groupLayerId(document, group) : undefined;
+            shown =
+                group?.visible === true &&
+                    !ui.isLocallyHidden(id) &&
+                    (layerId === undefined || layerShown(layerId));
+            groups.set(id, shown);
+        }
+        return shown;
+    };
+    return (type, id) => {
+        if (type === 'layer')
+            return layerShown(id);
+        if (type === 'group')
+            return groupShown(id);
+        const feature = document.getFeature(id);
+        if (!feature?.visible || ui.isLocallyHidden(id))
+            return false;
+        if (feature.groupId && !groupShown(feature.groupId))
+            return false;
+        return layerShown(feature.layerId);
+    };
+}
+/** The layer of a group: the one of its members, or the layer that lists an empty group */
+function groupLayerId(document, group) {
+    for (const featureId of group.featureIds) {
+        const feature = document.getFeature(featureId);
+        if (feature)
+            return feature.layerId;
+    }
+    return document.getAllLayers().find((layer) => layer.order.includes(group.id))?.id;
+}
+/** Whether two coordinate values are equal, position by position */
+function sameCoordinates(a, b) {
+    if (a === b)
+        return true;
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (!sameCoordinates(a[i], b[i]))
+            return false;
+    }
+    return true;
+}
+/** The categories of a notification that belong to the document */
+function documentPart(changes) {
+    const part = {};
+    if (changes.features)
+        part.features = changes.features;
+    if (changes.layers)
+        part.layers = changes.layers;
+    if (changes.groups)
+        part.groups = changes.groups;
+    if (changes.layerReorder)
+        part.layerReorder = changes.layerReorder;
+    if (changes.groupReorder)
+        part.groupReorder = changes.groupReorder;
+    if (changes.metadata)
+        part.metadata = changes.metadata;
+    if (changes.uiStateChanged)
+        part.uiStateChanged = true;
+    return part;
+}

package/dist/store/event-bridge.d.ts

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

package/dist/store/event-bridge.js

@@ -0,0 +1,161 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * EventBridge implementation
+ *
+ * @internal
+ */
+export class EventBridgeImpl {
+    constructor(store, emitter) {
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: store
+        });
+        Object.defineProperty(this, "emitter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: emitter
+        });
+        Object.defineProperty(this, "unsubscribe", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    start() {
+        if (this.unsubscribe)
+            return;
+        this.unsubscribe = this.store.subscribe((changes) => {
+            this.handleChanges(changes);
+        });
+    }
+    stop() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+    }
+    handleChanges(changes) {
+        // Every change is emitted as its own event, whatever the source: a subscriber that keeps
+        // another copy in sync (a server, an index) needs each of them. A subscriber that only
+        // rebuilds a view on any change subscribes to features.change instead, which comes once
+        // per flush, so a bulk load of N features does not cost it N rebuilds.
+        const features = changes.features;
+        if (features) {
+            const created = [...(features.created ?? [])];
+            const updated = (features.updated ?? []).map(({ feature, previous }) => ({
+                feature,
+                previous,
+            }));
+            const deleted = [...(features.deleted ?? [])];
+            for (const feature of created) {
+                this.emitter.emit('feature.create', { feature });
+            }
+            for (const payload of updated) {
+                this.emitter.emit('feature.update', payload);
+            }
+            for (const feature of deleted) {
+                this.emitter.emit('feature.delete', { feature });
+            }
+            if (created.length > 0 || updated.length > 0 || deleted.length > 0) {
+                this.emitter.emit('features.change', {
+                    created,
+                    updated,
+                    deleted,
+                    source: changes.source ?? 'local',
+                });
+            }
+        }
+        // Layer events
+        if (changes.layers) {
+            if (changes.layers.created) {
+                for (const layer of changes.layers.created) {
+                    this.emitter.emit('layer.create', { layer });
+                }
+            }
+            if (changes.layers.updated) {
+                for (const { layer, previous } of changes.layers.updated) {
+                    this.emitter.emit('layer.update', { layer, previous });
+                }
+            }
+            if (changes.layers.deleted) {
+                for (const layer of changes.layers.deleted) {
+                    this.emitter.emit('layer.delete', { layer });
+                }
+            }
+            if (changes.layers.orderChanged) {
+                this.emitter.emit('layer.reorder', {
+                    order: changes.layers.orderChanged.order,
+                    previous: changes.layers.orderChanged.previous,
+                });
+            }
+        }
+        // Group events
+        if (changes.groups) {
+            if (changes.groups.created) {
+                for (const group of changes.groups.created) {
+                    this.emitter.emit('group.create', { group });
+                }
+            }
+            if (changes.groups.updated) {
+                for (const { group, previous } of changes.groups.updated) {
+                    this.emitter.emit('group.update', { group, previous });
+                }
+            }
+            if (changes.groups.deleted) {
+                for (const group of changes.groups.deleted) {
+                    this.emitter.emit('group.delete', { group });
+                }
+            }
+        }
+        // Layer reorder event (reordering within a layer)
+        if (changes.layerReorder) {
+            // Emitted as a layer.update event (in order to update the UI)
+            const layer = this.store.getLayer(changes.layerReorder.layerId);
+            if (layer) {
+                this.emitter.emit('layer.update', {
+                    layer,
+                    previous: { ...layer, order: changes.layerReorder.previous },
+                });
+            }
+        }
+        // Group reorder event (reordering within a group)
+        if (changes.groupReorder) {
+            // Emitted as a group.update event (in order to update the UI)
+            const group = this.store.getGroup(changes.groupReorder.groupId);
+            if (group) {
+                this.emitter.emit('group.update', {
+                    group,
+                    previous: { ...group, featureIds: changes.groupReorder.previous },
+                });
+            }
+        }
+        // Selection event
+        if (changes.selection) {
+            this.emitter.emit('selection.change', {
+                type: changes.selection.type,
+                ids: changes.selection.ids,
+                previousType: changes.selection.previousType,
+                previousIds: changes.selection.previousIds,
+            });
+        }
+        // Mode event
+        if (changes.mode) {
+            this.emitter.emit('mode.change', {
+                mode: changes.mode.mode,
+                previousMode: changes.mode.previous,
+            });
+        }
+        // Metadata event
+        if (changes.metadata) {
+            this.emitter.emit('metadata.change', {
+                metadata: changes.metadata.metadata,
+                previous: changes.metadata.previous,
+            });
+        }
+    }
+}

package/dist/store/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Store 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 { FeatureLockStore, InteractionGateStore } from './lock.js';
+export { isFeatureLocked, isGroupLocked, isInteractionBlocked } from './lock.js';
+export { MemoryStore } from './memory.js';
+export type { SpatialQuery } from './spatial/spatial-index.js';
+export type { DocumentStore, Store, StoreView, UiState } from './store.js';
+export type { BoundingBox, BoundingBoxCoordsSimple, BoxSelection, Coordinate, Data, DragOperationType, DragState, ExportFormat, ExportOptions, ExportResult, Feature, FeatureCoordinates, FeatureInput, FeatureStyle, FeatureType, FileData, Group, ImageProperties, ImageStyle, Layer, LoadOptions, LoadResult, Metadata, Mode, RotateInfo, Selection, SelectionType, SkippedFeature, StateChanges, StyleRule, TentativeState, UpdateFeatureOptions, UpdateSource, VertexRef, VertexSelection, } from './types.js';

package/dist/store/index.js

@@ -0,0 +1,4 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export { isFeatureLocked, isGroupLocked, isInteractionBlocked } from './lock.js';
+export { MemoryStore } from './memory.js';

package/dist/store/local-visibility.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Derivation of local visibility
+ *
+ * Resolves the visibility hidden only on this client (the set accumulated by
+ * setLocallyHidden) through a 3-step cascade of the feature (the ids of itself / the
+ * group it belongs to / the layer it belongs to). It is a layer separate from the shared
+ * visible, and rendering, hit testing and box selection respect it.
+ *
+ * A pure function with the same standing as lock.ts (isFeatureLocked). It does not change
+ * the shared data (feature.visible and so on) at all. getOrderedFeatures is kept pure and
+ * this is derived separately here.
+ */
+import type { Feature } from './types.js';
+/** The minimal interface that isLocallyHidden requires. */
+export interface LocalHiddenStore {
+    isLocallyHidden(id: string): boolean;
+}
+/** The minimal interface that getDisplayFeatures requires. */
+export interface DisplayStore extends LocalHiddenStore {
+    getOrderedFeatures(): Feature[];
+}

package/dist/store/local-visibility.js

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Whether the feature is locally hidden on this client (true if itself / the group it
+ * belongs to / the layer it belongs to is in the hidden set).
+ *
+ * @internal
+ */
+export function isLocallyHidden(feature, store) {
+    if (store.isLocallyHidden(feature.id))
+        return true;
+    if (feature.groupId && store.isLocallyHidden(feature.groupId))
+        return true;
+    if (store.isLocallyHidden(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.
+ *
+ * @internal
+ */
+export function getDisplayFeatures(store) {
+    return store.getOrderedFeatures().filter((feature) => !isLocallyHidden(feature, store));
+}