@sakuzu/maplibre-gl-draw 1.0.0

package/dist/store/memory.js

@@ -0,0 +1,708 @@
+// 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 __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 _MemoryDocumentStore_instances, _MemoryDocumentStore_features, _MemoryDocumentStore_layers, _MemoryDocumentStore_groups, _MemoryDocumentStore_layerOrder, _MemoryDocumentStore_metadata, _MemoryDocumentStore_layerOrderIndex, _MemoryDocumentStore_groupFeatureIndex, _MemoryDocumentStore_pendingFeaturePlacement, _MemoryDocumentStore_pendingGroupPlacement, _MemoryDocumentStore_operationDepth, _MemoryDocumentStore_freshLayers, _MemoryDocumentStore_freshGroups, _MemoryDocumentStore_bus, _MemoryDocumentStore_fileStore, _MemoryDocumentStore_createGroup, _MemoryDocumentStore_mutateLayerOrder, _MemoryDocumentStore_mutateGroupFeatureIds, _MemoryDocumentStore_writableLayer, _MemoryDocumentStore_writableGroup, _MemoryDocumentStore_freezeFresh, _MemoryDocumentStore_layerOrderSet, _MemoryDocumentStore_groupFeatureSet, _MemoryDocumentStore_withinOperation, _MemoryDocumentStore_scheduleGroupPlacement, _MemoryDocumentStore_settlePlacements, _MemoryDocumentStore_isListedInAnyLayer, _MemoryDocumentStore_assertLayerExists, _MemoryDocumentStore_addToContainer, _MemoryDocumentStore_removeFromContainer, _MemoryDocumentStore_addItemToLayerOrder, _MemoryDocumentStore_removeItemFromLayerOrder, _MemoryDocumentStore_addFeatureToGroupOrder, _MemoryDocumentStore_removeFeatureFromGroupOrder;
+/**
+ * MemoryStore
+ *
+ * The in-memory Store: a DrawStore over a MemoryDocumentStore.
+ *
+ * MemoryDocumentStore is the in-memory implementation of the DocumentStore contract.
+ * Keeping Feature / Layer / Group consistent (cascading updates on deletion, cascading
+ * updates when groupId changes, etc.) is the responsibility of this file. Transactions and
+ * listeners are delegated to memory/change-bus.ts and File CRUD to memory/file-store.ts.
+ *
+ * What it returns is frozen and never changed afterwards: a feature is stored as a frozen
+ * copy of what it was given, and a layer or a group whose order changes is replaced by a
+ * copy (copied once per notification, so that a bulk import stays linear) and frozen when
+ * the notification goes out.
+ */
+import { DrawStore } from './draw-store.js';
+import { ChangeBus } from './memory/change-bus.js';
+import { FileStore } from './memory/file-store.js';
+import { frozenCopy, frozenFeature } from './memory/frozen.js';
+/** Creates an empty in-memory Store */
+export const MemoryStore = class extends DrawStore {
+    constructor() {
+        super(new MemoryDocumentStore());
+    }
+};
+/**
+ * The in-memory DocumentStore
+ *
+ * @internal
+ */
+export class MemoryDocumentStore {
+    constructor() {
+        _MemoryDocumentStore_instances.add(this);
+        _MemoryDocumentStore_features.set(this, new Map());
+        _MemoryDocumentStore_layers.set(this, new Map());
+        _MemoryDocumentStore_groups.set(this, new Map());
+        _MemoryDocumentStore_layerOrder.set(this, []);
+        _MemoryDocumentStore_metadata.set(this, {});
+        /**
+         * The content set of layer.order (layer ID -> the set of IDs listed in order).
+         *
+         * It is an index whose only purpose is to make membership tests O(1), and it always keeps
+         * the same content as `#layers.get(id).order` (an invariant). Because membership used to be
+         * tested with `layer.order.includes()`, inserting N entries at once into a layer whose order
+         * was already populated cost O(N^2) in total (the main cause of draw.load going quadratic).
+         *
+         * The order arrays the store returns are frozen, so the outside cannot rewrite them behind
+         * this index.
+         */
+        _MemoryDocumentStore_layerOrderIndex.set(this, new Map());
+        /** The content set of group.featureIds. The group version of #layerOrderIndex (same invariant) */
+        _MemoryDocumentStore_groupFeatureIndex.set(this, new Map());
+        /**
+         * Placements settled at the end of the outermost store operation (see #withinOperation).
+         *
+         * When a change of layerId / groupId makes a feature standalone, or a group is created that
+         * no layer lists, the store must list it somewhere so that it stays reachable. Callers
+         * inside a transaction often place the item themselves right after (at a chosen index), so
+         * listing it at once would duplicate it. The store therefore only records the item here
+         * and lists it at the end of the operation when nobody has listed it by then.
+         */
+        _MemoryDocumentStore_pendingFeaturePlacement.set(this, new Set());
+        _MemoryDocumentStore_pendingGroupPlacement.set(this, new Map());
+        _MemoryDocumentStore_operationDepth.set(this, 0);
+        /**
+         * Layers and groups whose stored object was copied during the current notification. Their
+         * order / featureIds may still be changed in place until the notification goes out, when
+         * they are frozen (#freezeFresh).
+         */
+        _MemoryDocumentStore_freshLayers.set(this, new Set());
+        _MemoryDocumentStore_freshGroups.set(this, new Set());
+        _MemoryDocumentStore_bus.set(this, new ChangeBus(() => __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_freezeFresh).call(this)));
+        _MemoryDocumentStore_fileStore.set(this, new FileStore());
+    }
+    // ============================================================================
+    // Feature
+    // ============================================================================
+    getFeature(id) {
+        return __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").get(id);
+    }
+    getAllFeatures() {
+        return Array.from(__classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").values());
+    }
+    createFeature(feature) {
+        if (__classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").has(feature.id)) {
+            throw new Error(`Feature with id "${feature.id}" already exists`);
+        }
+        // A feature must be reachable from exactly one container (its group, or else its layer).
+        // A reference to a container that does not exist would leave it stored but never drawn,
+        // hit or exported in order, so it is rejected before anything is written.
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_assertLayerExists).call(this, feature.layerId);
+        if (feature.groupId && !__classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").has(feature.groupId)) {
+            throw new Error(`Group with id "${feature.groupId}" not found`);
+        }
+        const stored = frozenFeature(undefined, feature);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").set(stored.id, stored);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_addToContainer).call(this, stored);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({ features: { created: [stored] } });
+    }
+    /**
+     * Updates a feature
+     *
+     * options.isIntermediate has no effect on the application of the update (an intermediate
+     * state is applied as usual). Only when it is set is it passed through to
+     * StateChanges.features.updated, so that the receiver can tell an intermediate update from
+     * a final one.
+     *
+     * When layerId or groupId changes the container of the feature (its group, or else its
+     * layer), the feature leaves the order of the old container at once. It joins the group at
+     * the tail at once; it joins the order of its layer at the tail at the end of the
+     * operation, unless the caller has listed it by then. A layerId that does not exist is
+     * rejected. A groupId whose group does not exist yet
+     * is accepted, because replaying recorded changes can set groupId before the group is
+     * created again (createGroup then lists the feature from its featureIds).
+     */
+    updateFeature(id, updates, options) {
+        const previous = __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").get(id);
+        if (!previous) {
+            throw new Error(`Feature with id "${id}" not found`);
+        }
+        if ('layerId' in updates && updates.layerId !== previous.layerId) {
+            __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_assertLayerExists).call(this, updates.layerId);
+        }
+        const updated = frozenFeature(previous, { ...updates, id });
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_withinOperation).call(this, () => {
+            __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").set(id, updated);
+            if (containerKey(previous) !== containerKey(updated)) {
+                __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_removeFromContainer).call(this, previous);
+                if (updated.groupId) {
+                    __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_addFeatureToGroupOrder).call(this, id, updated.groupId);
+                }
+                else {
+                    __classPrivateFieldGet(this, _MemoryDocumentStore_pendingFeaturePlacement, "f").add(id);
+                }
+            }
+        });
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({
+            features: {
+                updated: [
+                    {
+                        id,
+                        feature: updated,
+                        previous,
+                        // Add the key only for an intermediate state (a final update has no such key)
+                        ...(options?.isIntermediate ? { isIntermediate: true } : {}),
+                    },
+                ],
+            },
+        });
+    }
+    deleteFeature(id) {
+        const feature = __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").get(id);
+        if (!feature) {
+            throw new Error(`Feature with id "${id}" not found`);
+        }
+        __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").delete(id);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_removeItemFromLayerOrder).call(this, id, feature.layerId);
+        if (feature.groupId) {
+            __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_removeFeatureFromGroupOrder).call(this, id, feature.groupId);
+        }
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({ features: { deleted: [feature] } });
+    }
+    getOrderedFeatures() {
+        const result = [];
+        for (const layerId of __classPrivateFieldGet(this, _MemoryDocumentStore_layerOrder, "f")) {
+            const layer = __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(layerId);
+            if (!layer?.visible)
+                continue;
+            for (const itemId of layer.order) {
+                const group = __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").get(itemId);
+                if (group) {
+                    if (!group.visible)
+                        continue;
+                    for (const featureId of group.featureIds) {
+                        const feature = __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").get(featureId);
+                        if (feature?.visible)
+                            result.push(feature);
+                    }
+                }
+                else {
+                    const feature = __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").get(itemId);
+                    if (feature?.visible)
+                        result.push(feature);
+                }
+            }
+        }
+        return result;
+    }
+    // ============================================================================
+    // Layer
+    // ============================================================================
+    getLayer(id) {
+        return __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(id);
+    }
+    getAllLayers() {
+        return Array.from(__classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").values());
+    }
+    createLayer(layer) {
+        if (__classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").has(layer.id)) {
+            throw new Error(`Layer with id "${layer.id}" already exists`);
+        }
+        // The order stays open for the members created in the same notification
+        const stored = { ...frozenFields(layer), order: [...layer.order] };
+        __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").set(layer.id, stored);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_freshLayers, "f").add(layer.id);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_layerOrderIndex, "f").set(layer.id, new Set(layer.order));
+        // An id the application already placed on the stacking order keeps its position
+        if (!__classPrivateFieldGet(this, _MemoryDocumentStore_layerOrder, "f").includes(layer.id))
+            __classPrivateFieldGet(this, _MemoryDocumentStore_layerOrder, "f").push(layer.id);
+        // The created entry is the layer as it was created (the stored one may still gain members
+        // in the same notification)
+        const created = Object.freeze({ ...stored, order: Object.freeze([...stored.order]) });
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({ layers: { created: [created] } });
+    }
+    updateLayer(id, updates) {
+        const previous = __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(id);
+        if (!previous) {
+            throw new Error(`Layer with id "${id}" not found`);
+        }
+        const updated = {
+            ...previous,
+            ...frozenFields(updates),
+            id,
+            order: [...(updates.order ?? previous.order)],
+        };
+        if (__classPrivateFieldGet(this, _MemoryDocumentStore_freshLayers, "f").has(id))
+            Object.freeze(Object.freeze(previous).order);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").set(id, updated);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_freshLayers, "f").add(id);
+        // Rebuild the index only when order has been replaced (if it is left as is, it is the same
+        // array as previous.order, so the index also stays valid).
+        if (updates.order)
+            __classPrivateFieldGet(this, _MemoryDocumentStore_layerOrderIndex, "f").set(id, new Set(updated.order));
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({ layers: { updated: [{ id, layer: updated, previous }] } });
+    }
+    deleteLayer(id) {
+        const layer = __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(id);
+        if (!layer) {
+            throw new Error(`Layer with id "${id}" not found`);
+        }
+        // Delete the features and groups in the layer
+        for (const itemId of [...layer.order]) {
+            const group = __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").get(itemId);
+            if (group) {
+                for (const featureId of [...group.featureIds]) {
+                    this.deleteFeature(featureId);
+                }
+                // An empty group is deleted automatically the moment the last feature in the group is
+                // removed, so delete it explicitly only when it still remains.
+                if (__classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").has(itemId)) {
+                    this.deleteGroup(itemId);
+                }
+            }
+            else if (__classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").has(itemId)) {
+                this.deleteFeature(itemId);
+            }
+        }
+        // The last state of the layer (its order has emptied as its members left)
+        const deleted = __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(id) ?? layer;
+        Object.freeze(Object.freeze(deleted).order);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_freshLayers, "f").delete(id);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").delete(id);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_layerOrderIndex, "f").delete(id);
+        const idx = __classPrivateFieldGet(this, _MemoryDocumentStore_layerOrder, "f").indexOf(id);
+        if (idx !== -1)
+            __classPrivateFieldGet(this, _MemoryDocumentStore_layerOrder, "f").splice(idx, 1);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({ layers: { deleted: [deleted] } });
+    }
+    getLayerOrder() {
+        // Returning the internal array as is would let the outside rewrite it and break the SSoT,
+        // so a defensive copy is returned (consistent with getSelection / getMetadata).
+        return [...__classPrivateFieldGet(this, _MemoryDocumentStore_layerOrder, "f")];
+    }
+    /**
+     * Replaces the stacking order (see {@link DocumentStore.setLayerOrder})
+     *
+     * The entries are not only layer IDs: the entries of the application
+     * (datasets, separators) are kept as they are. Only what cannot be an entry is dropped:
+     * a value that is not a non-empty string, and a repeated entry after its first position.
+     *
+     * The membership index within a layer (#layerOrderIndex) is an index over the layer.order of
+     * each layer, which is a different thing from this sequence, so it is not touched.
+     */
+    setLayerOrder(order) {
+        const previous = [...__classPrivateFieldGet(this, _MemoryDocumentStore_layerOrder, "f")];
+        __classPrivateFieldSet(this, _MemoryDocumentStore_layerOrder, [...new Set(order.filter((id) => typeof id === 'string' && id !== ''))], "f");
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({
+            layers: { orderChanged: { order: [...__classPrivateFieldGet(this, _MemoryDocumentStore_layerOrder, "f")], previous } },
+        });
+    }
+    reorderInLayer(itemId, layerId, newIndex) {
+        const current = __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(layerId);
+        if (!current) {
+            throw new Error(`Layer with id "${layerId}" not found`);
+        }
+        const currentIndex = current.order.indexOf(itemId);
+        if (currentIndex === -1) {
+            throw new Error(`Item "${itemId}" not found in layer "${layerId}"`);
+        }
+        const previousOrder = [...current.order];
+        const layer = __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_writableLayer).call(this, current);
+        layer.order.splice(currentIndex, 1);
+        layer.order.splice(newIndex, 0, itemId);
+        // An update of this layer already stacked in the notification carries the new object
+        if (__classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").hasPendingLayerUpdate(layerId))
+            __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").mergeLayerUpdate(layer, undefined);
+        // Emit the dedicated layerReorder (not layers.updated)
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({
+            layerReorder: { layerId, order: [...layer.order], previous: previousOrder },
+        });
+    }
+    reorderInGroup(featureId, groupId, newIndex) {
+        const current = __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").get(groupId);
+        if (!current) {
+            throw new Error(`Group with id "${groupId}" not found`);
+        }
+        const currentIndex = current.featureIds.indexOf(featureId);
+        if (currentIndex === -1) {
+            throw new Error(`Feature "${featureId}" not found in group "${groupId}"`);
+        }
+        const previousFeatureIds = [...current.featureIds];
+        const group = __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_writableGroup).call(this, current);
+        group.featureIds.splice(currentIndex, 1);
+        group.featureIds.splice(newIndex, 0, featureId);
+        if (__classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").hasPendingGroupUpdate(groupId))
+            __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").mergeGroupUpdate(group, undefined);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({
+            groupReorder: { groupId, featureIds: [...group.featureIds], previous: previousFeatureIds },
+        });
+    }
+    // ============================================================================
+    // Group
+    // ============================================================================
+    getGroup(id) {
+        return __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").get(id);
+    }
+    getAllGroups() {
+        return Array.from(__classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").values());
+    }
+    createGroup(group) {
+        if (__classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").has(group.id)) {
+            throw new Error(`Group with id "${group.id}" already exists`);
+        }
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_withinOperation).call(this, () => __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_createGroup).call(this, group));
+    }
+    updateGroup(id, updates) {
+        const previous = __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").get(id);
+        if (!previous) {
+            throw new Error(`Group with id "${id}" not found`);
+        }
+        const updated = {
+            ...previous,
+            ...frozenFields(updates),
+            id,
+            featureIds: [...(updates.featureIds ?? previous.featureIds)],
+        };
+        if (__classPrivateFieldGet(this, _MemoryDocumentStore_freshGroups, "f").has(id))
+            Object.freeze(Object.freeze(previous).featureIds);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").set(id, updated);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_freshGroups, "f").add(id);
+        // Rebuild the index only when featureIds has been replaced (same reason as updateLayer).
+        if (updates.featureIds)
+            __classPrivateFieldGet(this, _MemoryDocumentStore_groupFeatureIndex, "f").set(id, new Set(updated.featureIds));
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({ groups: { updated: [{ id, group: updated, previous }] } });
+    }
+    deleteGroup(id) {
+        const group = __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").get(id);
+        if (!group) {
+            throw new Error(`Group with id "${id}" not found`);
+        }
+        // Delete the group itself first. This prevents #removeFeatureFromGroupOrder from
+        // recursively invoking the automatic deletion of an empty group while the groupId of the
+        // members is cleared (it returns early because the group is already gone).
+        Object.freeze(Object.freeze(group).featureIds);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_freshGroups, "f").delete(id);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").delete(id);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_groupFeatureIndex, "f").delete(id);
+        // Put the members where the group was in the order of its layer, so that they stay
+        // reachable after the group is gone. A member whose layerId names another layer is left
+        // to the cascade of updateFeature below, which appends it to its own layer.
+        for (const layer of [...__classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").values()]) {
+            const index = __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_layerOrderSet).call(this, layer);
+            if (!index.has(id))
+                continue;
+            const idx = layer.order.indexOf(id);
+            if (idx === -1)
+                continue;
+            const members = group.featureIds.filter((fid) => __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").get(fid)?.layerId === layer.id && !index.has(fid));
+            if (members.length === 0)
+                continue;
+            __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_mutateLayerOrder).call(this, layer, (order) => {
+                order.splice(idx, 0, ...members);
+            });
+            for (const fid of members)
+                index.add(fid);
+        }
+        // Remove groupId from the features in the group
+        // updateFeature modifies group.featureIds, so iterate over a copy of the array
+        for (const featureId of [...group.featureIds]) {
+            if (__classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").has(featureId)) {
+                this.updateFeature(featureId, { groupId: undefined });
+            }
+        }
+        // Remove the group ID from the order of every layer (the index skips layers that do not
+        // hold it in O(1))
+        for (const layer of [...__classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").values()]) {
+            const index = __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_layerOrderSet).call(this, layer);
+            if (!index.has(id))
+                continue;
+            const idx = layer.order.indexOf(id);
+            if (idx === -1)
+                continue;
+            __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_mutateLayerOrder).call(this, layer, (order) => {
+                order.splice(idx, 1);
+            });
+            index.delete(id);
+        }
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({ groups: { deleted: [group] } });
+    }
+    // ============================================================================
+    // File (delegated to FileStore)
+    // ============================================================================
+    createFile(file) {
+        __classPrivateFieldGet(this, _MemoryDocumentStore_fileStore, "f").create(file);
+    }
+    getFile(id) {
+        return __classPrivateFieldGet(this, _MemoryDocumentStore_fileStore, "f").get(id);
+    }
+    getAllFiles() {
+        return __classPrivateFieldGet(this, _MemoryDocumentStore_fileStore, "f").getAll();
+    }
+    deleteFile(id) {
+        __classPrivateFieldGet(this, _MemoryDocumentStore_fileStore, "f").delete(id);
+    }
+    // ============================================================================
+    // Metadata
+    // ============================================================================
+    getMetadata() {
+        return { ...__classPrivateFieldGet(this, _MemoryDocumentStore_metadata, "f") };
+    }
+    setMetadata(metadata) {
+        const previous = { ...__classPrivateFieldGet(this, _MemoryDocumentStore_metadata, "f") };
+        __classPrivateFieldSet(this, _MemoryDocumentStore_metadata, { ...__classPrivateFieldGet(this, _MemoryDocumentStore_metadata, "f"), ...frozenFields(metadata) }, "f");
+        // Delete the keys whose value is undefined
+        for (const key of Object.keys(__classPrivateFieldGet(this, _MemoryDocumentStore_metadata, "f"))) {
+            if (__classPrivateFieldGet(this, _MemoryDocumentStore_metadata, "f")[key] === undefined) {
+                delete __classPrivateFieldGet(this, _MemoryDocumentStore_metadata, "f")[key];
+            }
+        }
+        __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({ metadata: { metadata: { ...__classPrivateFieldGet(this, _MemoryDocumentStore_metadata, "f") }, previous } });
+    }
+    // ============================================================================
+    // Subscribe / Transaction (delegated to ChangeBus)
+    // ============================================================================
+    subscribe(listener) {
+        return __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").subscribe(listener);
+    }
+    transact(fn, source = 'local') {
+        return __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").transact(() => __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_withinOperation).call(this, fn), source);
+    }
+}
+_MemoryDocumentStore_features = new WeakMap(), _MemoryDocumentStore_layers = new WeakMap(), _MemoryDocumentStore_groups = new WeakMap(), _MemoryDocumentStore_layerOrder = new WeakMap(), _MemoryDocumentStore_metadata = new WeakMap(), _MemoryDocumentStore_layerOrderIndex = new WeakMap(), _MemoryDocumentStore_groupFeatureIndex = new WeakMap(), _MemoryDocumentStore_pendingFeaturePlacement = new WeakMap(), _MemoryDocumentStore_pendingGroupPlacement = new WeakMap(), _MemoryDocumentStore_operationDepth = new WeakMap(), _MemoryDocumentStore_freshLayers = new WeakMap(), _MemoryDocumentStore_freshGroups = new WeakMap(), _MemoryDocumentStore_bus = new WeakMap(), _MemoryDocumentStore_fileStore = new WeakMap(), _MemoryDocumentStore_instances = new WeakSet(), _MemoryDocumentStore_createGroup = function _MemoryDocumentStore_createGroup(group) {
+    const featureIdsCopy = [...group.featureIds];
+    const stored = { ...frozenFields(group), featureIds: [...featureIdsCopy] };
+    __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").set(group.id, stored);
+    __classPrivateFieldGet(this, _MemoryDocumentStore_freshGroups, "f").add(group.id);
+    __classPrivateFieldGet(this, _MemoryDocumentStore_groupFeatureIndex, "f").set(group.id, new Set(featureIdsCopy));
+    // The members leave the order of their layer below (their container becomes the group),
+    // so a group that no layer lists takes the place of its first member at the end of the
+    // operation. A caller that lists the group itself (at the position it chose) wins.
+    __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_scheduleGroupPlacement).call(this, group.id, featureIdsCopy);
+    // Set groupId on the features in the group
+    for (const featureId of featureIdsCopy) {
+        if (__classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").has(featureId)) {
+            this.updateFeature(featureId, { groupId: group.id });
+        }
+    }
+    __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").merge({
+        groups: {
+            created: [Object.freeze({ ...stored, featureIds: Object.freeze(featureIdsCopy) })],
+        },
+    });
+}, _MemoryDocumentStore_mutateLayerOrder = function _MemoryDocumentStore_mutateLayerOrder(current, mutate) {
+    const hadUpdate = __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").hasPendingLayerUpdate(current.id);
+    const fresh = __classPrivateFieldGet(this, _MemoryDocumentStore_freshLayers, "f").has(current.id);
+    const previous = hadUpdate
+        ? undefined
+        : fresh
+            ? { ...current, order: [...current.order] }
+            : current;
+    const layer = __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_writableLayer).call(this, current);
+    mutate(layer.order);
+    __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").mergeLayerUpdate(layer, previous);
+}, _MemoryDocumentStore_mutateGroupFeatureIds = function _MemoryDocumentStore_mutateGroupFeatureIds(current, mutate) {
+    const hadUpdate = __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").hasPendingGroupUpdate(current.id);
+    const fresh = __classPrivateFieldGet(this, _MemoryDocumentStore_freshGroups, "f").has(current.id);
+    const previous = hadUpdate
+        ? undefined
+        : fresh
+            ? { ...current, featureIds: [...current.featureIds] }
+            : current;
+    const group = __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_writableGroup).call(this, current);
+    mutate(group.featureIds);
+    __classPrivateFieldGet(this, _MemoryDocumentStore_bus, "f").mergeGroupUpdate(group, previous);
+}, _MemoryDocumentStore_writableLayer = function _MemoryDocumentStore_writableLayer(current) {
+    if (__classPrivateFieldGet(this, _MemoryDocumentStore_freshLayers, "f").has(current.id))
+        return current;
+    const layer = { ...current, order: [...current.order] };
+    __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").set(layer.id, layer);
+    __classPrivateFieldGet(this, _MemoryDocumentStore_freshLayers, "f").add(layer.id);
+    return layer;
+}, _MemoryDocumentStore_writableGroup = function _MemoryDocumentStore_writableGroup(current) {
+    if (__classPrivateFieldGet(this, _MemoryDocumentStore_freshGroups, "f").has(current.id))
+        return current;
+    const group = { ...current, featureIds: [...current.featureIds] };
+    __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").set(group.id, group);
+    __classPrivateFieldGet(this, _MemoryDocumentStore_freshGroups, "f").add(group.id);
+    return group;
+}, _MemoryDocumentStore_freezeFresh = function _MemoryDocumentStore_freezeFresh() {
+    for (const id of __classPrivateFieldGet(this, _MemoryDocumentStore_freshLayers, "f")) {
+        const layer = __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(id);
+        if (layer)
+            Object.freeze(Object.freeze(layer).order);
+    }
+    __classPrivateFieldGet(this, _MemoryDocumentStore_freshLayers, "f").clear();
+    for (const id of __classPrivateFieldGet(this, _MemoryDocumentStore_freshGroups, "f")) {
+        const group = __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").get(id);
+        if (group)
+            Object.freeze(Object.freeze(group).featureIds);
+    }
+    __classPrivateFieldGet(this, _MemoryDocumentStore_freshGroups, "f").clear();
+}, _MemoryDocumentStore_layerOrderSet = function _MemoryDocumentStore_layerOrderSet(layer) {
+    let index = __classPrivateFieldGet(this, _MemoryDocumentStore_layerOrderIndex, "f").get(layer.id);
+    if (!index) {
+        index = new Set(layer.order);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_layerOrderIndex, "f").set(layer.id, index);
+    }
+    return index;
+}, _MemoryDocumentStore_groupFeatureSet = function _MemoryDocumentStore_groupFeatureSet(group) {
+    let index = __classPrivateFieldGet(this, _MemoryDocumentStore_groupFeatureIndex, "f").get(group.id);
+    if (!index) {
+        index = new Set(group.featureIds);
+        __classPrivateFieldGet(this, _MemoryDocumentStore_groupFeatureIndex, "f").set(group.id, index);
+    }
+    return index;
+}, _MemoryDocumentStore_withinOperation = function _MemoryDocumentStore_withinOperation(fn) {
+    var _a, _b;
+    __classPrivateFieldSet(this, _MemoryDocumentStore_operationDepth, (_a = __classPrivateFieldGet(this, _MemoryDocumentStore_operationDepth, "f"), _a++, _a), "f");
+    try {
+        return fn();
+    }
+    finally {
+        __classPrivateFieldSet(this, _MemoryDocumentStore_operationDepth, (_b = __classPrivateFieldGet(this, _MemoryDocumentStore_operationDepth, "f"), _b--, _b), "f");
+        if (__classPrivateFieldGet(this, _MemoryDocumentStore_operationDepth, "f") === 0)
+            __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_settlePlacements).call(this);
+    }
+}, _MemoryDocumentStore_scheduleGroupPlacement = function _MemoryDocumentStore_scheduleGroupPlacement(groupId, featureIds) {
+    const first = featureIds
+        .map((fid) => __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").get(fid))
+        .find((f) => f !== undefined);
+    const layer = first && __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(first.layerId);
+    if (!first || !layer)
+        return;
+    const idx = layer.order.indexOf(first.id);
+    __classPrivateFieldGet(this, _MemoryDocumentStore_pendingGroupPlacement, "f").set(groupId, {
+        layerId: layer.id,
+        index: idx === -1 ? layer.order.length : idx,
+    });
+}, _MemoryDocumentStore_settlePlacements = function _MemoryDocumentStore_settlePlacements() {
+    if (__classPrivateFieldGet(this, _MemoryDocumentStore_pendingGroupPlacement, "f").size === 0 && __classPrivateFieldGet(this, _MemoryDocumentStore_pendingFeaturePlacement, "f").size === 0) {
+        return;
+    }
+    const groups = [...__classPrivateFieldGet(this, _MemoryDocumentStore_pendingGroupPlacement, "f")];
+    const features = [...__classPrivateFieldGet(this, _MemoryDocumentStore_pendingFeaturePlacement, "f")];
+    __classPrivateFieldGet(this, _MemoryDocumentStore_pendingGroupPlacement, "f").clear();
+    __classPrivateFieldGet(this, _MemoryDocumentStore_pendingFeaturePlacement, "f").clear();
+    for (const [groupId, { layerId, index }] of groups) {
+        if (!__classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").has(groupId) || __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_isListedInAnyLayer).call(this, groupId))
+            continue;
+        const layer = __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(layerId);
+        if (!layer)
+            continue;
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_mutateLayerOrder).call(this, layer, (order) => {
+            order.splice(Math.min(index, order.length), 0, groupId);
+        });
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_layerOrderSet).call(this, layer).add(groupId);
+    }
+    for (const id of features) {
+        const feature = __classPrivateFieldGet(this, _MemoryDocumentStore_features, "f").get(id);
+        if (!feature || feature.groupId)
+            continue;
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_addItemToLayerOrder).call(this, id, feature.layerId);
+    }
+}, _MemoryDocumentStore_isListedInAnyLayer = function _MemoryDocumentStore_isListedInAnyLayer(itemId) {
+    for (const layer of __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").values()) {
+        if (__classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_layerOrderSet).call(this, layer).has(itemId))
+            return true;
+    }
+    return false;
+}, _MemoryDocumentStore_assertLayerExists = function _MemoryDocumentStore_assertLayerExists(layerId) {
+    if (layerId === undefined || !__classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").has(layerId)) {
+        throw new Error(`Layer with id "${layerId}" not found`);
+    }
+}, _MemoryDocumentStore_addToContainer = function _MemoryDocumentStore_addToContainer(feature) {
+    if (feature.groupId) {
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_addFeatureToGroupOrder).call(this, feature.id, feature.groupId);
+    }
+    else {
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_addItemToLayerOrder).call(this, feature.id, feature.layerId);
+    }
+}, _MemoryDocumentStore_removeFromContainer = function _MemoryDocumentStore_removeFromContainer(feature) {
+    if (feature.groupId) {
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_removeFeatureFromGroupOrder).call(this, feature.id, feature.groupId);
+    }
+    else {
+        __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_removeItemFromLayerOrder).call(this, feature.id, feature.layerId);
+    }
+}, _MemoryDocumentStore_addItemToLayerOrder = function _MemoryDocumentStore_addItemToLayerOrder(itemId, layerId) {
+    const layer = __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(layerId);
+    if (!layer)
+        return;
+    const index = __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_layerOrderSet).call(this, layer);
+    if (index.has(itemId))
+        return;
+    __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_mutateLayerOrder).call(this, layer, (order) => {
+        order.push(itemId);
+    });
+    index.add(itemId);
+}, _MemoryDocumentStore_removeItemFromLayerOrder = function _MemoryDocumentStore_removeItemFromLayerOrder(itemId, layerId) {
+    const layer = __classPrivateFieldGet(this, _MemoryDocumentStore_layers, "f").get(layerId);
+    if (!layer)
+        return;
+    // Most IDs, such as features belonging to a group, are not listed in order, so they are
+    // rejected by the index before the traversal (indexOf itself is needed to locate the
+    // splice position).
+    const index = __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_layerOrderSet).call(this, layer);
+    if (!index.has(itemId))
+        return;
+    const idx = layer.order.indexOf(itemId);
+    if (idx === -1)
+        return;
+    __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_mutateLayerOrder).call(this, layer, (order) => {
+        order.splice(idx, 1);
+    });
+    index.delete(itemId);
+}, _MemoryDocumentStore_addFeatureToGroupOrder = function _MemoryDocumentStore_addFeatureToGroupOrder(featureId, groupId) {
+    const group = __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").get(groupId);
+    if (!group)
+        return;
+    const index = __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_groupFeatureSet).call(this, group);
+    if (index.has(featureId))
+        return;
+    __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_mutateGroupFeatureIds).call(this, group, (featureIds) => {
+        featureIds.push(featureId);
+    });
+    index.add(featureId);
+}, _MemoryDocumentStore_removeFeatureFromGroupOrder = function _MemoryDocumentStore_removeFeatureFromGroupOrder(featureId, groupId) {
+    const group = __classPrivateFieldGet(this, _MemoryDocumentStore_groups, "f").get(groupId);
+    if (!group)
+        return;
+    const index = __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_groupFeatureSet).call(this, group);
+    if (!index.has(featureId))
+        return;
+    const idx = group.featureIds.indexOf(featureId);
+    if (idx === -1)
+        return;
+    __classPrivateFieldGet(this, _MemoryDocumentStore_instances, "m", _MemoryDocumentStore_mutateGroupFeatureIds).call(this, group, (featureIds) => {
+        featureIds.splice(idx, 1);
+    });
+    index.delete(featureId);
+    // A group that has become empty is deleted automatically (the standard behavior of
+    // canvas-style tools). A group is a container of elements, and an empty group only
+    // clutters the layer tree.
+    if (index.size === 0) {
+        this.deleteGroup(groupId);
+    }
+};
+/**
+ * Identifies the container that lists a feature: its group when it has one, otherwise its
+ * layer. A feature is listed in exactly this container.
+ */
+function containerKey(feature) {
+    return feature.groupId ? `group:${feature.groupId}` : `layer:${feature.layerId}`;
+}
+/**
+ * A shallow copy whose object and array fields are frozen copies (the fields of a layer,
+ * a group or the metadata other than the order they keep)
+ */
+function frozenFields(value) {
+    const copy = { ...value };
+    for (const key of Object.keys(copy))
+        copy[key] = frozenCopy(copy[key]);
+    return copy;
+}