@sakuzu/maplibre-gl-draw 1.0.0

package/dist/store/spatial/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Spatial module
+ */
+export type { SpatialIndex } from './spatial-index.js';
+export { getBoundingBox, RBushSpatialIndex } from './spatial-index.js';
+export { StoreSpatialIndex } from './store-spatial-index.js';

package/dist/store/spatial/index.js

@@ -0,0 +1,4 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export { getBoundingBox, RBushSpatialIndex } from './spatial-index.js';
+export { StoreSpatialIndex } from './store-spatial-index.js';

package/dist/store/spatial/spatial-index.d.ts

@@ -0,0 +1,90 @@
+import type { BoundingBox, Coordinate, Feature } from '../types.js';
+export { getBoundingBox } from '../../shared/utils/feature-bbox.js';
+/**
+ * The type of a custom bounding box calculation function
+ */
+export type CustomBoundingBoxCalculator = (feature: Feature, tileSize: number) => BoundingBox;
+/**
+ * The queries of a spatial index (what the hit testing, the snapping, the rendering and the
+ * modes read)
+ */
+export interface SpatialQuery {
+    /**
+     * Gets the IDs of the features near the given coordinate
+     *
+     * @param coordinate the coordinate to search at [lng, lat]
+     * @param tolerance the tolerance (in degrees)
+     */
+    findNear(coordinate: Coordinate, tolerance: number): string[];
+    /**
+     * Gets the IDs of the features inside the given bounding box
+     */
+    findInBounds(bounds: BoundingBox): string[];
+}
+/**
+ * The SpatialIndex interface
+ *
+ * The queries and the configuration of the extent calculation. It has no writes: the index
+ * a draw instance holds is derived from the Store (StoreSpatialIndex), so a feature enters
+ * and leaves it only through the Store. The writes belong to the implementation
+ * (RBushSpatialIndex).
+ */
+export interface SpatialIndex extends SpatialQuery {
+    /**
+     * Sets the tile size (used for computing the size of an Image)
+     */
+    setTileSize?(tileSize: number): void;
+    /**
+     * Registers a custom bounding box calculation function
+     *
+     * This is to support the custom feature types of an extension (registerFeatureHandler).
+     * @param type the feature type
+     * @param calculator the bounding box calculation function
+     * @returns a function that cancels the registration (it does not remove a later
+     *   registration of the same type)
+     */
+    setCustomBoundingBoxCalculator?(type: string, calculator: CustomBoundingBoxCalculator): () => void;
+}
+/**
+ * The rbush-based SpatialIndex implementation
+ */
+export declare class RBushSpatialIndex implements SpatialIndex {
+    private tree;
+    private items;
+    private tileSize;
+    private customCalculators;
+    /**
+     * Sets the tile size
+     *
+     * The tile size can differ depending on the MapLibre style, so setting an appropriate
+     * value improves the accuracy of the size computation for an Image
+     */
+    setTileSize(tileSize: number): void;
+    /**
+     * Registers a custom bounding box calculation function
+     */
+    setCustomBoundingBoxCalculator(type: string, calculator: CustomBoundingBoxCalculator): () => void;
+    /** Adds a feature to the index */
+    insert(feature: Feature): void;
+    /**
+     * Indexes several features at once (a bulk load of rbush, much faster than inserting one
+     * by one). A feature that is already indexed is replaced.
+     */
+    load(features: readonly Feature[]): void;
+    /** Whether the feature with this id is indexed */
+    has(id: string): boolean;
+    /**
+     * Computes the bounding box of a feature
+     *
+     * If a custom calculation function is registered, it is used.
+     */
+    private computeBoundingBoxForFeature;
+    /** Updates the entry of a feature */
+    update(id: string, feature: Feature): void;
+    /** Removes a feature from the index */
+    remove(id: string): void;
+    /** Clears the index */
+    clear(): void;
+    findNear(coordinate: Coordinate, tolerance: number): string[];
+    findInBounds(bounds: BoundingBox): string[];
+}

package/dist/store/spatial/spatial-index.js

@@ -0,0 +1,148 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * SpatialIndex
+ *
+ * A spatial index that uses rbush.
+ * It provides fast spatial queries over features.
+ */
+import RBush from 'rbush';
+import { getBoundingBox } from '../../shared/utils/feature-bbox.js';
+// The bounding box of a feature is a pure function of the feature, so it is defined in
+// shared/ (display/ uses it too); re-exported here for the existing imports
+export { getBoundingBox } from '../../shared/utils/feature-bbox.js';
+/**
+ * The rbush-based SpatialIndex implementation
+ */
+export class RBushSpatialIndex {
+    constructor() {
+        Object.defineProperty(this, "tree", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new RBush()
+        });
+        Object.defineProperty(this, "items", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "tileSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 512
+        }); // the MapLibre default
+        Object.defineProperty(this, "customCalculators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * Sets the tile size
+     *
+     * The tile size can differ depending on the MapLibre style, so setting an appropriate
+     * value improves the accuracy of the size computation for an Image
+     */
+    setTileSize(tileSize) {
+        this.tileSize = tileSize;
+    }
+    /**
+     * Registers a custom bounding box calculation function
+     */
+    setCustomBoundingBoxCalculator(type, calculator) {
+        this.customCalculators.set(type, calculator);
+        return () => {
+            if (this.customCalculators.get(type) === calculator)
+                this.customCalculators.delete(type);
+        };
+    }
+    /** Adds a feature to the index */
+    insert(feature) {
+        // An id is held at most once, so inserting a feature that is already indexed replaces it
+        this.update(feature.id, feature);
+    }
+    /**
+     * Indexes several features at once (a bulk load of rbush, much faster than inserting one
+     * by one). A feature that is already indexed is replaced.
+     */
+    load(features) {
+        const items = [];
+        for (const feature of features) {
+            this.remove(feature.id);
+            const item = {
+                ...this.computeBoundingBoxForFeature(feature),
+                featureId: feature.id,
+            };
+            this.items.set(feature.id, item);
+            items.push(item);
+        }
+        this.tree.load(items);
+    }
+    /** Whether the feature with this id is indexed */
+    has(id) {
+        return this.items.has(id);
+    }
+    /**
+     * Computes the bounding box of a feature
+     *
+     * If a custom calculation function is registered, it is used.
+     */
+    computeBoundingBoxForFeature(feature) {
+        // Use the custom calculation function if there is one
+        const customCalc = this.customCalculators.get(feature.type);
+        if (customCalc) {
+            return customCalc(feature, this.tileSize);
+        }
+        // The default computation
+        return getBoundingBox(feature, this.tileSize);
+    }
+    /** Updates the entry of a feature */
+    update(id, feature) {
+        // Remove the existing item
+        this.remove(id);
+        // Compute the new bounding box and insert it
+        const bbox = this.computeBoundingBoxForFeature(feature);
+        const item = {
+            ...bbox,
+            featureId: feature.id,
+        };
+        this.items.set(feature.id, item);
+        this.tree.insert(item);
+    }
+    /** Removes a feature from the index */
+    remove(id) {
+        const item = this.items.get(id);
+        if (item) {
+            this.tree.remove(item);
+            this.items.delete(id);
+        }
+    }
+    /** Clears the index */
+    clear() {
+        this.tree.clear();
+        this.items.clear();
+    }
+    findNear(coordinate, tolerance) {
+        const [lng, lat] = coordinate;
+        const bounds = {
+            minX: lng - tolerance,
+            minY: lat - tolerance,
+            maxX: lng + tolerance,
+            maxY: lat + tolerance,
+        };
+        return this.findInBounds(bounds);
+    }
+    findInBounds(bounds) {
+        const results = this.tree.search({
+            minX: bounds.minX,
+            minY: bounds.minY,
+            maxX: bounds.maxX,
+            maxY: bounds.maxY,
+        });
+        return results.map((item) => item.featureId);
+    }
+}

package/dist/store/spatial/store-spatial-index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * StoreSpatialIndex
+ *
+ * The spatial index as a value derived from the Store. It subscribes to the Store and
+ * re-derives the entry of every feature a StateChanges names (created / updated / deleted)
+ * from the Store itself, so it holds exactly the features the Store holds, with the extent
+ * they have now:
+ *
+ * - every write path (the public API, the drawing modes, the drag, import, plugins, a mode
+ *   of an extension, a change applied from elsewhere to a replaced Store) reaches it in the same way
+ * - a write the Store refuses (read-only) notifies nothing, so it leaves no trace here
+ * - an update of the properties (the radius of a Circle, the scale and rotation of an Image)
+ *   re-indexes the feature like an update of the coordinates
+ * - the intermediate updates of a drag are Store updates too (isIntermediate), so the shape
+ *   being dragged is the shape that is indexed
+ *
+ * The extent of a type registered with a custom bounding box calculator can change for
+ * reasons outside the Store (a font that arrives later, for example). Its owner announces
+ * that with invalidateType(), which re-derives the features of that type from the Store.
+ */
+import type { Store } from '../store.js';
+import type { BoundingBox, Coordinate } from '../types.js';
+import { type CustomBoundingBoxCalculator, type SpatialIndex } from './spatial-index.js';
+/**
+ * The spatial index derived from a Store
+ */
+export declare class StoreSpatialIndex implements SpatialIndex {
+    #private;
+    constructor(store: Store);
+    findNear(coordinate: Coordinate, tolerance: number): string[];
+    findInBounds(bounds: BoundingBox): string[];
+    /**
+     * Sets the tile size used to size an Image, and re-derives every feature (a custom
+     * calculator also receives the tile size)
+     */
+    setTileSize(tileSize: number): void;
+    /**
+     * Registers the bounding box calculation of a custom feature type, and re-derives the
+     * features of that type the Store already holds
+     *
+     * @returns a function that cancels the registration and measures those features again
+     *   with the default calculation
+     */
+    setCustomBoundingBoxCalculator(type: string, calculator: CustomBoundingBoxCalculator): () => void;
+    /**
+     * Re-derives the extent of every feature of the given type from the Store
+     *
+     * For a type whose extent changed for a reason the Store does not see.
+     */
+    invalidateType(type: string): void;
+    /**
+     * Re-derives the entries of the given features from the Store (an id the Store does not
+     * hold is dropped)
+     */
+    invalidate(ids: Iterable<string>): void;
+    /**
+     * Stops following the Store and empties the index
+     */
+    destroy(): void;
+}

package/dist/store/spatial/store-spatial-index.js

@@ -0,0 +1,125 @@
+// 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 _StoreSpatialIndex_instances, _StoreSpatialIndex_store, _StoreSpatialIndex_index, _StoreSpatialIndex_unsubscribe, _StoreSpatialIndex_apply, _StoreSpatialIndex_refresh, _StoreSpatialIndex_rebuild;
+import { RBushSpatialIndex, } from './spatial-index.js';
+/**
+ * The spatial index derived from a Store
+ */
+export class StoreSpatialIndex {
+    constructor(store) {
+        _StoreSpatialIndex_instances.add(this);
+        _StoreSpatialIndex_store.set(this, void 0);
+        _StoreSpatialIndex_index.set(this, new RBushSpatialIndex());
+        _StoreSpatialIndex_unsubscribe.set(this, void 0);
+        __classPrivateFieldSet(this, _StoreSpatialIndex_store, store, "f");
+        __classPrivateFieldSet(this, _StoreSpatialIndex_unsubscribe, store.subscribe((changes) => __classPrivateFieldGet(this, _StoreSpatialIndex_instances, "m", _StoreSpatialIndex_apply).call(this, changes)), "f");
+        // A Store handed in from outside can already hold features
+        __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").load(store.getAllFeatures());
+    }
+    findNear(coordinate, tolerance) {
+        return __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").findNear(coordinate, tolerance);
+    }
+    findInBounds(bounds) {
+        return __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").findInBounds(bounds);
+    }
+    /**
+     * Sets the tile size used to size an Image, and re-derives every feature (a custom
+     * calculator also receives the tile size)
+     */
+    setTileSize(tileSize) {
+        __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").setTileSize(tileSize);
+        __classPrivateFieldGet(this, _StoreSpatialIndex_instances, "m", _StoreSpatialIndex_rebuild).call(this);
+    }
+    /**
+     * Registers the bounding box calculation of a custom feature type, and re-derives the
+     * features of that type the Store already holds
+     *
+     * @returns a function that cancels the registration and measures those features again
+     *   with the default calculation
+     */
+    setCustomBoundingBoxCalculator(type, calculator) {
+        const cancel = __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").setCustomBoundingBoxCalculator(type, calculator);
+        this.invalidateType(type);
+        return () => {
+            cancel();
+            this.invalidateType(type);
+        };
+    }
+    /**
+     * Re-derives the extent of every feature of the given type from the Store
+     *
+     * For a type whose extent changed for a reason the Store does not see.
+     */
+    invalidateType(type) {
+        for (const feature of __classPrivateFieldGet(this, _StoreSpatialIndex_store, "f").getAllFeatures()) {
+            if (feature.type === type) {
+                __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").update(feature.id, feature);
+            }
+        }
+    }
+    /**
+     * Re-derives the entries of the given features from the Store (an id the Store does not
+     * hold is dropped)
+     */
+    invalidate(ids) {
+        for (const id of ids) {
+            __classPrivateFieldGet(this, _StoreSpatialIndex_instances, "m", _StoreSpatialIndex_refresh).call(this, id);
+        }
+    }
+    /**
+     * Stops following the Store and empties the index
+     */
+    destroy() {
+        __classPrivateFieldGet(this, _StoreSpatialIndex_unsubscribe, "f")?.call(this);
+        __classPrivateFieldSet(this, _StoreSpatialIndex_unsubscribe, null, "f");
+        __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").clear();
+    }
+}
+_StoreSpatialIndex_store = new WeakMap(), _StoreSpatialIndex_index = new WeakMap(), _StoreSpatialIndex_unsubscribe = new WeakMap(), _StoreSpatialIndex_instances = new WeakSet(), _StoreSpatialIndex_apply = function _StoreSpatialIndex_apply(changes) {
+    const features = changes.features;
+    if (!features)
+        return;
+    // A bulk creation (import) is loaded in one pass
+    const created = features.created;
+    if (created && created.length > 0) {
+        const present = [];
+        for (const { id } of created) {
+            const feature = __classPrivateFieldGet(this, _StoreSpatialIndex_store, "f").getFeature(id);
+            if (feature)
+                present.push(feature);
+        }
+        __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").load(present);
+    }
+    // The final state is read from the Store, so the order of the entries within one
+    // notification (created then deleted, updated several times) does not matter
+    if (features.updated) {
+        for (const { id } of features.updated)
+            __classPrivateFieldGet(this, _StoreSpatialIndex_instances, "m", _StoreSpatialIndex_refresh).call(this, id);
+    }
+    if (features.deleted) {
+        for (const { id } of features.deleted)
+            __classPrivateFieldGet(this, _StoreSpatialIndex_instances, "m", _StoreSpatialIndex_refresh).call(this, id);
+    }
+}, _StoreSpatialIndex_refresh = function _StoreSpatialIndex_refresh(id) {
+    const feature = __classPrivateFieldGet(this, _StoreSpatialIndex_store, "f").getFeature(id);
+    if (feature) {
+        __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").update(id, feature);
+    }
+    else {
+        __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").remove(id);
+    }
+}, _StoreSpatialIndex_rebuild = function _StoreSpatialIndex_rebuild() {
+    __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").clear();
+    __classPrivateFieldGet(this, _StoreSpatialIndex_index, "f").load(__classPrivateFieldGet(this, _StoreSpatialIndex_store, "f").getAllFeatures());
+};