@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/shared/utils/name-generator.d.ts

@@ -8,7 +8,7 @@
  * the host's `typeNames`, or from the English defaults below. Nothing else in the library
  * writes such a word inline.
  */
-import type { Feature, FeatureType, Group, Layer, StateChanges } from '../types/model.js';
+import type { Feature, FeatureType, Group, Layer, StoreChange } from '../types/model.js';
 /**
  * What automatic naming names: a feature type, a layer or a group
  */
@@ -16,8 +16,8 @@ export type AutoNameType = FeatureType | 'Layer' | 'Group';
 /**
  * How new features, layers and groups are named automatically ("Point 1", "Layer 2")
  *
- * Give it through the `autoName` option of `createMapLibreGLDraw` (`true`, the default, turns
- * it on with these defaults, and `false` turns it off). Each type counts on its own, and a
+ * The engine reads it from the `autoName` option of `createDraw` (left out, it is on with
+ * these defaults, and `false` turns it off). Each type counts on its own, and a
  * number is never reused: after "Point 1" and "Point 2" are created and "Point 2" is deleted,
  * the next point is "Point 3". Existing names of the form "<word> <number>" move the count on
  * as well, however they arrived (a load, an import).
@@ -32,18 +32,6 @@ export type AutoNameType = FeatureType | 'Layer' | 'Group';
  * A layer or a group always has a name. When one is created without a name while `enabled`
  * is false, it gets the word of its type alone, without a number ("Layer", or the
  * `typeNames.Layer` of the host); features get no name then.
- *
- * @example
- * ```ts
- * const draw = createMapLibreGLDraw(map, {
- *   autoName: {
- *     enabled: true,
- *     typeNames: { Point: 'Pin', Layer: 'Sheet' },
- *     formatter: (typeName, n) => `${typeName} #${n}`,
- *   },
- * });
- * // The first point is named "Pin #1"
- * ```
  */
 export interface AutoNameConfig {
     /**
@@ -90,7 +78,7 @@ export declare function normalizeAutoNameConfig(config: AutoNameConfig | boolean
  */
 export declare class AutoNameGenerator {
     private readonly store;
-    private readonly config;
+    private config;
     /** Counter that remembers the largest number already generated per type */
     private readonly counters;
     /** Counter keys whose full scan is done (Layer/Group go into the same Set) */
@@ -98,15 +86,21 @@ export declare class AutoNameGenerator {
     /** Unsubscribe function of the Store subscription (null when not subscribed) */
     private unsubscribe;
     constructor(store: {
-        getAllFeatures(): Feature[];
-        getAllLayers(): Layer[];
-        getAllGroups(): Group[];
-        subscribe(listener: (changes: StateChanges) => void): () => void;
+        listFeatures(): Feature[];
+        listLayers(): Layer[];
+        listGroups(): Group[];
+        subscribe(listener: (changes: StoreChange) => void): () => void;
     }, config?: AutoNameConfig | boolean);
     /**
      * Returns whether it is enabled
      */
     isEnabled(): boolean;
+    /**
+     * Replaces the configuration: whether names are generated, the words of the types and the
+     * format. The numbers already used are not used again; the names already in the document
+     * are read again in the new words.
+     */
+    configure(config: AutoNameConfig | boolean): void;
     /**
      * Unsubscribes from the Store
      */

package/dist/shared/utils/name-generator.js

@@ -117,6 +117,23 @@ export class AutoNameGenerator {
     isEnabled() {
         return this.config.enabled;
     }
+    /**
+     * Replaces the configuration: whether names are generated, the words of the types and the
+     * format. The numbers already used are not used again; the names already in the document
+     * are read again in the new words.
+     */
+    configure(config) {
+        this.config = normalizeAutoNameConfig(config);
+        this.scannedTypes.clear();
+        if (this.config.enabled && !this.unsubscribe) {
+            this.unsubscribe = this.store.subscribe((changes) => {
+                this.observeChanges(changes);
+            });
+        }
+        else if (!this.config.enabled) {
+            this.dispose();
+        }
+    }
     /**
      * Unsubscribes from the Store
      */
@@ -244,7 +261,7 @@ export class AutoNameGenerator {
      * Gets the largest number from the existing Features
      */
     getMaxNumberFromFeatures(featureType, typeName) {
-        const features = this.store.getAllFeatures();
+        const features = this.store.listFeatures();
         let maxNumber = 0;
         for (const feature of features) {
             // Only features of the same type are considered
@@ -287,7 +304,7 @@ export class AutoNameGenerator {
     findNextLayerNumber(typeName) {
         this.scanOnce(LAYER_COUNTER_KEY, () => {
             let maxNumber = 0;
-            for (const layer of this.store.getAllLayers()) {
+            for (const layer of this.store.listLayers()) {
                 const number = extractNumberFromName(layer.name, typeName);
                 if (number !== null && number > maxNumber) {
                     maxNumber = number;
@@ -322,7 +339,7 @@ export class AutoNameGenerator {
     findNextGroupNumber(typeName) {
         this.scanOnce(GROUP_COUNTER_KEY, () => {
             let maxNumber = 0;
-            for (const group of this.store.getAllGroups()) {
+            for (const group of this.store.listGroups()) {
                 const number = extractNumberFromName(group.name, typeName);
                 if (number !== null && number > maxNumber) {
                     maxNumber = number;

package/dist/shared/utils/pixel-ratio.d.ts

@@ -46,7 +46,7 @@ export interface PixelRatioProvider {
     /** The current rendering pixel ratio (the injected value or window x renderScale) */
     resolve: () => number;
     /** The factor of the current rendering pixel ratio (default 1) */
-    getRenderScale: () => number;
+    getScaleFactor: () => number;
 }
 /**
  * The rendering pixel ratio that can be injected
@@ -88,9 +88,15 @@ export declare function resolveContentPixelRatio(pixelRatio?: PixelRatioInput):
  *
  * The read side (`PixelRatioProvider`) plus a socket for rewriting the factor.
  * Handing the source itself out to each renderer as the `PixelRatioInput` makes a change from
- * `setRenderScale` propagate from the next frame to every place that reads it directly.
+ * `setScaleFactor` propagate from the next frame to every place that reads it directly.
  */
 export interface PixelRatioSource extends PixelRatioProvider {
+    /**
+     * Replaces the pixel ratio given at creation; `undefined` goes back to the ratio of the map
+     *
+     * @returns Whether the value changed
+     */
+    setPixelRatio: (pixelRatio: number | undefined) => boolean;
     /**
      * Sets the factor of the rendering pixel ratio
      *
@@ -98,7 +104,7 @@ export interface PixelRatioSource extends PixelRatioProvider {
      * when the value changed, so the caller can trigger a redraw or a rebuild of the batches
      * only at that point.
      */
-    setRenderScale: (scale: number) => boolean;
+    setScaleFactor: (scale: number) => boolean;
 }
 /**
  * Creates a source of the rendering pixel ratio

package/dist/shared/utils/pixel-ratio.js

@@ -53,7 +53,7 @@ export function resolvePixelRatio(pixelRatio) {
 export function resolveContentPixelRatio(pixelRatio) {
     if (!isProvider(pixelRatio))
         return resolvePixelRatio(pixelRatio);
-    const scale = pixelRatio.getRenderScale();
+    const scale = pixelRatio.getScaleFactor();
     const resolved = resolvePixelRatio(pixelRatio);
     if (!usable(scale))
         return resolved;
@@ -69,11 +69,20 @@ export function resolveContentPixelRatio(pixelRatio) {
  */
 export function createPixelRatioSource(pixelRatio, fallback) {
     let renderScale = 1;
-    const input = usable(pixelRatio) ? pixelRatio : fallback;
+    let given = usable(pixelRatio) ? pixelRatio : undefined;
+    let input = given ?? fallback;
     return {
+        setPixelRatio: (value) => {
+            const next = usable(value) ? value : undefined;
+            if (next === given)
+                return false;
+            given = next;
+            input = given ?? fallback;
+            return true;
+        },
         resolve: () => resolvePixelRatio(input) * renderScale,
-        getRenderScale: () => renderScale,
-        setRenderScale: (scale) => {
+        getScaleFactor: () => renderScale,
+        setScaleFactor: (scale) => {
             if (!Number.isFinite(scale) || scale <= 0)
                 return false;
             if (scale === renderScale)

package/dist/shared/utils/property.d.ts

@@ -1,75 +1,32 @@
 import type { Feature, ImageProperties } from '../types/model.js';
 /**
- * Gets the zoom at which the feature was created (`properties.createdZoom`)
+ * Gets the zoom at which the feature was created (`maplibre-gl-draw:createdZoom` in
+ * `properties`)
  *
  * The drawing modes record it. Line widths follow the map from that zoom, and an Image is
  * drawn at its size in pixels at that zoom (see {@link FeatureStyle.strokeWidth}).
  *
  * @returns The zoom, or undefined when the feature has none (it then keeps the same width on
  *   the screen)
- *
- * @example
- * ```ts
- * const feature = draw.getFeature(id);
- * const zoom = feature ? getCreatedZoom(feature) : undefined;
- * ```
  */
 export declare function getCreatedZoom(feature: Feature): number | undefined;
 /**
  * Sets the zoom at which a feature was created, in a `properties` object
  *
- * Use it on the properties of a {@link FeatureInput} before `addFeature`, so that the new
+ * Use it on the properties of a {@link FeatureInput} before it is created, so that the new
  * feature scales with the map from the current zoom like a drawn one.
- *
- * @example
- * ```ts
- * const properties: Record<string, unknown> = {};
- * setCreatedZoom(properties, map.getZoom());
- * draw.addFeature({
- *   type: 'LineString',
- *   coordinates: [
- *     [139.76, 35.68],
- *     [139.78, 35.69],
- *   ],
- *   properties,
- * });
- * ```
  */
 export declare function setCreatedZoom(properties: Record<string, unknown>, zoom: number): void;
 /**
- * Gets the rotation of the feature in degrees (`properties.rotation`, 0 when unset)
+ * Gets the rotation of the feature in degrees (`maplibre-gl-draw:rotation` in `properties`, 0
+ * when unset)
  */
 export declare function getRotation(feature: Feature): number;
 /**
- * Sets the rotation in degrees, in a `properties` object (the properties of a
- * {@link FeatureInput} before `addFeature`, say)
- */
-export declare function setRotation(properties: Record<string, unknown>, rotation: number): void;
-/**
- * Gets the scale of the feature (`properties.scale`, 1 when unset), which resizing an Image
- * changes
+ * Gets the scale of the feature (`maplibre-gl-draw:scale` in `properties`, 1 when unset),
+ * which resizing an Image changes
  */
 export declare function getScale(feature: Feature): number;
-/**
- * Sets the scale of the feature
- */
-export declare function setScale(properties: Record<string, unknown>, scale: number): void;
-/**
- * Gets the name of the feature
- */
-export declare function getFeatureName(feature: Feature): string | undefined;
-/**
- * Sets the name of the feature
- */
-export declare function setFeatureName(properties: Record<string, unknown>, name: string): void;
-/**
- * Gets the description of the feature
- */
-export declare function getFeatureDescription(feature: Feature): string | undefined;
-/**
- * Sets the description of the feature
- */
-export declare function setFeatureDescription(properties: Record<string, unknown>, description: string): void;
 /**
  * Gets the properties of an Image feature in a type-safe way.
  *

package/dist/shared/utils/property.js

@@ -4,107 +4,45 @@
  * Property helpers
  *
  * Utilities for handling the properties of a feature (feature.properties) in a type-safe way.
- *
- * This library's own data such as createdZoom/rotation/scale has to round-trip through
- * GeoJSON with the maplibre-gl-draw: prefix, so it is held inside feature.properties under
- * keys without the prefix.
+ * The values of the library are read and written through the accessors of
+ * shared/properties.ts, which own their keys.
  */
-import { INTERNAL_PROPERTIES } from '../config/constants.js';
+import { getDrawProperty, setDrawProperty } from '../properties.js';
 /**
- * Gets the zoom at which the feature was created (`properties.createdZoom`)
+ * Gets the zoom at which the feature was created (`maplibre-gl-draw:createdZoom` in
+ * `properties`)
  *
  * The drawing modes record it. Line widths follow the map from that zoom, and an Image is
  * drawn at its size in pixels at that zoom (see {@link FeatureStyle.strokeWidth}).
  *
  * @returns The zoom, or undefined when the feature has none (it then keeps the same width on
  *   the screen)
- *
- * @example
- * ```ts
- * const feature = draw.getFeature(id);
- * const zoom = feature ? getCreatedZoom(feature) : undefined;
- * ```
  */
 export function getCreatedZoom(feature) {
-    const value = feature.properties[INTERNAL_PROPERTIES.CREATED_ZOOM];
-    return typeof value === 'number' ? value : undefined;
+    return getDrawProperty(feature, 'createdZoom');
 }
 /**
  * Sets the zoom at which a feature was created, in a `properties` object
  *
- * Use it on the properties of a {@link FeatureInput} before `addFeature`, so that the new
+ * Use it on the properties of a {@link FeatureInput} before it is created, so that the new
  * feature scales with the map from the current zoom like a drawn one.
- *
- * @example
- * ```ts
- * const properties: Record<string, unknown> = {};
- * setCreatedZoom(properties, map.getZoom());
- * draw.addFeature({
- *   type: 'LineString',
- *   coordinates: [
- *     [139.76, 35.68],
- *     [139.78, 35.69],
- *   ],
- *   properties,
- * });
- * ```
  */
 export function setCreatedZoom(properties, zoom) {
-    properties[INTERNAL_PROPERTIES.CREATED_ZOOM] = zoom;
+    setDrawProperty(properties, 'createdZoom', zoom);
 }
 /**
- * Gets the rotation of the feature in degrees (`properties.rotation`, 0 when unset)
+ * Gets the rotation of the feature in degrees (`maplibre-gl-draw:rotation` in `properties`, 0
+ * when unset)
  */
 export function getRotation(feature) {
-    const value = feature.properties[INTERNAL_PROPERTIES.ROTATION];
-    return typeof value === 'number' ? value : 0;
-}
-/**
- * Sets the rotation in degrees, in a `properties` object (the properties of a
- * {@link FeatureInput} before `addFeature`, say)
- */
-export function setRotation(properties, rotation) {
-    properties[INTERNAL_PROPERTIES.ROTATION] = rotation;
+    return getDrawProperty(feature, 'rotation') ?? 0;
 }
 /**
- * Gets the scale of the feature (`properties.scale`, 1 when unset), which resizing an Image
- * changes
+ * Gets the scale of the feature (`maplibre-gl-draw:scale` in `properties`, 1 when unset),
+ * which resizing an Image changes
  */
 export function getScale(feature) {
-    const value = feature.properties[INTERNAL_PROPERTIES.SCALE];
-    return typeof value === 'number' ? value : 1;
-}
-/**
- * Sets the scale of the feature
- */
-export function setScale(properties, scale) {
-    properties[INTERNAL_PROPERTIES.SCALE] = scale;
-}
-/**
- * Gets the name of the feature
- */
-export function getFeatureName(feature) {
-    const value = feature.properties.name;
-    return typeof value === 'string' ? value : undefined;
-}
-/**
- * Sets the name of the feature
- */
-export function setFeatureName(properties, name) {
-    properties.name = name;
-}
-/**
- * Gets the description of the feature
- */
-export function getFeatureDescription(feature) {
-    const value = feature.properties.description;
-    return typeof value === 'string' ? value : undefined;
-}
-/**
- * Sets the description of the feature
- */
-export function setFeatureDescription(properties, description) {
-    properties.description = description;
+    return getDrawProperty(feature, 'scale') ?? 1;
 }
 /**
  * Gets the properties of an Image feature in a type-safe way.
@@ -113,28 +51,25 @@ export function setFeatureDescription(properties, description) {
  * Use it instead of a dangerous cast such as `as unknown as ImageProperties`.
  */
 export function getImageProperties(feature) {
-    const p = feature.properties;
     return {
-        imageFileId: typeof p.imageFileId === 'string' ? p.imageFileId : '',
-        imageWidth: typeof p.imageWidth === 'number' ? p.imageWidth : 0,
-        imageHeight: typeof p.imageHeight === 'number' ? p.imageHeight : 0,
-        createdZoom: typeof p.createdZoom === 'number' ? p.createdZoom : 0,
-        rotation: typeof p.rotation === 'number' ? p.rotation : undefined,
-        scale: typeof p.scale === 'number' ? p.scale : undefined,
+        imageFileId: getDrawProperty(feature, 'imageFileId') ?? '',
+        imageWidth: getDrawProperty(feature, 'imageWidth') ?? 0,
+        imageHeight: getDrawProperty(feature, 'imageHeight') ?? 0,
+        createdZoom: getDrawProperty(feature, 'createdZoom') ?? 0,
+        rotation: getDrawProperty(feature, 'rotation'),
+        scale: getDrawProperty(feature, 'scale'),
     };
 }
 /**
  * Gets the radius (meters) of a Circle feature. undefined when it is unset or invalid.
  */
 export function getCircleRadius(feature) {
-    const value = feature.properties.radiusMeters;
-    return typeof value === 'number' ? value : undefined;
+    return getDrawProperty(feature, 'radiusMeters');
 }
 /**
  * Gets the angle (degrees) of the radius handle of a Circle feature. The default is 135
  * (toward the southwest).
  */
 export function getRadiusHandleAngle(feature) {
-    const value = feature.properties.radiusHandleAngle;
-    return typeof value === 'number' ? value : 135;
+    return getDrawProperty(feature, 'radiusHandleAngle') ?? 135;
 }

package/dist/snapping/custom-targets.js

@@ -7,15 +7,32 @@
  */
 export function createSnapTargetsRegistry() {
     const providers = new Map();
+    const narrowed = new Map();
     return {
-        register(type, provider) {
+        register(type, provider, appliesTo) {
             providers.set(type, provider);
+            if (appliesTo)
+                narrowed.set(type, appliesTo);
+            else
+                narrowed.delete(type);
             return () => {
-                if (providers.get(type) === provider)
-                    providers.delete(type);
+                if (providers.get(type) !== provider)
+                    return;
+                providers.delete(type);
+                narrowed.delete(type);
             };
         },
         get: (type) => providers.get(type),
-        clear: () => providers.clear(),
+        forFeature(feature) {
+            const provider = providers.get(feature.type);
+            if (!provider)
+                return undefined;
+            const appliesTo = narrowed.get(feature.type);
+            return appliesTo && !appliesTo(feature) ? undefined : provider;
+        },
+        clear() {
+            providers.clear();
+            narrowed.clear();
+        },
     };
 }

package/dist/snapping/indicator.js

@@ -78,6 +78,17 @@ export const DEFAULT_SNAP_INDICATOR_STYLES = {
     intersection: INTERSECTION_STYLE,
     guide: GUIDE_STYLE,
 };
+/**
+ * A look of the indicator with the defaults, which the caller may change in place
+ *
+ * @internal
+ */
+export function createSnapIndicatorLook() {
+    return structuredClone({
+        styles: DEFAULT_SNAP_INDICATOR_STYLES,
+        guideLine: DEFAULT_SNAP_GUIDE_LINE_STYLE,
+    });
+}
 /**
  * The renderer of the snapping indicator
  *
@@ -103,21 +114,17 @@ export class SnapIndicatorRenderer {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "styles", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "guideLineStyle", {
+        Object.defineProperty(this, "look", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
         this.snapService = deps.snapService;
-        this.styles = { ...DEFAULT_SNAP_INDICATOR_STYLES, ...deps.styles };
-        this.guideLineStyle = deps.guideLineStyle ?? DEFAULT_SNAP_GUIDE_LINE_STYLE;
+        this.look = deps.look ?? {
+            styles: { ...DEFAULT_SNAP_INDICATOR_STYLES, ...deps.styles },
+            guideLine: deps.guideLineStyle ?? DEFAULT_SNAP_GUIDE_LINE_STYLE,
+        };
     }
     onAdd(_gl, _map) {
         // It uses the existing drawing primitives, so it holds no GPU resources of its own
@@ -134,9 +141,11 @@ export class SnapIndicatorRenderer {
                 [target.segment.start[0], target.segment.start[1]],
                 [target.segment.end[0], target.segment.end[1]],
             ];
-            context.sdfLineRenderer.draw(line, this.guideLineStyle, { widthUnit: 'pixels', closed: false }, zoom, projectionData);
+            context.sdfLineRenderer.draw(line, this.look.guideLine, { widthUnit: 'pixels', closed: false }, zoom, projectionData);
         }
-        const style = this.styles[target.kind];
+        // A kind of a provider's own is shown as a vertex
+        const { styles } = this.look;
+        const style = styles[target.kind] ?? styles.vertex;
         context.pointShapeRenderer.draw([result.lngLat.lng, result.lngLat.lat], style, zoom);
     }
     onRemove() {

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

@@ -18,7 +18,7 @@
  * "display x Store" are computed (Store x Store is the responsibility of
  * providers/intersection.ts).
  */
-import type { DatasetManager } from '../../display/manager.js';
+import type { DatasetManager } from '../../dataset/manager.js';
 import { type Messages } from '../../messages.js';
 import type { SpatialIndex } from '../../store/spatial/spatial-index.js';
 import type { Store } from '../../store/store.js';
@@ -65,6 +65,11 @@ export interface DisplaySnapProviders {
      * of edges (it is wired to ModeContext.getDatasetTraceFeatures).
      */
     queryFeatures(bbox: BoundingBox): Feature[];
+    /** The same features as `queryFeatures`, each with the ID of its dataset */
+    queryRows(bbox: BoundingBox): Array<{
+        datasetId: string;
+        feature: Feature;
+    }>;
 }
 /**
  * Builds the snapping providers for datasets

package/dist/snapping/providers/display.js

@@ -132,7 +132,7 @@ export function createDisplaySnapProviders(deps) {
         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))
+            if (deps.snapTargets?.forFeature(feature))
                 continue;
             if (!hasSnapEdges(feature.type))
                 continue;
@@ -254,6 +254,7 @@ export function createDisplaySnapProviders(deps) {
         queryFeatures(bbox) {
             return nearbyFeatures(bbox).map((entry) => entry.feature);
         },
+        queryRows: (bbox) => nearbyFeatures(bbox),
         getFeature(datasetId, featureId) {
             const dataset = deps.datasets.get(datasetId);
             if (!dataset) {

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

@@ -1,18 +1,17 @@
 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 dependencies of {@link createSteppedGuideSnapProvider}.
  *
  * 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 */
+    /** The Store of the draw instance */
     store: Store;
 }
 /**
- * The options of {@link createGuideSnapProvider}.
+ * The options of {@link createSteppedGuideSnapProvider}.
  */
 export interface GuideSnapProviderOptions {
     /**
@@ -28,42 +27,3 @@ export interface GuideSnapProviderOptions {
      */
     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;