@sakuzu/maplibre-gl-draw 1.0.0

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

@@ -0,0 +1,223 @@
+// 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 _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 {
+    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');
+        // Read-only (forbids local writes to the document). Local state, not part of the document.
+        _MemoryUiState_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);
+        // 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");
+    }
+    // Selection
+    getSelection() {
+        return { type: __classPrivateFieldGet(this, _MemoryUiState_selection, "f").type, ids: [...__classPrivateFieldGet(this, _MemoryUiState_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({
+            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")];
+    }
+    startEditing(ids) {
+        const newIds = ids.filter((id) => !__classPrivateFieldGet(this, _MemoryUiState_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 } });
+    }
+    endEditing(ids) {
+        const endedIds = ids.filter((id) => __classPrivateFieldGet(this, _MemoryUiState_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 } });
+    }
+    /** Removal from editing that accompanies a feature deletion (internal use) */
+    removeFromEditing(featureId) {
+        const idx = __classPrivateFieldGet(this, _MemoryUiState_editingIds, "f").indexOf(featureId);
+        if (idx === -1)
+            return;
+        __classPrivateFieldGet(this, _MemoryUiState_editingIds, "f").splice(idx, 1);
+        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ editing: { ended: [featureId] } });
+    }
+    // Tentative
+    getTentative() {
+        return __classPrivateFieldGet(this, _MemoryUiState_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 } });
+    }
+    // BoxSelection
+    getBoxSelection() {
+        return __classPrivateFieldGet(this, _MemoryUiState_boxSelection, "f");
+    }
+    setBoxSelection(box) {
+        __classPrivateFieldSet(this, _MemoryUiState_boxSelection, box
+            ? {
+                startPoint: [...box.startPoint],
+                endPoint: [...box.endPoint],
+                previousSelection: [...box.previousSelection],
+            }
+            : null, "f");
+        __classPrivateFieldGet(this, _MemoryUiState_bus, "f").merge({ uiStateChanged: true });
+    }
+    // DragState
+    getDragState() {
+        return __classPrivateFieldGet(this, _MemoryUiState_dragState, "f");
+    }
+    setDragState(state) {
+        __classPrivateFieldSet(this, _MemoryUiState_dragState, state
+            ? {
+                operation: state.operation,
+                activeVertex: state.activeVertex ? { ...state.activeVertex } : undefined,
+                activeFeatureId: state.activeFeatureId,
+                rotateInfo: state.rotateInfo,
+                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 });
+    }
+    // FollowedVertices (vertices that follow along when shared vertices move together. Set only
+    // during a drag)
+    getFollowedVertices() {
+        return __classPrivateFieldGet(this, _MemoryUiState_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)) {
+            return;
+        }
+        __classPrivateFieldSet(this, _MemoryUiState_followedVertices, selections && selections.length > 0
+            ? selections.map((selection) => ({
+                featureId: selection.featureId,
+                vertexIndices: selection.vertexIndices.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 });
+        }
+    }
+}
+_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();

package/dist/store/memory.d.ts

@@ -0,0 +1,26 @@
+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.
+ *
+ * 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 {
+}
+/** Creates an empty in-memory Store */
+export declare const MemoryStore: {
+    new (): MemoryStore;
+    readonly prototype: MemoryStore;
+};