smap-leaflet 0.0.0-stage → 2.6.1

package/dist/index.d.ts

@@ -0,0 +1,1240 @@
+import * as L_2 from 'leaflet';
+
+export declare interface AdministrativeParams extends ServiceKeyParam {
+    /** District name, or its 9-digit code such as "156340100" */
+    keyword?: string;
+    /** @deprecated Use `keyword` */
+    searchWord?: string;
+    /** How many levels of sub-districts to include (0–3). Default 0 */
+    childLevel?: 0 | 1 | 2 | 3;
+    /** Include boundary geometry (WKT). Default false */
+    extensions?: boolean;
+}
+
+export declare type AreaUnit = 'auto' | 'm2' | 'km2' | 'ha' | 'mu';
+
+export declare interface AttributionOptions {
+    prefix?: string;
+    content?: string;
+}
+
+/**
+ * Base class of the measure tools.
+ *
+ * It owns the whole lifecycle — drawing, labels, results, events, cleanup. A
+ * concrete tool only says how to read numbers off a shape and how to word them.
+ */
+export declare abstract class BaseMeasureTool implements MeasureTool {
+    protected map: L_2.Map;
+    protected options: MeasureOptions;
+    /** Holds the finished shapes */
+    protected layerGroup: L_2.FeatureGroup;
+    private entries;
+    /** Labels of the drawing in progress */
+    private draft;
+    private session;
+    private emitter;
+    private clickHandler;
+    private editor;
+    private snapper;
+    private destroyed;
+    /** @deprecated Nothing needs loading any more. Kept so existing calls keep working */
+    static preload(): Promise<void>;
+    constructor(map: L_2.Map, options?: MeasureOptions);
+    /** Which shape this tool draws */
+    protected abstract readonly drawType: MeasureType;
+    /** Read the measurement off a finished shape */
+    protected abstract measure(layer: any): MeasureGeometry;
+    /** Where the result label goes */
+    protected abstract anchor(result: MeasureResult): L_2.LatLng;
+    /** Default wording of a label */
+    protected abstract defaultText(label: MeasureLabel): string;
+    /** What the deprecated `valueFormatter` option receives for this tool */
+    protected abstract legacyValue(label: MeasureLabel): number | L_2.LatLng[];
+    /** Labels to show while drawing; only the distance tool has any */
+    protected draftLabels(_latlngs: L_2.LatLng[]): LabelSpec[];
+    /** Labels of a finished measurement. By default just the result label */
+    protected resultLabels(result: MeasureResult): LabelSpec[];
+    get type(): MeasureType;
+    get measuring(): boolean;
+    enable(): void;
+    disable(): void;
+    get editing(): boolean;
+    startEdit(): void;
+    undo(): boolean;
+    finishEdit(save?: boolean): void;
+    /** Read the numbers off the shape again and redraw its labels */
+    private refresh;
+    setOptions(options: Partial<MeasureOptions>): void;
+    getResults(): MeasureResult[];
+    remove(id: string): void;
+    clearAll(): void;
+    on<K extends keyof MeasureEvents>(type: K, handler: (event: MeasureEvents[K]) => void): void;
+    off<K extends keyof MeasureEvents>(type: K, handler: (event: MeasureEvents[K]) => void): void;
+    destroy(): void;
+    private handleVertex;
+    private handleCreated;
+    private setDraft;
+    /** Put labels on the map. A label is a permanent tooltip on an invisible marker */
+    private renderLabels;
+    protected getShapeOptions(): L_2.PathOptions;
+    /** Text of a label: `formatLabel`, else the deprecated `valueFormatter`, else the default */
+    protected text(label: MeasureLabel, legacyPrefix?: string): string;
+    /** Plain label, used for intermediate values */
+    protected labelHtml(content: string): string;
+    /** Emphasised label of a finished measurement, with the button that removes it */
+    protected resultHtml(result: MeasureResult, legacyPrefix?: string): string;
+    /** Labels take the colour of this tool's lines */
+    private accentStyle;
+    protected formatLength(meters: number): string;
+    protected formatArea(sqMeters: number): string;
+    /** Length of a path in metres */
+    protected pathLength(latlngs: L_2.LatLng[]): number;
+}
+
+/** BD-09 → GCJ-02 */
+export declare function bd09ToGcj02(lng: number, lat: number): Coord;
+
+/** BD-09 → WGS-84 */
+export declare function bd09ToWgs84(lng: number, lat: number): Coord;
+
+/** Every tile type shipped with the library (kept in sync with `providers` by a test) */
+export declare const BUILTIN_TILE_TYPES: readonly ["TianDiTu.Normal.Map", "TianDiTu.Normal.Annotion", "TianDiTu.Satellite.Map", "TianDiTu.Satellite.Annotion", "TianDiTu.Terrain.Map", "TianDiTu.Terrain.Annotion", "GaoDe.Normal.Map", "GaoDe.Satellite.Map", "GaoDe.Satellite.Annotion", "GaoDe.Brief.Map", "Google.Normal.Map", "Google.Satellite.Map", "Google.Satellite.Annotion", "Geoq.Normal.Map", "Geoq.Normal.PurplishBlue", "Geoq.Normal.Gray", "Geoq.Normal.Warm", "Geoq.Theme.Hydro", "OSM.Normal.Map", "Baidu.Normal.Map", "Baidu.Satellite.Map", "Baidu.Satellite.Annotion", "BaiduV3.Normal.Map", "Tencent.Normal.Map", "Tencent.Satellite.Map", "Tencent.Terrain.Map", "Mapbox.Satellite.Map"];
+
+/** Tile types shipped with the library */
+export declare type BuiltinTileType = (typeof BUILTIN_TILE_TYPES)[number];
+
+export declare class CircleMeasure extends BaseMeasureTool {
+    protected readonly drawType = "circle";
+    protected measure(layer: L_2.Circle): MeasureGeometry;
+    protected anchor(result: MeasureResult): L_2.LatLng;
+    protected defaultText(label: MeasureLabel): string;
+    protected legacyValue(label: MeasureLabel): number;
+}
+
+/**
+ * Points that merge into counted bubbles when they would overlap.
+ *
+ * Clustering is a grid over the current zoom level: points falling into the same
+ * cell become one bubble at their average position. It is recomputed for the
+ * visible area on every move, which keeps it cheap for tens of thousands of points.
+ */
+export declare class ClusterLayer<T extends PointInput = PointInput> extends L_2.FeatureGroup {
+    private items;
+    private clusterOptions;
+    private canvas;
+    constructor(points: T[], options?: ClusterOptions<T>, canvas?: {
+        renderer?: L_2.Renderer;
+    });
+    /** Replace the data */
+    setPoints(points: T[]): this;
+    /** Bounds of all points, not just the ones currently drawn */
+    getBounds(): L_2.LatLngBounds;
+    onAdd(map: L_2.Map): this;
+    onRemove(map: L_2.Map): this;
+    private index;
+    private refresh;
+    private pointMarker;
+    private clusterMarker;
+}
+
+export declare interface ClusterOptions<T = PointInput> extends PointLayerOptions<T> {
+    /** Points closer than this (pixels) merge into one bubble. Default 60 */
+    clusterRadius?: number;
+    /** From this zoom level on, every point is shown on its own */
+    disableClusteringAtZoom?: number;
+    /** Called when a bubble is clicked. By default the map zooms in on it */
+    onClusterClick?: (points: T[], event: L_2.LeafletMouseEvent) => void;
+}
+
+/**
+ * Right-click menus for the map and for individual layers.
+ */
+export declare class ContextMenu {
+    private map;
+    private mapItems;
+    private bound;
+    private el;
+    constructor(map: L_2.Map);
+    /** Set the menu shown when right-clicking the map itself. Pass null to remove it */
+    setItems(items: ContextMenuItems | null): void;
+    /** Give a layer its own menu. Returns a function that removes it again */
+    bind(layer: L_2.Layer, items: ContextMenuItems): () => void;
+    unbind(layer: L_2.Layer): void;
+    /** Close the menu if it is open */
+    hide(): void;
+    destroy(): void;
+    private onMapContextMenu;
+    private onPointerDown;
+    private onKeyDown;
+    private open;
+    private renderItem;
+}
+
+export declare interface ContextMenuContext {
+    /** Where the right click happened */
+    latlng: L_2.LatLng;
+    containerPoint: L_2.Point;
+    /** The layer that was right-clicked, for menus bound to a layer */
+    layer?: L_2.Layer;
+    map: L_2.Map;
+}
+
+export declare type ContextMenuItem = {
+    text: string;
+    onClick?: (context: ContextMenuContext) => void;
+    disabled?: boolean;
+    /** Render as a destructive action */
+    danger?: boolean;
+}
+/** Separator */
+| '-';
+
+/** A fixed list, or a function building the list for each right click */
+export declare type ContextMenuItems = ContextMenuItem[] | ((context: ContextMenuContext) => ContextMenuItem[]);
+
+export declare class ControlManager {
+    private map;
+    private host?;
+    private controls;
+    private layers?;
+    private refreshLayers;
+    private refreshOverlays;
+    constructor(map: L_2.Map, host?: TileHost, layers?: LayerManager);
+    /**
+     * Add a control by type. Adding the same type again replaces the previous one.
+     */
+    add(type: 'layers', options: LayersControlOptions): L_2.Control;
+    add(type: 'overlays', options?: OverlaysControlOptions): L_2.Control;
+    add(type: 'attribution' | 'zoom' | 'scale', options?: ControlOptions & AttributionOptions): L_2.Control;
+    /** Base-map switcher: one button per entry, the current one highlighted */
+    private createLayersControl;
+    /** Switches for the layers registered in `smap.layer` */
+    private createOverlaysControl;
+    /**
+     * Remove a control by type
+     */
+    remove(type: string): void;
+    /**
+     * Remove all managed controls
+     */
+    removeAll(): void;
+}
+
+export declare interface ControlOptions {
+    position?: L_2.ControlPosition;
+    [key: string]: unknown;
+}
+
+export declare type ControlType = 'attribution' | 'zoom' | 'scale' | 'layers' | 'overlays';
+
+/**
+ * Coordinate system conversion utilities
+ * Supports: WGS-84, GCJ-02 (火星坐标), BD-09 (百度坐标)
+ */
+export declare interface Coord {
+    lng: number;
+    lat: number;
+}
+
+declare type CoordSystem = 'wgs84' | 'gcj02' | 'bd09';
+
+export declare type CoordType = 'wgs84' | 'gcj02' | 'bd09';
+
+/**
+ * Create a china tile layer from type string like "GaoDe.Normal.Map"
+ */
+export declare function createChinaTileLayer(type: string, options?: {
+    key?: string;
+    zIndex?: number;
+    [k: string]: any;
+}): L_2.TileLayer;
+
+/**
+ * Snapping to the vertices and edges of other shapes.
+ * A vertex wins over an edge: corners are what people aim for.
+ */
+export declare function createSnapper(map: L_2.Map, sources: () => L_2.Layer[], distance?: number): Snapper;
+
+export declare type DrawEvents = {
+    /** Drawing a shape has started */
+    drawstart: {
+        type: DrawType;
+    };
+    /** Drawing ended, whether a shape was finished or it was cancelled */
+    drawstop: {
+        type: DrawType;
+    };
+    /** A shape was finished */
+    created: {
+        layer: L_2.Layer;
+        type: DrawType;
+    };
+    /** A shape is being changed in edit mode: fired while dragging, and after an undo */
+    editing: {
+        layer: L_2.Layer;
+    };
+    /** Shapes were changed in edit mode and saved */
+    edited: {
+        layers: L_2.Layer[];
+    };
+    /** Shapes were removed */
+    removed: {
+        layers: L_2.Layer[];
+    };
+    /** Anything changed; carries the current content as GeoJSON */
+    change: GeoJSON.FeatureCollection;
+};
+
+export declare interface DrawOptions {
+    /** Style of drawn lines and areas */
+    shapeOptions?: L_2.PathOptions;
+    /** Icon of drawn markers. Defaults to a round dot */
+    markerIcon?: L_2.Icon | L_2.DivIcon;
+    /**
+     * Snap to the vertices and edges of the shapes already drawn, while drawing and
+     * editing. Pass an object to change the distance or to snap to other layers too.
+     */
+    snap?: boolean | SnapOptions;
+}
+
+/**
+ * Draw, edit and export shapes. Create it with `smap.createDraw()`.
+ */
+export declare class DrawTool {
+    /** Everything drawn or loaded lives in this group */
+    readonly group: L_2.FeatureGroup;
+    private map;
+    private options;
+    private emitter;
+    private session;
+    private editor;
+    private snapper;
+    /** @deprecated Nothing needs loading any more. Kept so existing calls keep working */
+    static preload(): Promise<void>;
+    constructor(map: L_2.Map, options?: DrawOptions);
+    /** Shape currently being drawn, or null */
+    get drawing(): DrawType | null;
+    /** Start drawing one shape. Drawing ends by itself when the shape is finished */
+    draw(type: DrawType): void;
+    /** Abandon the shape being drawn */
+    cancel(): void;
+    /** True while shapes can be dragged and reshaped */
+    get editing(): boolean;
+    /** Make every shape editable: drag vertices, move markers, resize rectangles and circles */
+    startEdit(): void;
+    /** True when there is a change to take back in edit mode */
+    get canUndo(): boolean;
+    /** Take back the last change made in edit mode (also Ctrl/Cmd+Z). Returns false when there is none */
+    undo(): boolean;
+    /** Leave edit mode, keeping (`save = true`) or discarding the changes */
+    finishEdit(save?: boolean): void;
+    getLayers(): L_2.Layer[];
+    /** Remove one shape */
+    remove(layer: L_2.Layer): void;
+    /** Remove every shape */
+    clear(): void;
+    /**
+     * Export everything as GeoJSON (WGS-84).
+     * A circle becomes a Point with `properties.radius` in metres.
+     */
+    toGeoJSON(): GeoJSON.FeatureCollection;
+    /**
+     * Load shapes from GeoJSON so they can be shown and edited.
+     * A Point with `properties.radius` becomes a circle.
+     */
+    load(geojson: GeoJSON.GeoJsonObject, options?: {
+        replace?: boolean;
+    }): void;
+    on<K extends keyof DrawEvents>(type: K, handler: (event: DrawEvents[K]) => void): void;
+    off<K extends keyof DrawEvents>(type: K, handler: (event: DrawEvents[K]) => void): void;
+    destroy(): void;
+    private emitChange;
+    private shapeOptions;
+    private markerIcon;
+}
+
+export declare type DrawType = 'marker' | 'polyline' | 'polygon' | 'rectangle' | 'circle';
+
+export declare interface ExportImageOptions {
+    /** Image format. Default 'image/png' */
+    type?: 'image/png' | 'image/jpeg' | 'image/webp';
+    /** Quality from 0 to 1, for JPEG and WebP */
+    quality?: number;
+    /** Pixels per CSS pixel. Defaults to the screen's ratio, at most 2 */
+    scale?: number;
+    /** Colour behind the tiles. Default '#ffffff' */
+    background?: string;
+    /** Draw measurement labels, cluster bubbles and drawn markers into the image. Default true */
+    labels?: boolean;
+    /**
+     * CSS selectors of further simple HTML elements to draw: boxes with a background,
+     * border, rounded corners and a line of text. Not for images or complex layouts.
+     */
+    include?: string[];
+    /** Longest wait (ms) for the base map to finish loading first. Default 8000 */
+    timeout?: number;
+}
+
+/** `auto` picks m² or km² by size; `ha` is hectares (公顷), `mu` is 亩 */
+export declare function formatArea(sqMeters: number, unit?: AreaUnit): string;
+
+/** `auto` picks metres or kilometres by size */
+export declare function formatLength(meters: number, unit?: LengthUnit): string;
+
+/** GCJ-02 → BD-09 */
+export declare function gcj02ToBd09(lng: number, lat: number): Coord;
+
+/** GCJ-02 → WGS-84 */
+export declare function gcj02ToWgs84(lng: number, lat: number): Coord;
+
+export declare interface GeocodeParams extends ServiceKeyParam {
+    /** Address to look up */
+    keyWord: string;
+}
+
+/** Area of a ring on the sphere, in square metres */
+export declare function geodesicArea(latlngs: L_2.LatLng[]): number;
+
+export declare function getCoordType(providerName: string): CoordType;
+
+/**
+ * HTML5 Geolocation API wrapper
+ */
+export declare function getLocation(options?: LocationOptions): Promise<LocationResult>;
+
+/** List every tile type currently available, including registered ones */
+export declare function getTileTypes(): string[];
+
+/** A label to put on the map */
+declare interface LabelSpec {
+    latlng: L_2.LatLng;
+    html: string;
+}
+
+export declare class LayerManager {
+    private map;
+    private registry;
+    private ownCanvas;
+    private listeners;
+    constructor(map: L_2.Map);
+    /** Be told when a layer is registered, removed, shown or hidden */
+    onChange(listener: () => void): void;
+    private changed;
+    /**
+     * Put a layer under management and add it to the map.
+     * An existing layer with the same id is removed first.
+     */
+    add<T extends L_2.Layer>(id: string, layer: T, options?: {
+        visible?: boolean;
+    }): T;
+    get<T extends L_2.Layer = L_2.Layer>(id: string): T | undefined;
+    has(id: string): boolean;
+    /** Ids of all managed layers, in insertion order */
+    ids(): string[];
+    isVisible(id: string): boolean;
+    /** Show a managed layer. Returns false when the id is unknown */
+    show(id: string): boolean;
+    /** Hide a managed layer without forgetting it. Returns false when the id is unknown */
+    hide(id: string): boolean;
+    /** Flip (or set) visibility. Returns the resulting visibility */
+    toggle(id: string, visible?: boolean): boolean;
+    /** Remove a managed layer from the map and forget it. Returns false when the id is unknown */
+    remove(id: string): boolean;
+    /** Remove every managed layer */
+    clear(): void;
+    /** Release everything, including the shared canvas. Called by `smap.destroy()` */
+    destroy(): void;
+    /**
+     * Renderer option for vector layers created here.
+     *
+     * Everything must end up on ONE canvas: Leaflet stacks a full-size <canvas> per
+     * renderer and only the top one receives mouse events, and a renderer is never
+     * removed from the map when its layers are. So: reuse the map's own canvas when
+     * it has one (`preferCanvas`, the default), otherwise share a single canvas.
+     */
+    private canvas;
+    private place;
+    /**
+     * Fetch GeoJSON from a GeoServer WFS endpoint
+     */
+    loadWFS(options: WFSOptions): Promise<any>;
+    /**
+     * Create a GeoJSON layer from data with optional styling
+     */
+    createGeoJsonLayer(data: GeoJSON.GeoJsonObject, style?: L_2.PathOptions): L_2.GeoJSON;
+    /**
+     * Load WFS data and add to map as a GeoJSON layer
+     */
+    addWFS(options: WFSOptions): Promise<L_2.GeoJSON>;
+    /**
+     * Create a WMS tile layer
+     */
+    createWMS(options: WMSOptions): L_2.TileLayer.WMS;
+    /**
+     * Create a WMS tile layer and add to map
+     */
+    addWMS(options: WMSOptions): L_2.TileLayer.WMS;
+    /**
+     * Build a mask that dims everything outside the given polygon(s).
+     * `getBounds()` of the result is the bounds of the highlighted region.
+     */
+    createMask(geojson: GeoJSON.GeoJsonObject, options?: MaskOptions): L_2.FeatureGroup;
+    /**
+     * Add a mask to the map. By default the view is fitted to the region.
+     */
+    addMask(geojson: GeoJSON.GeoJsonObject, options?: MaskOptions): L_2.FeatureGroup;
+    /**
+     * Build a layer of many points, drawn on canvas.
+     * Suitable for tens of thousands of points, where one marker per point would be too slow.
+     */
+    createPointLayer<T extends PointInput>(points: T[], options?: PointLayerOptions<T>): L_2.FeatureGroup;
+    /**
+     * Add a layer of many points to the map
+     */
+    addPoints<T extends PointInput>(points: T[], options?: PointLayerOptions<T>): L_2.FeatureGroup;
+    /**
+     * Build a layer of points that merge into counted bubbles when zoomed out.
+     * Use it when there are too many points to tell apart at low zoom.
+     */
+    createCluster<T extends PointInput>(points: T[], options?: ClusterOptions<T>): ClusterLayer<T>;
+    /**
+     * Add a clustered point layer to the map
+     */
+    addCluster<T extends PointInput>(points: T[], options?: ClusterOptions<T>): ClusterLayer<T>;
+}
+
+export declare interface LayersControlOptions {
+    position?: L_2.ControlPosition;
+    /** Base maps to choose from */
+    options: {
+        label: string;
+        /** One tile type, or several stacked (base + annotation) */
+        tileType: TileType | TileType[];
+    }[];
+}
+
+export declare type LengthUnit = 'auto' | 'm' | 'km';
+
+/**
+ * @deprecated Drawing no longer depends on leaflet-draw; there is nothing to load.
+ * Kept so existing `await loadLeafletDraw()` / `Tool.preload()` calls keep working.
+ */
+export declare function loadLeafletDraw(): Promise<void>;
+
+/**
+ * Dynamically load an external script. Deduplicates by URL.
+ */
+export declare function loadScript(src: string): Promise<void>;
+
+/**
+ * Dynamically load an external stylesheet. Deduplicates by URL.
+ */
+export declare function loadStyle(href: string): void;
+
+export declare interface LocateOptions extends LocationOptions {
+    /** Move the map to the position. Default true */
+    setView?: boolean;
+    /** Zoom to use when moving. Defaults to at least 16 */
+    zoom?: number;
+    /** Show the position and its accuracy on the map. Default true */
+    marker?: boolean;
+}
+
+export declare interface LocateResult extends LocationResult {
+    latlng: L_2.LatLng;
+}
+
+export declare interface LocationOptions {
+    timeout?: number;
+    enableHighAccuracy?: boolean;
+}
+
+export declare interface LocationResult {
+    latitude: number;
+    longitude: number;
+    /** Accuracy radius in metres */
+    accuracy: number;
+}
+
+export declare interface MaskOptions {
+    /** Register the mask under this id in `smap.layer` */
+    id?: string;
+    /** Colour of the dimmed area. Default '#000' */
+    fillColor?: string;
+    /** Opacity of the dimmed area. Default 0.5 */
+    fillOpacity?: number;
+    /** Draw the region's border. Default true */
+    outline?: boolean;
+    /** Border colour. Default '#3388ff' */
+    color?: string;
+    /** Border width. Default 2 */
+    weight?: number;
+    /** Fit the view to the region when added. Default true */
+    fit?: boolean;
+    /** Keep the map from being panned away from the region while the mask is shown. Default false */
+    restrict?: boolean;
+}
+
+export declare type MeasureEvents = {
+    /** Measuring started */
+    start: {
+        type: MeasureType;
+    };
+    /** Measuring ended. `completed` is false when it was cancelled */
+    stop: {
+        type: MeasureType;
+        completed: boolean;
+    };
+    /** A shape was finished */
+    created: MeasureResult;
+    /** A measurement was removed (delete button, `remove()` or `clearAll()`) */
+    removed: {
+        id: string;
+        type: MeasureType;
+    };
+    /** A measurement is being reshaped: fired while dragging, and after an undo */
+    updating: MeasureResult;
+    /** A measurement was reshaped in edit mode and saved */
+    updated: MeasureResult;
+    /** The tool was destroyed */
+    destroyed: {
+        type: MeasureType;
+    };
+};
+
+/** What a tool works out from a finished shape */
+declare type MeasureGeometry = Omit<MeasureResult, 'id' | 'type' | 'layer'>;
+
+/** What a label formatter is given */
+export declare type MeasureLabel = Omit<MeasureResult, 'id' | 'layer'> & {
+    /** True for an intermediate value, false for the final result */
+    partial: boolean;
+};
+
+export declare interface MeasureOptions {
+    /** Whether to show distance/area markers */
+    showMarker?: boolean;
+    /** Snap to earlier measurements (and to `layers`, if given) while drawing and editing */
+    snap?: boolean | SnapOptions;
+    /** Unit of distances in the default labels. Default 'auto' (m or km by size) */
+    lengthUnit?: LengthUnit;
+    /** Unit of areas in the default labels: 'auto', 'm2', 'km2', 'ha' (公顷) or 'mu' (亩). Default 'auto' */
+    areaUnit?: AreaUnit;
+    /**
+     * Custom text for the labels. Receives the measurement; `partial` is true for
+     * the running totals shown while a line is being drawn.
+     */
+    formatLabel?: (label: MeasureLabel) => string;
+    /**
+     * @deprecated Use `formatLabel`. What this receives depends on the tool: the
+     * distance for a line, the radius for a circle, the vertices for an area.
+     */
+    valueFormatter?: (value: number | L_2.LatLng[]) => string;
+    /** Style of the measured lines and areas */
+    shapeOptions?: L_2.PathOptions;
+    /** Icon for draw vertices */
+    icon?: L_2.DivIcon;
+}
+
+/** Outcome of one finished measurement */
+export declare interface MeasureResult {
+    /** Id of this measurement, usable with `tool.remove(id)` */
+    id: string;
+    type: MeasureType;
+    /** Total length in metres (polyline) */
+    distance?: number;
+    /** Area in square metres (polygon, rectangle, circle) */
+    area?: number;
+    /** Length of the outline in metres (polygon, rectangle, circle) */
+    perimeter?: number;
+    /** Radius in metres (circle) */
+    radius?: number;
+    /** Centre (circle) */
+    center?: L_2.LatLng;
+    /** Vertices of the shape; for a circle, its centre */
+    latlngs: L_2.LatLng[];
+    /** The drawn Leaflet layer */
+    layer: L_2.Layer;
+}
+
+export declare interface MeasureTool {
+    readonly type: MeasureType;
+    /** True while a measurement is being drawn */
+    readonly measuring: boolean;
+    /** True while the results can be reshaped */
+    readonly editing: boolean;
+    /** Let the user reshape the finished measurements; values and labels follow live */
+    startEdit(): void;
+    /** Leave edit mode, keeping (default) or discarding the changes */
+    finishEdit(save?: boolean): void;
+    /** Take back the last change made in edit mode. Returns false when there is none */
+    undo(): boolean;
+    /** Change options afterwards, e.g. the units; labels on the map are redrawn */
+    setOptions(options: Partial<MeasureOptions>): void;
+    enable(): void;
+    disable(): void;
+    remove(id: string): void;
+    clearAll(): void;
+    destroy(): void;
+    /** Finished measurements still on the map, oldest first */
+    getResults(): MeasureResult[];
+    on<K extends keyof MeasureEvents>(type: K, handler: (event: MeasureEvents[K]) => void): void;
+    off<K extends keyof MeasureEvents>(type: K, handler: (event: MeasureEvents[K]) => void): void;
+}
+
+export declare type MeasureType = 'polyline' | 'polygon' | 'circle' | 'rectangle';
+
+export declare interface OverlaysControlOptions {
+    position?: L_2.ControlPosition;
+    /** Heading shown above the list */
+    title?: string;
+    /**
+     * Layers to list, by the id they are registered under in `smap.layer`.
+     * Omit to list every registered layer, labelled by its id.
+     */
+    items?: {
+        id: string;
+        label: string;
+    }[];
+}
+
+/** Length of a path in metres */
+export declare function pathLength(latlngs: L_2.LatLng[]): number;
+
+/** A point for `addPoints()`: `[lat, lng]`, or any object with `lat` and `lng` */
+export declare type PointInput = L_2.LatLngExpression | {
+    lat: number;
+    lng: number;
+};
+
+export declare interface PointLayerOptions<T = PointInput> {
+    /** Register the layer under this id in `smap.layer` */
+    id?: string;
+    /** Radius in pixels. Default 4 */
+    radius?: number;
+    /** Style for all points, or a function returning the style of each one */
+    style?: L_2.CircleMarkerOptions | ((point: T, index: number) => L_2.CircleMarkerOptions);
+    /** Tooltip text for a point */
+    tooltip?: (point: T) => string;
+    /** Called when a point is clicked */
+    onClick?: (point: T, event: L_2.LeafletMouseEvent) => void;
+}
+
+export declare class PolygonMeasure extends RingAreaMeasure {
+    protected readonly drawType = "polygon";
+}
+
+/** Distance along a line, with the running total shown at each vertex */
+export declare class PolylineMeasure extends BaseMeasureTool {
+    protected readonly drawType = "polyline";
+    protected measure(layer: L_2.Polyline): MeasureGeometry;
+    protected anchor(result: MeasureResult): L_2.LatLng;
+    protected defaultText(label: MeasureLabel): string;
+    protected legacyValue(label: MeasureLabel): number;
+    protected draftLabels(latlngs: L_2.LatLng[]): LabelSpec[];
+    protected resultLabels(result: MeasureResult): LabelSpec[];
+    /** "起点" on the first vertex, the distance so far on the others */
+    private nodeLabels;
+}
+
+/** Provider definitions: Provider.MapName.MapType -> URL template */
+export declare const providers: Record<string, any>;
+
+export declare class RectangleMeasure extends RingAreaMeasure {
+    protected readonly drawType = "rectangle";
+}
+
+/**
+ * Register a custom tile provider (or override a built-in one).
+ * Its layers are then addressable as `"<name>.<group>.<type>"`.
+ *
+ * @example
+ * ```ts
+ * registerProvider('Intranet', {
+ *   layers: { Satellite: { Map: 'https://tiles.example.com/{z}/{x}/{y}.png' } },
+ *   coordType: 'gcj02',
+ * })
+ * smap.setTileLayer('Intranet.Satellite.Map')
+ * ```
+ */
+export declare function registerProvider(name: string, definition: TileProviderDefinition): void;
+
+export declare interface ReverseGeocodeParams extends ServiceKeyParam {
+    /** Longitude */
+    lon: number;
+    /** Latitude */
+    lat: number;
+    ver?: number;
+}
+
+/** Shared by the tools that measure the area of a ring: polygon and rectangle */
+declare abstract class RingAreaMeasure extends BaseMeasureTool {
+    protected measure(layer: L_2.Polygon): MeasureGeometry;
+    protected anchor(result: MeasureResult): L_2.LatLng;
+    protected defaultText(label: MeasureLabel): string;
+    protected legacyValue(label: MeasureLabel): L_2.LatLng[];
+}
+
+export declare interface SearchParams extends ServiceKeyParam {
+    /** Search keyword */
+    keyword: string;
+    /** Number of results to return. Default 10 */
+    count?: number;
+    /** Start index. Default 0 */
+    start?: number;
+    /** TianDiTu query type. Default 1 (keyword search) */
+    queryType?: number;
+    /** Zoom level used for ranking. Defaults to the map's current zoom */
+    level?: number;
+    /** Search extent "minLng,minLat,maxLng,maxLat". Defaults to the map's current view */
+    mapBound?: string;
+}
+
+/**
+ * TianDiTu web services.
+ *
+ * `smap.service` is bound to its map and to `tdtKey`, so calls need neither.
+ * A standalone `new ServiceClient()` must be given `tk` (and, for `search`,
+ * a map or `mapBound` + `level`) on every call.
+ */
+export declare class ServiceClient {
+    private context;
+    constructor(context?: ServiceContext);
+    /**
+     * POI keyword search within the map's current view
+     */
+    search(params: SearchParams): Promise<TdtSearchResult>;
+    /** @deprecated Pass only `params`; `smap.service` already knows its map */
+    search(map: L_2.Map, params: SearchParams): Promise<TdtSearchResult>;
+    /**
+     * Geocoding: address → coordinates
+     */
+    geocode(params: GeocodeParams): Promise<TdtGeocodeResult>;
+    /**
+     * Reverse geocoding: coordinates → address
+     */
+    reverseGeocode(params: ReverseGeocodeParams): Promise<TdtReverseGeocodeResult>;
+    /**
+     * Administrative district query (TianDiTu v2 API)
+     */
+    getAdministrative(params: AdministrativeParams): Promise<TdtAdministrativeResult>;
+    /**
+     * Get location by IP (no key required)
+     */
+    getLocationByIp(): Promise<TdtIpLocationResult>;
+    private resolveKey;
+    private request;
+}
+
+export declare interface ServiceContext {
+    /** Map whose current view scopes `search()` */
+    map?: L_2.Map;
+    /** Default TianDiTu key, used when a call does not pass `tk` */
+    key?: string | (() => string | undefined);
+}
+
+/** Fields shared by every TianDiTu service call */
+declare interface ServiceKeyParam {
+    /** TianDiTu API key. Defaults to the map's `tdtKey` */
+    tk?: string;
+}
+
+/**
+ * Texts shown next to the cursor while drawing and editing.
+ * Assign to the fields to translate or reword them.
+ */
+export declare const sketchText: {
+    marker: {
+        start: string;
+    };
+    polyline: {
+        start: string;
+        next: string;
+        finish: string;
+    };
+    polygon: {
+        start: string;
+        next: string;
+        finish: string;
+    };
+    rectangle: {
+        start: string;
+        finish: string;
+    };
+    circle: {
+        start: string;
+        finish: string;
+        radius: string;
+    };
+    /** {n} is replaced by the number of points required */
+    tooFewPoints: string;
+    cancel: string;
+    edit: string;
+};
+
+/**
+ * Main map class — supports multi-instance, fully typed API
+ *
+ * @example
+ * ```ts
+ * const map = new SMap('#map', {
+ *   tileType: ['TianDiTu.Normal.Map', 'TianDiTu.Normal.Annotion'],
+ *   center: [31.82, 117.23],
+ *   zoom: 12,
+ *   tdtKey: 'your-key',
+ * })
+ * ```
+ */
+export declare class SMap {
+    /** The underlying Leaflet map instance */
+    readonly instance: L_2.Map;
+    /** Layer management (registry, WFS/WMS, mask, points) */
+    readonly layer: LayerManager;
+    /** Control management (zoom, scale, attribution, base-map switcher) */
+    readonly control: ControlManager;
+    /** TianDiTu web services (search, geocode, etc.) */
+    readonly service: ServiceClient;
+    /** Right-click menus for the map and for layers */
+    readonly contextMenu: ContextMenu;
+    private tileLayers;
+    private tileTypes;
+    private tileChangeHandlers;
+    private drawTools;
+    private locationLayer;
+    private measureTools;
+    private sharedMeasures;
+    private emitter;
+    private options;
+    private tileObserver;
+    private destroyed;
+    constructor(container: string | HTMLElement, options?: SMapOptions);
+    /**
+     * Replace current tile layers with new type(s)
+     */
+    setTileLayer(type: TileType | TileType[]): L_2.TileLayer[];
+    /**
+     * Add additional tile layer(s) without removing existing ones
+     */
+    addTileLayer(type: TileType | TileType[]): L_2.TileLayer[];
+    private notifyTileChange;
+    /**
+     * Pick the credential that belongs to the tile provider
+     * (TianDiTu → tdtKey, Mapbox → mapboxToken, others → provider default)
+     */
+    private resolveKey;
+    /**
+     * Remove all tile layers
+     */
+    clearTileLayers(): void;
+    /**
+     * Types of the current tile layers, bottom first
+     */
+    getTileType(): TileType[];
+    /**
+     * Get current tile layers
+     */
+    getTileLayers(): L_2.TileLayer[];
+    /**
+     * Create a new measure tool.
+     *
+     * Every call creates another tool; keep the one you get and reuse it, or call
+     * its `destroy()` when done. For one shared tool per type use `getMeasure()`.
+     */
+    createMeasure(type: MeasureType, options?: MeasureOptions): Promise<MeasureTool>;
+    /**
+     * The map's shared measure tool of a type, created on first use.
+     * `options` only apply when it is created.
+     */
+    getMeasure(type: MeasureType, options?: MeasureOptions): Promise<MeasureTool>;
+    /**
+     * Destroy all measure tools
+     */
+    clearMeasures(): void;
+    /**
+     * Create a tool for drawing and editing shapes (loads leaflet-draw on first call)
+     */
+    createDraw(options?: DrawOptions): Promise<DrawTool>;
+    /**
+     * Locate the user with the browser's geolocation, show the position and move there.
+     * Rejects when permission is denied or the position is unavailable.
+     */
+    locate(options?: LocateOptions): Promise<LocateResult>;
+    /** Remove the position shown by `locate()` */
+    clearLocation(): void;
+    /**
+     * The map as currently shown, as an image.
+     *
+     * Contains the base map, vector shapes (lines, areas, circles, point layers) and
+     * the library's own labels: measurement labels, cluster bubbles, drawn markers.
+     * Other HTML — custom marker icons, popups, controls — is not part of it unless
+     * named in `include`. Rejects if a tile server forbids cross-origin reading.
+     */
+    exportImage(options?: ExportImageOptions): Promise<Blob>;
+    /** Export the map and save it as a file */
+    downloadImage(filename?: string, options?: ExportImageOptions): Promise<void>;
+    /**
+     * Fit map to bounds of a layer
+     */
+    fitToLayer(layer: L_2.Layer): void;
+    /**
+     * Set map view
+     */
+    setView(center: [number, number], zoom?: number): void;
+    on<K extends keyof SMapEvents>(type: K, handler: (event: SMapEvents[K]) => void): void;
+    off<K extends keyof SMapEvents>(type: K, handler: (event: SMapEvents[K]) => void): void;
+    /**
+     * Destroy the map instance and clean up all resources
+     */
+    destroy(): void;
+}
+
+export declare type SMapEvents = {
+    loaded: L_2.Map;
+    tileLoaded: L_2.TileLayer[];
+    /** A measurement was finished by any tool created through `createMeasure()` */
+    'measure:created': MeasureResult;
+    /** A measurement was removed */
+    'measure:removed': {
+        id: string;
+        type: MeasureType;
+    };
+    /** A measurement is being reshaped in edit mode */
+    'measure:updating': MeasureResult;
+    /** A measurement was reshaped in edit mode and saved */
+    'measure:updated': MeasureResult;
+    /** A measure tool started drawing */
+    'measure:start': {
+        type: MeasureType;
+    };
+    /** A measure tool stopped drawing. `completed` is false when it was cancelled */
+    'measure:stop': {
+        type: MeasureType;
+        completed: boolean;
+    };
+};
+
+export declare interface SMapOptions {
+    /** Map container element ID or HTMLElement */
+    container?: string | HTMLElement;
+    /** Tile layer type(s), e.g. "GaoDe.Normal.Map" or ["TianDiTu.Normal.Map", "TianDiTu.Normal.Annotion"] */
+    tileType?: TileType | TileType[];
+    /** Map center [lat, lng] */
+    center?: [number, number];
+    /** Initial zoom level */
+    zoom?: number;
+    /** Minimum zoom level */
+    minZoom?: number;
+    /** Maximum zoom level */
+    maxZoom?: number;
+    /** Maximum native zoom */
+    maxNativeZoom?: number;
+    /** Whether to use Canvas renderer */
+    preferCanvas?: boolean;
+    /** TianDiTu API key */
+    tdtKey?: string;
+    /** Mapbox access token */
+    mapboxToken?: string;
+    /** Any additional Leaflet map options */
+    [key: string]: unknown;
+}
+
+export declare interface SnapOptions {
+    /** How close (pixels) the cursor has to be. Default 12 */
+    distance?: number;
+    /** Other layers to snap to, besides the tool's own shapes */
+    layers?: L_2.Layer[] | (() => L_2.Layer[]);
+}
+
+/** Returns the position to use: the nearest vertex or edge if one is close, else the input */
+export declare type Snapper = (latlng: L_2.LatLng, exclude?: L_2.Layer) => L_2.LatLng;
+
+export declare interface TdtAdministrativeResult {
+    /** 200 on success */
+    status: number;
+    message: string;
+    data?: {
+        district: TdtDistrict[];
+        suggestion: unknown[];
+    };
+    [key: string]: unknown;
+}
+
+export declare interface TdtDistrict {
+    /** 9-digit district code, e.g. "156340100" */
+    gb: string;
+    /** Parent district code */
+    pgb: string;
+    name: string;
+    center: {
+        lng: number;
+        lat: number;
+    };
+    level: number;
+    /** WKT geometry, present when `extensions` is true */
+    boundary?: string;
+    /** Present when `childLevel` > 0 */
+    children?: TdtDistrict[];
+}
+
+export declare interface TdtGeocodeResult {
+    /** "0" on success */
+    status: string;
+    msg: string;
+    location?: {
+        /** Longitude, as a string */
+        lon: string;
+        /** Latitude, as a string */
+        lat: string;
+        level?: string;
+        score?: number;
+        keyWord?: string;
+    };
+    [key: string]: unknown;
+}
+
+export declare interface TdtIpLocationResult {
+    code: number;
+    msg: string;
+    data?: {
+        country?: string;
+        province?: string;
+        city?: string;
+        /** Administrative code */
+        gb?: string;
+        /** Latitude, as a string */
+        lat?: string;
+        /** Longitude, as a string */
+        lng?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+
+export declare interface TdtPoi {
+    name: string;
+    address?: string;
+    phone?: string;
+    poiType?: string;
+    source?: string;
+    hotPointID?: string;
+    /** "lng,lat" */
+    lonlat: string;
+    [key: string]: unknown;
+}
+
+export declare interface TdtReverseGeocodeResult {
+    /** "0" on success */
+    status: string;
+    msg: string;
+    result?: {
+        formatted_address: string;
+        location: {
+            lon: number;
+            lat: number;
+        };
+        addressComponent: {
+            nation?: string;
+            province?: string;
+            province_code?: string;
+            city?: string;
+            city_code?: string;
+            county?: string;
+            county_code?: string;
+            town?: string;
+            town_code?: string;
+            road?: string;
+            road_distance?: number;
+            address?: string;
+            address_distance?: number;
+            address_position?: string;
+            poi?: string;
+            poi_distance?: number;
+            poi_position?: string;
+        };
+    };
+    [key: string]: unknown;
+}
+
+export declare interface TdtSearchResult {
+    /** Total number of matches */
+    count?: number;
+    resultType?: number;
+    keyWord?: string;
+    /** Present when the search matched POIs */
+    pois?: TdtPoi[];
+    status: {
+        infocode: number;
+        cndesc: string;
+    };
+    [key: string]: unknown;
+}
+
+/** What the base-map switcher needs from the map it belongs to */
+declare interface TileHost {
+    setTileLayer(type: TileType | TileType[]): unknown;
+    getTileType(): TileType[];
+    onTileChange(handler: () => void): void;
+}
+
+/** Definition passed to `registerProvider()` */
+export declare interface TileProviderDefinition {
+    /**
+     * group → type → URL template, addressed as `"<provider>.<group>.<type>"`.
+     * Placeholders: `{s}` subdomain, `{x}` `{y}` `{z}`, `{-y}` inverted y, `{key}`.
+     */
+    layers: Record<string, Record<string, string>>;
+    /** Values substituted for `{s}` */
+    subdomains?: string[];
+    /** Coordinate system of the tiles. Non-WGS-84 tiles are shifted to line up with WGS-84 data. Default 'wgs84' */
+    coordType?: CoordType;
+    /** Tiles use TMS (inverted y) numbering */
+    tms?: boolean;
+    /** Value substituted for `{key}` */
+    key?: string;
+}
+
+/**
+ * Tile type string, e.g. "GaoDe.Normal.Map".
+ * Built-in types autocomplete; any other string is accepted for providers
+ * added through `registerProvider()`.
+ */
+export declare type TileType = BuiltinTileType | (string & {});
+
+/** Convert one coordinate between any two of WGS-84, GCJ-02 and BD-09 */
+export declare function transformCoord(lng: number, lat: number, from: CoordSystem, to: CoordSystem): Coord;
+
+/**
+ * Convert every coordinate in a GeoJSON object. Returns a deep copy; the input is not modified.
+ * Typical use: data received in GCJ-02 or BD-09 → WGS-84 before putting it on the map.
+ */
+export declare function transformGeoJSON<T>(geojson: T, from: CoordSystem, to: CoordSystem): T;
+
+export declare interface WFSOptions {
+    url: string;
+    layer: string;
+    /** Register the layer under this id in `smap.layer` */
+    id?: string;
+    style?: L_2.PathOptions;
+    outputFormat?: string;
+    [key: string]: unknown;
+}
+
+/** WGS-84 → BD-09 */
+export declare function wgs84ToBd09(lng: number, lat: number): Coord;
+
+/** WGS-84 → GCJ-02 */
+export declare function wgs84ToGcj02(lng: number, lat: number): Coord;
+
+export declare interface WMSOptions {
+    url: string;
+    layer: string;
+    /** Register the layer under this id in `smap.layer` */
+    id?: string;
+    format?: string;
+    transparent?: boolean;
+    crs?: L_2.CRS;
+    [key: string]: unknown;
+}
+
+export { }