@sakuzu/maplibre-gl-draw 1.0.0

package/dist/snapping/providers/display.js

@@ -0,0 +1,268 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { segmentIntersection } from '../../geometry/split.js';
+import { MESSAGES_EN } from '../../messages.js';
+import { RBushSpatialIndex } from '../../store/spatial/spatial-index.js';
+import { computeVertexHandles } from '../../view/ui/handles.js';
+import { collectFeatureSegments, hasSnapEdges, isExcludedVertex, queryFeatures, segmentIntersectsBBox, } from './shared.js';
+/**
+ * Whether the feature type is a target of vertex snapping
+ *
+ * It targets the point types in addition to the types that have edges. Types that do
+ * not originate from GeoJSON, such as Circle and Image, are out of scope.
+ */
+function hasSnapVertices(type) {
+    return hasSnapEdges(type) || type === 'Point' || type === 'MultiPoint';
+}
+/**
+ * Builds the snapping providers for datasets
+ */
+export function createDisplaySnapProviders(deps) {
+    const cache = new Map();
+    // The description of an intersection candidate (read by the status bar and the like)
+    const intersectionDescription = deps.messages?.snapIntersection ?? MESSAGES_EN.snapIntersection;
+    /**
+     * Gets the cache entry of a dataset (building it when there is none)
+     */
+    function entryOf(dataset) {
+        const cached = cache.get(dataset.id);
+        if (cached && cached.dataset === dataset)
+            return cached;
+        cached?.unsubscribe();
+        const entry = { dataset, built: null, unsubscribe: () => { } };
+        entry.unsubscribe = dataset.on('change', (payload) => {
+            // It is not rebuilt on a change of visibility or of style
+            if (payload.reason === 'features')
+                entry.built = null;
+        });
+        cache.set(dataset.id, entry);
+        return entry;
+    }
+    /**
+     * Gets the index (rebuilding it when it was discarded)
+     */
+    function indexOf(entry) {
+        if (entry.built)
+            return entry.built;
+        const index = new RBushSpatialIndex();
+        const byId = new Map();
+        for (const feature of entry.dataset.getFeatures()) {
+            index.insert(feature);
+            byId.set(feature.id, feature);
+        }
+        entry.built = { index, byId };
+        return entry.built;
+    }
+    /**
+     * Discards the cache of the datasets that were removed
+     */
+    function prune(alive) {
+        for (const [id, entry] of cache) {
+            if (alive.has(id))
+                continue;
+            entry.unsubscribe();
+            cache.delete(id);
+        }
+    }
+    /**
+     * Lists the snapping target features near the bbox
+     *
+     * ctx.excludeFeatureId / excludeVertex are not looked at. Both exist to keep a
+     * feature being edited in the Store from snapping to itself, and they have nothing
+     * to do with the features of datasets, which are never dragged.
+     */
+    function nearbyFeatures(bbox) {
+        const datasets = deps.datasets.list();
+        prune(new Set(datasets.map((dataset) => dataset.id)));
+        const lng = (bbox.minX + bbox.maxX) / 2;
+        const lat = (bbox.minY + bbox.maxY) / 2;
+        // findNear queries a square extent, so the larger of the tolerances is used
+        const tolerance = Math.max(bbox.maxX - lng, bbox.maxY - lat);
+        const result = [];
+        for (const dataset of datasets) {
+            if (!dataset.visible)
+                continue;
+            // A feature that was not drawn because of collision thinning is not a snapping
+            // target either (a vertex being pulled towards a point that is not visible is a
+            // source of confusion, just as it is in hit testing)
+            const drawable = dataset.getVisibleFeatureIds();
+            const { index, byId } = indexOf(entryOf(dataset));
+            const seen = new Set();
+            for (const id of index.findNear([lng, lat], tolerance)) {
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                const feature = byId.get(id);
+                if (!feature)
+                    continue;
+                if (feature.visible === false)
+                    continue;
+                if (drawable !== null && !drawable.has(feature.id))
+                    continue;
+                result.push({ datasetId: dataset.id, feature });
+            }
+        }
+        return result;
+    }
+    /**
+     * Gathers the edges of the datasets that fall within the bbox
+     */
+    function collectDisplaySegments(bbox) {
+        const groups = [];
+        for (const { datasetId, feature } of nearbyFeatures(bbox)) {
+            if (!hasSnapEdges(feature.type))
+                continue;
+            const segments = [];
+            collectFeatureSegments(feature, (start, end) => {
+                if (!segmentIntersectsBBox(start, end, bbox))
+                    return;
+                segments.push({ start, end });
+            });
+            if (segments.length > 0)
+                groups.push({ datasetId, featureId: feature.id, segments });
+        }
+        return groups;
+    }
+    /**
+     * Gathers the edges of the Store that fall within the bbox (the counterpart of an
+     * intersection)
+     */
+    function collectStoreSegments(bbox, ctx) {
+        const groups = [];
+        for (const feature of queryFeatures({ store: deps.store, spatialIndex: deps.spatialIndex, snapTargets: deps.snapTargets }, bbox, ctx)) {
+            // The candidates of a custom type are returned by the vertex provider
+            // (getSnapTargets)
+            if (deps.snapTargets?.get(feature.type))
+                continue;
+            if (!hasSnapEdges(feature.type))
+                continue;
+            const segments = [];
+            collectFeatureSegments(feature, (start, end, startRef, endRef) => {
+                if (!segmentIntersectsBBox(start, end, bbox))
+                    return;
+                if (isExcludedVertex(feature.id, startRef, ctx))
+                    return;
+                if (isExcludedVertex(feature.id, endRef, ctx))
+                    return;
+                segments.push({ start, end });
+            });
+            if (segments.length > 0)
+                groups.push({ featureId: feature.id, segments });
+        }
+        return groups;
+    }
+    const vertexProvider = {
+        name: 'core:display-vertex',
+        candidates(bbox) {
+            if (!deps.isEnabled())
+                return [];
+            const candidates = [];
+            for (const { datasetId, feature } of nearbyFeatures(bbox)) {
+                if (!hasSnapVertices(feature.type))
+                    continue;
+                for (const handle of computeVertexHandles(feature)) {
+                    const candidate = {
+                        kind: 'vertex',
+                        coordinate: handle.position,
+                        featureId: feature.id,
+                        datasetId,
+                        vertex: handle.vertexRef,
+                    };
+                    candidates.push(candidate);
+                }
+            }
+            return candidates;
+        },
+    };
+    const edgeProvider = {
+        name: 'core:display-edge',
+        candidates(bbox) {
+            if (!deps.isEnabled())
+                return [];
+            const candidates = [];
+            for (const { datasetId, feature } of nearbyFeatures(bbox)) {
+                if (!hasSnapEdges(feature.type))
+                    continue;
+                collectFeatureSegments(feature, (start, end, startRef, endRef) => {
+                    if (!segmentIntersectsBBox(start, end, bbox))
+                        return;
+                    const candidate = {
+                        kind: 'edge',
+                        start,
+                        end,
+                        startRef,
+                        endRef,
+                        featureId: feature.id,
+                        datasetId,
+                    };
+                    candidates.push(candidate);
+                });
+            }
+            return candidates;
+        },
+    };
+    const intersectionProvider = {
+        name: 'core:display-intersection',
+        candidates(bbox, ctx) {
+            if (!deps.isEnabled())
+                return [];
+            const displayGroups = collectDisplaySegments(bbox);
+            if (displayGroups.length === 0)
+                return [];
+            const storeGroups = collectStoreSegments(bbox, ctx);
+            if (displayGroups.length < 2 && storeGroups.length === 0)
+                return [];
+            const candidates = [];
+            const seen = new Set();
+            /** Makes the intersections of the segments of 2 features into candidates (the
+             * origin is the display side) */
+            const intersect = (source, other) => {
+                for (const a of source.segments) {
+                    for (const b of other.segments) {
+                        const point = segmentIntersection(a.start, a.end, b.start, b.end);
+                        if (point === null)
+                            continue;
+                        // The same point can come out of several pairs, so they are merged into one
+                        const key = `${point[0]},${point[1]}`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        const candidate = {
+                            kind: 'intersection',
+                            coordinate: point,
+                            featureId: source.featureId,
+                            datasetId: source.datasetId,
+                            description: intersectionDescription,
+                        };
+                        candidates.push(candidate);
+                    }
+                }
+            };
+            for (let i = 0; i < displayGroups.length; i++) {
+                for (let j = i + 1; j < displayGroups.length; j++) {
+                    intersect(displayGroups[i], displayGroups[j]);
+                }
+                for (const group of storeGroups) {
+                    intersect(displayGroups[i], group);
+                }
+            }
+            return candidates;
+        },
+    };
+    return {
+        providers: [vertexProvider, edgeProvider, intersectionProvider],
+        queryFeatures(bbox) {
+            return nearbyFeatures(bbox).map((entry) => entry.feature);
+        },
+        getFeature(datasetId, featureId) {
+            const dataset = deps.datasets.get(datasetId);
+            if (!dataset) {
+                const stale = cache.get(datasetId);
+                stale?.unsubscribe();
+                cache.delete(datasetId);
+                return null;
+            }
+            return indexOf(entryOf(dataset)).byId.get(featureId) ?? null;
+        },
+    };
+}

package/dist/snapping/providers/guide.d.ts

@@ -0,0 +1,69 @@
+import { type Messages } from '../../messages.js';
+import type { Store } from '../../store/store.js';
+import { type SnapProvider } from '../types.js';
+/**
+ * The dependencies of {@link createGuideSnapProvider}.
+ *
+ * The guides are built from the vertices committed so far in the drawing in progress, so the
+ * Store alone is enough.
+ */
+export interface GuideSnapProviderDeps {
+    /** The Store of the draw instance, such as `ctx.getStore()` of a plugin */
+    store: Store;
+}
+/**
+ * The options of {@link createGuideSnapProvider}.
+ */
+export interface GuideSnapProviderOptions {
+    /**
+     * The step angle of the north-based guides in degrees (default: 45, which gives 8 guides).
+     * 0, a negative value or a non-finite value gives the default
+     */
+    northStepDegrees?: number;
+    /** The tile size in px the map uses, to convert px into degrees (default: 512) */
+    tileSize?: number;
+    /**
+     * The messages table the descriptions of the candidates come from (`snapNorth`,
+     * `snapExtension`, `snapPerpendicular`; default: `MESSAGES_EN`)
+     */
+    messages?: Partial<Messages>;
+}
+/**
+ * Creates a snapping provider of construction guides for `draw_line` and `draw_polygon`.
+ *
+ * The guides start at the last committed vertex (the anchor): the north-based guides at every
+ * `northStepDegrees` from true north (from the first vertex on), and the extension and the
+ * perpendiculars of the previous segment (from the second vertex on). Each guide is a
+ * segment 4096 screen px long, returned as a candidate of kind `'guide'` whose description
+ * comes from `messages` (`snapNorth`, `snapExtension`, `snapPerpendicular`). Outside those
+ * two modes it returns no candidates.
+ *
+ * The draw instance already registers a built-in one, whose step is set with
+ * `options.snap.guideStepDegrees` and changed at runtime with `draw.snapping.setGuideStep`.
+ * Register another one to add guides at a second step on top of the built-in ones.
+ *
+ * @param deps The Store to read the drawing in progress from
+ * @param options The step angle, the tile size and the messages
+ * @returns A provider to pass to `draw.snapping.register`
+ *
+ * @example
+ * ```ts
+ * import { createGuideSnapProvider, type Plugin } from '@sakuzu/maplibre-gl-draw';
+ *
+ * // Guides every 15 degrees from north, in addition to the built-in ones
+ * let unregister: (() => void) | undefined;
+ * const fineGuides: Plugin = {
+ *   name: 'fine-guides',
+ *   onInstall(ctx) {
+ *     unregister = draw.snapping.register(
+ *       createGuideSnapProvider({ store: ctx.getStore() }, { northStepDegrees: 15 }),
+ *     );
+ *   },
+ *   onUninstall() {
+ *     unregister?.();
+ *   },
+ * };
+ * draw.addPlugin(fineGuides);
+ * ```
+ */
+export declare function createGuideSnapProvider(deps: GuideSnapProviderDeps, options?: GuideSnapProviderOptions): SnapProvider;

package/dist/snapping/providers/guide.js

@@ -0,0 +1,187 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Built-in snapping provider (construction guides)
+ *
+ * It works only while drawing (draw_line / draw_polygon); it reads the confirmed
+ * vertices from the Tentative of the Store and returns the guides as segment
+ * candidates with kind: 'guide'. Because they are segment candidates, the
+ * computation of the point closest to the cursor can be left to SnapService.
+ *
+ * It produces 3 kinds of guides.
+ *
+ *   Extension      Forward from the anchor along the bearing of the previous segment
+ *                  (2 or more confirmed points)
+ *   Perpendicular  At the bearing of the previous segment +-90 degrees, to both
+ *                  sides of the anchor (2 or more confirmed points)
+ *   North-based    Towards every bearing at each step angle, starting from true
+ *                  north at 0 degrees (1 or more confirmed points)
+ *
+ * Only the north-based guide works from the very first segment. The built-in provider
+ * reads the step angle from SnapOptions.guideStepDegrees at every query (through a
+ * getter), so a change at runtime takes effect without rebuilding the provider. A
+ * provider made with createGuideSnapProvider keeps the step it was built with.
+ *
+ * A guide is not an infinite line; it is cut off at the equivalent of 4096 pixels on
+ * screen. The priority order stays SNAP_KIND_PRIORITY, so a real vertex,
+ * intersection or edge wins when it is within the tolerance.
+ */
+import { getPointAtAngle } from '../../geometry/angle.js';
+import { initialBearingDegrees } from '../../geometry/distance.js';
+import { EARTH_RADIUS_METERS, toRadians } from '../../geometry/units.js';
+import { resolveMessages } from '../../messages.js';
+import { DEFAULT_TILE_SIZE } from '../../shared/math/index.js';
+import { degreesPerPixel } from '../geometry.js';
+import { resolveGuideStepDegrees, } from '../types.js';
+/** The drawing modes that produce guides */
+const GUIDE_MODES = new Set(['draw_line', 'draw_polygon']);
+/** The length of a guide (pixels). The cut-off that keeps it from being an infinite line */
+const GUIDE_LENGTH_PIXELS = 4096;
+/**
+ * Takes the confirmed vertices out of the Tentative
+ *
+ * For a line it is the first confirmedCount items of the coordinate sequence. For a
+ * polygon it is the first confirmedCount items of the closed ring. The first point of
+ * a polygon has type 'Point' because it is shown as a marker (in that case there is
+ * no confirmedCount, and that single point is the confirmed one).
+ *
+ * @internal
+ */
+export function getConfirmedTentativeVertices(tentative) {
+    switch (tentative.type) {
+        case 'Point':
+            return [tentative.coordinates];
+        case 'LineString': {
+            const coords = tentative.coordinates;
+            const count = tentative.confirmedCount ?? coords.length;
+            return coords.slice(0, Math.max(0, Math.min(count, coords.length)));
+        }
+        case 'Polygon': {
+            const ring = tentative.coordinates[0];
+            if (!ring || ring.length === 0)
+                return [];
+            // It is a closed ring, so the last item is a copy of the first one. When there is
+            // no confirmedCount, the closing point is excluded
+            const count = tentative.confirmedCount ?? ring.length - 1;
+            return ring.slice(0, Math.max(0, Math.min(count, ring.length)));
+        }
+        default:
+            return [];
+    }
+}
+/**
+ * Computes the length of a guide (meters)
+ *
+ * The equivalent of GUIDE_LENGTH_PIXELS on screen is converted into degrees in the
+ * latitude direction, and that is converted into meters (because getPointAtAngle
+ * takes the distance in meters).
+ */
+function guideLengthMeters(anchor, zoom, tileSize) {
+    const perPixel = degreesPerPixel(anchor[1], zoom, tileSize);
+    const degrees = perPixel.lat * GUIDE_LENGTH_PIXELS;
+    return toRadians(degrees) * EARTH_RADIUS_METERS;
+}
+/**
+ * Builds a segment candidate extended from the anchor towards the bearing
+ *
+ * When backwardBearing is given, it becomes a single segment extended towards that
+ * side as well (a guide on both sides passing through the anchor).
+ */
+function guideSegment(anchor, lengthMeters, bearing, description, backwardBearing) {
+    return {
+        kind: 'guide',
+        start: backwardBearing === undefined
+            ? [anchor[0], anchor[1]]
+            : getPointAtAngle(anchor, lengthMeters, backwardBearing),
+        end: getPointAtAngle(anchor, lengthMeters, bearing),
+        description,
+    };
+}
+/**
+ * Creates a snapping provider of construction guides for `draw_line` and `draw_polygon`.
+ *
+ * The guides start at the last committed vertex (the anchor): the north-based guides at every
+ * `northStepDegrees` from true north (from the first vertex on), and the extension and the
+ * perpendiculars of the previous segment (from the second vertex on). Each guide is a
+ * segment 4096 screen px long, returned as a candidate of kind `'guide'` whose description
+ * comes from `messages` (`snapNorth`, `snapExtension`, `snapPerpendicular`). Outside those
+ * two modes it returns no candidates.
+ *
+ * The draw instance already registers a built-in one, whose step is set with
+ * `options.snap.guideStepDegrees` and changed at runtime with `draw.snapping.setGuideStep`.
+ * Register another one to add guides at a second step on top of the built-in ones.
+ *
+ * @param deps The Store to read the drawing in progress from
+ * @param options The step angle, the tile size and the messages
+ * @returns A provider to pass to `draw.snapping.register`
+ *
+ * @example
+ * ```ts
+ * import { createGuideSnapProvider, type Plugin } from '@sakuzu/maplibre-gl-draw';
+ *
+ * // Guides every 15 degrees from north, in addition to the built-in ones
+ * let unregister: (() => void) | undefined;
+ * const fineGuides: Plugin = {
+ *   name: 'fine-guides',
+ *   onInstall(ctx) {
+ *     unregister = draw.snapping.register(
+ *       createGuideSnapProvider({ store: ctx.getStore() }, { northStepDegrees: 15 }),
+ *     );
+ *   },
+ *   onUninstall() {
+ *     unregister?.();
+ *   },
+ * };
+ * draw.addPlugin(fineGuides);
+ * ```
+ */
+export function createGuideSnapProvider(deps, options = {}) {
+    const step = resolveGuideStepDegrees(options.northStepDegrees);
+    return createSteppedGuideSnapProvider(deps, () => step, options);
+}
+/**
+ * Creates the guide provider whose step angle is read through a getter at every query
+ * (the built-in provider reads the current `guideStepDegrees` of the SnapService this way)
+ *
+ * @param deps The Store to read the drawing in progress from
+ * @param getNorthStepDegrees Returns the step angle; an invalid value gives the default
+ * @param options The tile size and the messages (`northStepDegrees` is ignored)
+ * @internal
+ */
+export function createSteppedGuideSnapProvider(deps, getNorthStepDegrees, options = {}) {
+    const tileSize = options.tileSize ?? DEFAULT_TILE_SIZE;
+    // The descriptions of the candidates (read by the status bar and the like)
+    const messages = resolveMessages(options.messages);
+    return {
+        name: 'core:guide',
+        candidates(_bbox, ctx) {
+            if (!GUIDE_MODES.has(deps.store.getMode()))
+                return [];
+            const tentative = deps.store.getTentative();
+            if (!tentative)
+                return [];
+            const confirmed = getConfirmedTentativeVertices(tentative);
+            if (confirmed.length === 0)
+                return [];
+            const anchor = confirmed[confirmed.length - 1];
+            const lengthMeters = guideLengthMeters(anchor, ctx.zoom, tileSize);
+            const candidates = [];
+            const step = resolveGuideStepDegrees(getNorthStepDegrees());
+            // North-based: every bearing at each step angle, starting from true north. The
+            // only guide that works from the very first segment
+            for (let bearing = 0; bearing < 360; bearing += step) {
+                candidates.push(guideSegment(anchor, lengthMeters, bearing, messages.snapNorth));
+            }
+            if (confirmed.length >= 2) {
+                const previous = confirmed[confirmed.length - 2];
+                const bearing = initialBearingDegrees(previous, anchor);
+                // Extension: forward along the bearing of the previous segment
+                candidates.push(guideSegment(anchor, lengthMeters, bearing, messages.snapExtension));
+                // Perpendicular: the bearing of the previous segment +-90 degrees. Merged into a
+                // single line passing through the anchor
+                candidates.push(guideSegment(anchor, lengthMeters, (bearing + 90) % 360, messages.snapPerpendicular, (bearing + 270) % 360));
+            }
+            return candidates;
+        },
+    };
+}

package/dist/snapping/providers/intersection.d.ts

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

package/dist/snapping/providers/intersection.js

@@ -0,0 +1,92 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Built-in snapping provider (intersections between edges)
+ *
+ * It gathers the edges that fall near the cursor (within the bbox of the tolerance)
+ * and returns the intersections of pairs of segments from different features as
+ * point candidates with kind: 'intersection'. Self-intersections within the same
+ * feature are out of scope (a self-intersecting polygon is an invalid shape, and
+ * there is no demand for snapping to the self-intersection point of a polyline).
+ *
+ * The bbox is the size of the tolerance (10px by default), so the number of edges
+ * that fall within it stays at a few. Combining them by brute force is small enough,
+ * so no dedicated index is kept.
+ *
+ * The rules of exclusion are the same as for the vertex and edge providers: the
+ * edges of an excluded feature and the edges touching the vertex being dragged are
+ * not used in the computation of the intersections.
+ */
+import { segmentIntersection } from '../../geometry/split.js';
+import { MESSAGES_EN } from '../../messages.js';
+import { collectFeatureSegmentsInBBox, hasSnapEdges, isExcludedVertex, queryFeatures, segmentIntersectsBBox, } from './shared.js';
+/**
+ * Gathers the edges that fall within the bbox, per feature
+ */
+function collectNearbySegments(deps, bbox, ctx) {
+    const result = [];
+    for (const feature of queryFeatures(deps, bbox, ctx)) {
+        // The candidates of a custom type are returned by the vertex provider
+        // (getSnapTargets)
+        if (deps.snapTargets?.get(feature.type))
+            continue;
+        if (!hasSnapEdges(feature.type))
+            continue;
+        const segments = [];
+        collectFeatureSegmentsInBBox(feature, bbox, (start, end, startRef, endRef) => {
+            if (!segmentIntersectsBBox(start, end, bbox))
+                return;
+            if (isExcludedVertex(feature.id, startRef, ctx))
+                return;
+            if (isExcludedVertex(feature.id, endRef, ctx))
+                return;
+            segments.push({ start, end });
+        });
+        if (segments.length > 0)
+            result.push({ featureId: feature.id, segments });
+    }
+    return result;
+}
+/**
+ * Builds the intersection provider for the Store
+ *
+ * @internal
+ */
+export function createStoreIntersectionSnapProvider(deps) {
+    // The description of the candidates (read by the status bar and the like)
+    const description = deps.messages?.snapIntersection ?? MESSAGES_EN.snapIntersection;
+    return {
+        name: 'core:store-intersection',
+        candidates(bbox, ctx) {
+            const nearby = collectNearbySegments(deps, bbox, ctx);
+            if (nearby.length < 2)
+                return [];
+            const candidates = [];
+            const seen = new Set();
+            for (let i = 0; i < nearby.length; i++) {
+                for (let j = i + 1; j < nearby.length; j++) {
+                    for (const a of nearby[i].segments) {
+                        for (const b of nearby[j].segments) {
+                            const point = segmentIntersection(a.start, a.end, b.start, b.end);
+                            if (point === null)
+                                continue;
+                            // The same point can come out of several pairs, so they are merged into one
+                            const key = `${point[0]},${point[1]}`;
+                            if (seen.has(key))
+                                continue;
+                            seen.add(key);
+                            const candidate = {
+                                kind: 'intersection',
+                                coordinate: point,
+                                featureId: nearby[i].featureId,
+                                description,
+                            };
+                            candidates.push(candidate);
+                        }
+                    }
+                }
+            }
+            return candidates;
+        },
+    };
+}

package/dist/snapping/providers/shared.d.ts

@@ -0,0 +1,39 @@
+import type { Store } from '../../store/store.js';
+import type { BoundingBox, Coordinate, Feature, VertexRef } from '../../store/types.js';
+import type { SnapProviderContext } from '../types.js';
+export type { SegmentVisitor } from '../../shared/utils/feature-segments.js';
+export { collectFeatureSegments, collectFeatureSegmentsInBBox, hasSnapEdges, segmentIntersectsBBox, } from '../../shared/utils/feature-segments.js';
+/**
+ * Whether the feature is a snapping target (whether it is displayed)
+ *
+ * It looks at both the shared visible cascade (feature / group / layer) and the local
+ * hiding that applies to this client only.
+ */
+export declare function isSnapVisible(feature: Feature, store: Store): boolean;
+/**
+ * Lists the candidate features near the bbox
+ */
+export declare function queryFeatures(deps: StoreSnapProviderDeps, bbox: BoundingBox, ctx: SnapProviderContext): Feature[];
+/**
+ * Whether the vertex is to be excluded
+ */
+export declare function isExcludedVertex(featureId: string, vertex: VertexRef | undefined, ctx: SnapProviderContext): boolean;
+/**
+ * A vertex candidate limited to the bbox
+ */
+export interface VertexCandidate {
+    position: Coordinate;
+    vertexRef: VertexRef;
+}
+/**
+ * Gathers the vertices of a feature that are inside the bbox
+ *
+ * The bbox is the cursor position +- the tolerance (in longitude and in latitude),
+ * and the distance test of SnapService measures the pixel distance with the same
+ * conversion. A vertex outside the bbox can therefore never be inside the tolerance,
+ * and discarding it here does not change the candidates.
+ *
+ * For types without edges (Point / MultiPoint / custom types), the full listing of
+ * computeVertexHandles is simply narrowed down by the bbox, as before.
+ */
+export declare function collectVertexCandidatesInBBox(feature: Feature, bbox: BoundingBox): VertexCandidate[];