@maptiler/geocoding-control 1.4.2-dev.2 → 2.0.0-rc.1

package/svelte/MapLibreBasedGeocodingControl.js

@@ -1,70 +1,178 @@
 import GeocodingControlComponent from "./GeocodingControl.svelte";
-import { createMapLibreGlMapController } from "./maplibregl-controller";
-export { createMapLibreGlMapController } from "./maplibregl-controller";
-export class MapLibreBasedGeocodingControl extends EventTarget {
-    #gc;
-    #options;
-    constructor(options = {}) {
-        super();
-        this.#options = options;
+import { createMapLibreGlMapController, } from "./maplibregl-controller";
+export { createMapLibreGlMapController, } from "./maplibregl-controller";
+export function crateClasses(Evented, maplibreGl, getExtraProps) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const _keysMatch = true;
+    // NOTE We can't use Maplibre `Event` - see https://github.com/maplibre/maplibre-gl-js/issues/5015
+    class Event {
+        type;
+        target;
+        constructor(target, type) {
+            this.type = type;
+            this.target = target;
+        }
     }
-    onAddInt(map) {
-        const div = document.createElement("div");
-        div.className =
-            "mapboxgl-ctrl-geocoder mapboxgl-ctrl maplibregl-ctrl-geocoder maplibregl-ctrl mapboxgl-ctrl-group";
-        const { marker, showResultMarkers, flyTo, fullGeometryStyle, ...restOptions } = this.#options;
-        const flyToOptions = typeof flyTo === "boolean" ? {} : flyTo;
-        const extraConfig = this.getExtraProps(map, div);
-        const mapController = createMapLibreGlMapController(map, this.getMapLibreGl(), marker, showResultMarkers, flyToOptions, flyToOptions, fullGeometryStyle);
-        const props = {
-            mapController,
-            flyTo: flyTo === undefined ? true : !!flyTo,
-            apiKey: "", // just to satisfy apiKey; TODO find a better solution
-            ...extraConfig,
-            ...restOptions,
-        };
-        if (!props.apiKey) {
-            throw new Error("no apiKey provided");
-        }
-        this.#gc = new GeocodingControlComponent({ target: div, props });
-        for (const eventName of [
-            "select",
-            "pick",
-            "featuresListed",
-            "featuresMarked",
-            "response",
-            "optionsVisibilityChange",
-            "reverseToggle",
-            "queryChange",
-        ]) {
-            this.#gc.$on(eventName, (event) => this.dispatchEvent(event));
-        }
-        return div;
+    class SelectEvent extends Event {
+        feature;
+        constructor(target, details) {
+            super(target, "select");
+            Object.assign(this, details);
+        }
     }
-    setOptions(options) {
-        this.#options = options;
-        const { marker, showResultMarkers, flyTo, fullGeometryStyle, ...restOptions } = this.#options;
-        this.#gc?.$set(restOptions);
+    class FeaturesListedEvent extends Event {
+        features;
+        constructor(target, features) {
+            super(target, "featureslisted");
+            this.features = features;
+        }
     }
-    setQuery(value, submit = true) {
-        this.#gc?.setQuery(value, submit);
+    class FeaturesMarkedEvent extends Event {
+        features;
+        constructor(target, features) {
+            super(target, "featuresmarked");
+            this.features = features;
+        }
     }
-    clearMap() {
-        this.#gc?.clearMap();
+    class OptionsVisibilityChangeEvent extends Event {
+        optionsVisible;
+        constructor(target, optionsVisible) {
+            super(target, "optionsvisibilitychange");
+            this.optionsVisible = optionsVisible;
+        }
     }
-    clearList() {
-        this.#gc?.clearList();
+    class PickEvent extends Event {
+        feature;
+        constructor(target, feature) {
+            super(target, "pick");
+            this.feature = feature;
+        }
     }
-    setReverseMode(value) {
-        this.#gc?.$set({ reverseActive: value });
+    class QueryChangeEvent extends Event {
+        query;
+        constructor(target, query) {
+            super(target, "querychange");
+            this.query = query;
+        }
     }
-    focus() {
-        this.#gc?.focus();
+    class ResponseEvent extends Event {
+        url;
+        featureCollection;
+        constructor(target, url, featureCollection) {
+            super(target, "response");
+            this.url = url;
+            this.featureCollection = featureCollection;
+        }
     }
-    blur() {
-        this.#gc?.blur();
+    class ReverseToggleEvent extends Event {
+        reverse;
+        constructor(target, reverse) {
+            super(target, "reversetoggle");
+            this.reverse = reverse;
+        }
     }
-    onRemove() {
-        this.#gc?.$destroy();
+    class MapLibreBasedGeocodingControl extends Evented {
+        #gc;
+        #options;
+        constructor(options = {}) {
+            super();
+            this.#options = options;
+        }
+        onAddInt(map) {
+            const div = document.createElement("div");
+            div.className =
+                "mapboxgl-ctrl-geocoder mapboxgl-ctrl maplibregl-ctrl-geocoder maplibregl-ctrl mapboxgl-ctrl-group";
+            const { marker, showResultMarkers, flyTo, fullGeometryStyle, ...restOptions } = this.#options;
+            const flyToOptions = typeof flyTo === "boolean" ? {} : flyTo;
+            const mapController = createMapLibreGlMapController(map, maplibreGl, marker, showResultMarkers, flyToOptions, flyToOptions, fullGeometryStyle, restOptions.showFullGeometry === "polygon-with-marker");
+            const props = {
+                mapController,
+                flyTo: flyTo === undefined ? true : !!flyTo,
+                apiKey: "", // just to satisfy apiKey; TODO find a better solution
+                ...getExtraProps?.(map, div),
+                ...restOptions,
+            };
+            if (!props.apiKey) {
+                throw new Error("no apiKey provided");
+            }
+            this.#gc = new GeocodingControlComponent({ target: div, props });
+            this.#gc.$on("select", (event) => {
+                this.fire(new SelectEvent(this, event.detail));
+            });
+            this.#gc.$on("pick", (event) => {
+                this.fire(new PickEvent(this, event.detail.feature));
+            });
+            this.#gc.$on("featureslisted", (event) => {
+                this.fire(new FeaturesListedEvent(this, event.detail.features));
+            });
+            this.#gc.$on("featuresmarked", (event) => {
+                this.fire(new FeaturesMarkedEvent(this, event.detail.features));
+            });
+            this.#gc.$on("response", (event) => {
+                this.fire(new ResponseEvent(this, event.detail.url, event.detail.featureCollection));
+            });
+            this.#gc.$on("optionsvisibilitychange", (event) => {
+                this.fire(new OptionsVisibilityChangeEvent(this, event.detail.optionsVisible));
+            });
+            this.#gc.$on("reversetoggle", (event) => {
+                this.fire(new ReverseToggleEvent(this, event.detail.reverse));
+            });
+            this.#gc.$on("querychange", (event) => {
+                this.fire(new QueryChangeEvent(this, event.detail.query));
+            });
+            return div;
+        }
+        on(type, listener) {
+            return super.on(type, listener);
+        }
+        once(type, listener) {
+            return super.once(type, listener);
+        }
+        off(type, listener) {
+            return super.off(type, listener);
+        }
+        listens(type) {
+            return super.listens(type);
+        }
+        setOptions(options) {
+            this.#options = options;
+            const { marker, showResultMarkers, flyTo, fullGeometryStyle, ...restOptions } = this.#options;
+            this.#gc?.$set(restOptions);
+        }
+        setQuery(value, submit = true) {
+            this.#gc?.setQuery(value, submit);
+        }
+        clearMap() {
+            this.#gc?.clearMap();
+        }
+        clearList() {
+            this.#gc?.clearList();
+        }
+        setReverseMode(value) {
+            this.#gc?.$set({ reverseActive: value });
+        }
+        focus() {
+            this.#gc?.focus();
+        }
+        blur() {
+            this.#gc?.blur();
+        }
+        onRemove() {
+            this.#gc?.$destroy();
+        }
     }
+    const events = {
+        SelectEvent,
+        FeaturesListedEvent,
+        FeaturesMarkedEvent,
+        OptionsVisibilityChangeEvent,
+        PickEvent,
+        QueryChangeEvent,
+        ResponseEvent,
+        ReverseToggleEvent,
+    };
+    return {
+        MapLibreBasedGeocodingControl,
+        events,
+    };
 }

package/svelte/leaflet-controller.d.ts

@@ -1,6 +1,6 @@
 import * as L from "leaflet";
 import type { BBox, Feature, MapEvent, Position } from "./types";
-export declare function createLeafletMapController(map: L.Map, marker?: boolean | L.MarkerOptions, showResultMarkers?: boolean | L.MarkerOptions, flyToOptions?: L.ZoomPanOptions, flyToBounds?: L.FitBoundsOptions, fullGeometryStyle?: L.PathOptions | L.StyleFunction): {
+export declare function createLeafletMapController(map: L.Map, marker?: boolean | null | L.MarkerOptions | ((map: L.Map, feature?: Feature) => L.Marker | undefined | null), showResultMarkers?: boolean | null | L.MarkerOptions | ((map: L.Map, feature: Feature) => L.Marker | undefined | null), flyToOptions?: L.ZoomPanOptions | null, flyToBounds?: L.FitBoundsOptions | null, fullGeometryStyle?: null | boolean | L.PathOptions | L.StyleFunction, showPolyMarker?: boolean): {
     setEventHandler(handler: undefined | ((e: MapEvent) => void)): void;
     flyTo(center: Position, zoom?: number): void;
     fitBounds(bbox: BBox, padding: number, maxZoom?: number): void;

package/svelte/leaflet-controller.js

@@ -6,7 +6,7 @@ import * as L from "leaflet";
 import { unwrapBbox } from "./geoUtils";
 import MarkerIcon from "./MarkerIcon.svelte";
 import { setMask } from "./mask";
-export function createLeafletMapController(map, marker = true, showResultMarkers = true, flyToOptions = {}, flyToBounds = {}, fullGeometryStyle = (feature) => {
+const defaultFullGeometryStyle = (feature) => {
     const type = feature?.geometry?.type;
     const weight = feature?.properties?.isMask
         ? 0
@@ -21,13 +21,18 @@ export function createLeafletMapController(map, marker = true, showResultMarkers
         dashArray: [weight, weight],
         lineCap: "butt",
     };
-}) {
+};
+export function createLeafletMapController(map, marker = true, showResultMarkers = true, flyToOptions = {}, flyToBounds = {}, fullGeometryStyle = defaultFullGeometryStyle, showPolyMarker = false) {
     let eventHandler;
     const markers = [];
     let selectedMarker;
     let reverseMarker;
     const resultLayer = L.geoJSON(undefined, {
-        style: fullGeometryStyle,
+        style: fullGeometryStyle === true
+            ? defaultFullGeometryStyle
+            : fullGeometryStyle === false
+                ? undefined
+                : (fullGeometryStyle ?? undefined),
         interactive: false,
     }).addTo(map);
     const handleMapClick = (e) => {
@@ -93,16 +98,18 @@ export function createLeafletMapController(map, marker = true, showResultMarkers
                 }
             }
             else if (latLng) {
-                reverseMarker = (typeof marker === "object"
-                    ? new L.Marker(latLng, marker)
-                    : createMarker(latLng)).addTo(map);
-                reverseMarker.getElement()?.classList.add("marker-reverse");
+                if (marker instanceof Function) {
+                    reverseMarker = marker(map) ?? undefined;
+                }
+                else {
+                    reverseMarker = (typeof marker === "object"
+                        ? new L.Marker(latLng, marker)
+                        : createMarker(latLng)).addTo(map);
+                    reverseMarker.getElement()?.classList.add("marker-reverse");
+                }
             }
         },
         setMarkers(markedFeatures, picked) {
-            if (!marker) {
-                return;
-            }
             function setData(data) {
                 resultLayer.clearLayers();
                 if (data) {
@@ -170,10 +177,21 @@ export function createLeafletMapController(map, marker = true, showResultMarkers
                     setData(picked);
                     return; // no pin for (multi)linestrings
                 }
-                const pos = [picked.center[1], picked.center[0]];
-                markers.push((typeof marker === "object"
-                    ? new L.Marker(pos, marker)
-                    : createMarker(pos)).addTo(map));
+                if (!showPolyMarker && picked.geometry.type !== "Point") {
+                    return;
+                }
+                if (marker instanceof Function) {
+                    const m = marker(map, picked);
+                    if (m) {
+                        markers.push(m.addTo(map));
+                    }
+                }
+                else if (marker) {
+                    const pos = [picked.center[1], picked.center[0]];
+                    markers.push(typeof marker === "object"
+                        ? new L.Marker(pos, marker)
+                        : createMarker(pos).addTo(map));
+                }
             }
             if (showResultMarkers) {
                 for (const feature of markedFeatures ?? []) {
@@ -184,16 +202,24 @@ export function createLeafletMapController(map, marker = true, showResultMarkers
                         feature.center[1],
                         feature.center[0],
                     ];
-                    const marker = typeof showResultMarkers === "object"
-                        ? new L.Marker(pos, showResultMarkers)
-                        : createMarker(pos, true);
-                    marker
-                        .addTo(map)
-                        .bindTooltip(feature.place_type[0] === "reverse"
-                        ? feature.place_name
-                        : feature.place_name.replace(/,.*/, ""), {
-                        direction: "top",
-                    });
+                    let marker;
+                    if (showResultMarkers instanceof Function) {
+                        marker = showResultMarkers(map, feature);
+                        if (!marker) {
+                            continue;
+                        }
+                    }
+                    else {
+                        marker = (typeof showResultMarkers === "object"
+                            ? new L.Marker(pos, showResultMarkers)
+                            : createMarker(pos, true))
+                            .addTo(map)
+                            .bindTooltip(feature.place_type[0] === "reverse"
+                            ? feature.place_name
+                            : feature.place_name.replace(/,.*/, ""), {
+                            direction: "top",
+                        });
+                    }
                     const element = marker.getElement();
                     if (element) {
                         element.addEventListener("click", (e) => {

package/svelte/leaflet.d.ts

@@ -1,34 +1,92 @@
 import * as L from "leaflet";
-import type { ControlOptions } from "./types";
+import type { ControlOptions, DispatcherType, Feature } from "./types";
 export { createLeafletMapController } from "./leaflet-controller";
 type LeafletControlOptions = ControlOptions & L.ControlOptions & {
     /**
-     * If `true`, a [Marker](https://leafletjs.com/reference.html#marker) will be added to the map at the location of the user-selected result using a default set of Marker options.
-     * If the value is an object, the marker will be constructed using these options.
-     * If `false`, no marker will be added to the map.
+     * Marker to be added to the map at the location of the user-selected result using a default set of Marker options.
+     *
+     * - If `true` or `undefined` then a default marker will be used.\
+     * - If the value is [MarkerOptions](https://leafletjs.com/reference.html#marker-option) then the marker will be constructed using these options.
+     * - If the value is a function then it can create and configure custom [Marker](https://leafletjs.com/reference.html#marker),
+     *     add it to the [Map](https://leafletjs.com/reference.html#map) and return it.
+     *   Function accepts [Map](https://leafletjs.com/reference.html#map) and `Feature` as parameters.
+     *   Feature is `undefined` for the reverse location marker.
+     * - If `false` or `null` then no marker will be added to the map.
+     *
      * Default value is `true`.
      */
-    marker?: boolean | L.MarkerOptions;
+    marker?: null | boolean | L.MarkerOptions | ((map: L.Map, feature?: Feature) => L.Marker | undefined | null);
     /**
-     * If `true`, [Markers](https://leafletjs.com/reference.html#marker) will be added to the map at the location the top results for the query.
-     * If the value is an object, the marker will be constructed using these options.
-     * If `false`, no marker will be added to the map.
+     * Marker be added to the map at the location the geocoding results.
+     *
+     * - If `true` or `undefined` then a default marker will be used.
+     * - If the value is [MarkerOptions](https://leafletjs.com/reference.html#marker-option) then the marker will be constructed using these options.
+     * - If the value is a function then it can create and configure custom [Marker](https://leafletjs.com/reference.html#marker),
+     *     add it to the [Map](https://leafletjs.com/reference.html#map) and return it.
+     *   In this case the default pop-up won't be added to the marker.
+     *   Function accepts [Map](https://leafletjs.com/reference.html#map) and `Feature` as parameters.
+     * - If `false` or `null` then no marker will be added to the map.
+     *
      * Default value is `true`.
      */
-    showResultMarkers?: boolean | L.MarkerOptions;
+    showResultMarkers?: null | boolean | L.MarkerOptions | ((map: L.Map, feature: Feature) => L.Marker | undefined | null);
     /**
-     * If `false`, animating the map to a selected result is disabled.
-     * If `true`, animating the map will use the default animation parameters.
-     * If an object, it will be passed as options to the map `flyTo` or `fitBounds` method providing control over the animation of the transition.
+     * Animation to selected feature on the map.
+     *
+     * - If `false` or `null` then animating the map to a selected result is disabled.
+     * - If `true` or `undefined` then animating the map will use the default animation parameters.
+     * - If an [ZoomPanOptions](https://leafletjs.com/reference.html#zoom/pan-options)
+     *     ` & `[FitBoundsOptions](https://leafletjs.com/reference.html#fitbounds-options) then it will be passed as options
+     *     to the map [flyTo](https://leafletjs.com/reference.html#map-flyto)
+     *     or [fitBounds](https://leafletjs.com/reference.html#map-fitbounds) method providing control over the animation of the transition.
+     *
      * Default value is `true`.
      */
-    flyTo?: boolean | (L.ZoomPanOptions & L.FitBoundsOptions);
+    flyTo?: null | boolean | (L.ZoomPanOptions & L.FitBoundsOptions);
     /**
-     * Style for full feature geometry GeoJSON.
+     * Style for the full feature geometry.
+     *
+     * - If `false` or `null` then no full geometry is drawn.
+     * - If `true` or `undefined` then default-styled full geometry is drawn.
+     * - If an [PathOptions](https://leafletjs.com/reference.html#path-option) then it will be used to style the full geometry.
+     * - If a function accepting a `Feature` and returning [PathOptions](https://leafletjs.com/reference.html#path-option)
+     *     then it must teturn the style and will be used to style the full geometry.
      */
-    fullGeometryStyle?: L.PathOptions | L.StyleFunction;
+    fullGeometryStyle?: null | boolean | L.PathOptions | L.StyleFunction;
 };
-export declare class GeocodingControl extends L.Control {
+type LeafletEvent<T> = {
+    type: T;
+    target: GeocodingControl;
+    sourceTarget: GeocodingControl;
+};
+type CustomEventMap = {
+    [T in keyof DispatcherType]: DispatcherType[T] & LeafletEvent<T>;
+};
+/**
+ * Leaflet mixins https://leafletjs.com/reference.html#class
+ * for TypeScript https://www.typescriptlang.org/docs/handbook/mixins.html
+ * @internal
+ */
+declare class EventedControl extends L.Control {
+}
+interface EventedControl extends L.Control {
+    on<T extends keyof CustomEventMap>(type: T, fn: (event: CustomEventMap[T]) => void, context?: unknown): this;
+    addEventListener<T extends keyof CustomEventMap>(type: T, fn: (event: CustomEventMap[T]) => void, context?: unknown): this;
+    once<T extends keyof CustomEventMap>(type: T, fn: (event: CustomEventMap[T]) => void, context?: unknown): this;
+    addOneTimeEventListener<T extends keyof CustomEventMap>(type: T, fn: (event: CustomEventMap[T]) => void, context?: unknown): this;
+    off<T extends keyof CustomEventMap>(type?: T, fn?: (event: CustomEventMap[T]) => void, context?: unknown): this;
+    off(eventMap?: {
+        [T in keyof CustomEventMap]?: (event: CustomEventMap[T]) => void;
+    }): this;
+    removeEventListener<T extends keyof CustomEventMap>(type?: T, fn?: (event: CustomEventMap[T]) => void, context?: unknown): this;
+    listens<T extends keyof CustomEventMap>(type: T, fn: (event: CustomEventMap[T]) => void, context?: unknown, propagate?: boolean): boolean;
+    fire(type: string, data?: unknown, propagate?: boolean): this;
+    addEventParent(obj: L.Evented): this;
+    removeEventParent(obj: L.Evented): this;
+    fireEvent(type: string, data?: unknown, propagate?: boolean): this;
+    hasEventListeners<T extends keyof CustomEventMap>(type: T): boolean;
+}
+export declare class GeocodingControl extends EventedControl {
     #private;
     constructor(options: LeafletControlOptions);
     onAdd(map: L.Map): HTMLDivElement;

package/svelte/leaflet.js

@@ -2,11 +2,20 @@ import * as L from "leaflet";
 import GeocodingControlComponent from "./GeocodingControl.svelte";
 import { createLeafletMapController } from "./leaflet-controller";
 export { createLeafletMapController } from "./leaflet-controller";
-export class GeocodingControl extends L.Control {
+/**
+ * Leaflet mixins https://leafletjs.com/reference.html#class
+ * for TypeScript https://www.typescriptlang.org/docs/handbook/mixins.html
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+class EventedControl extends L.Control {
+}
+L.Util.extend(EventedControl.prototype, L.Evented.prototype);
+export class GeocodingControl extends EventedControl {
     #gc;
     #options;
     constructor(options) {
-        super();
+        super(options);
         this.#options = options;
     }
     onAdd(map) {
@@ -14,9 +23,9 @@ export class GeocodingControl extends L.Control {
         div.className = "leaflet-ctrl-geocoder";
         L.DomEvent.disableClickPropagation(div);
         L.DomEvent.disableScrollPropagation(div);
-        const { marker, showResultMarkers, flyTo, fullGeometryStyle, ...restOptions } = this.#options;
+        const { marker, showResultMarkers, flyTo, fullGeometryStyle, position, ...restOptions } = this.#options;
         const flyToOptions = typeof flyTo === "boolean" ? {} : flyTo;
-        const mapController = createLeafletMapController(map, marker, showResultMarkers, flyToOptions, flyToOptions, fullGeometryStyle);
+        const mapController = createLeafletMapController(map, marker, showResultMarkers, flyToOptions, flyToOptions, fullGeometryStyle, restOptions.showFullGeometry === "polygon-with-marker");
         this.#gc = new GeocodingControlComponent({
             target: div,
             props: {
@@ -25,17 +34,18 @@ export class GeocodingControl extends L.Control {
                 ...restOptions,
             },
         });
-        for (const eventName of [
-            "select",
-            "pick",
-            "featuresListed",
-            "featuresMarked",
-            "response",
-            "optionsVisibilityChange",
-            "reverseToggle",
-            "queryChange",
-        ]) {
-            this.#gc.$on(eventName, (event) => map.fire(eventName.toLowerCase(), event.detail));
+        const eventNames = {
+            select: undefined,
+            pick: undefined,
+            featureslisted: undefined,
+            featuresmarked: undefined,
+            response: undefined,
+            optionsvisibilitychange: undefined,
+            reversetoggle: undefined,
+            querychange: undefined,
+        };
+        for (const eventName in eventNames) {
+            this.#gc.$on(eventName, (event) => this.fire(eventName, event.detail));
         }
         return div;
     }

package/svelte/maplibregl-controller.d.ts

@@ -1,12 +1,13 @@
 import type * as maplibregl from "maplibre-gl";
-import type { FillLayerSpecification, FitBoundsOptions, FlyToOptions, LineLayerSpecification, Map } from "maplibre-gl";
+import type { FillLayerSpecification, FitBoundsOptions, FlyToOptions, LineLayerSpecification, Map, Marker, MarkerOptions } from "maplibre-gl";
 import type { BBox, Position } from "./types";
 import type { Feature, MapEvent } from "./types.js";
-type MapLibreGL = Pick<typeof maplibregl, "Marker" | "Popup">;
-export declare function createMapLibreGlMapController(map: Map, maplibregl?: MapLibreGL | undefined, marker?: boolean | maplibregl.MarkerOptions, showResultMarkers?: boolean | maplibregl.MarkerOptions, flyToOptions?: FlyToOptions, fitBoundsOptions?: FitBoundsOptions, fullGeometryStyle?: undefined | {
-    fill?: Pick<FillLayerSpecification, "layout" | "paint" | "filter">;
-    line?: Pick<LineLayerSpecification, "layout" | "paint" | "filter">;
-}): {
+export type MapLibreGL = Pick<typeof maplibregl, "Marker" | "Popup">;
+export type FullGeometryStyle = {
+    fill: Pick<FillLayerSpecification, "layout" | "paint" | "filter">;
+    line: Pick<LineLayerSpecification, "layout" | "paint" | "filter">;
+};
+export declare function createMapLibreGlMapController(map: Map, maplibregl?: MapLibreGL | undefined, marker?: boolean | null | MarkerOptions | ((map: Map, feature?: Feature) => Marker | undefined | null), showResultMarkers?: boolean | null | MarkerOptions | ((map: Map, feature: Feature) => Marker | undefined | null), flyToOptions?: FlyToOptions | null, fitBoundsOptions?: FitBoundsOptions | null, fullGeometryStyle?: boolean | null | FullGeometryStyle, showPolyMarker?: boolean): {
     setEventHandler(handler: undefined | ((e: MapEvent) => void)): void;
     flyTo(center: Position, zoom?: number): void;
     fitBounds(bbox: BBox, padding: number, maxZoom?: number): void;
@@ -16,4 +17,3 @@ export declare function createMapLibreGlMapController(map: Map, maplibregl?: Map
     setSelectedMarker(index: number): void;
     getCenterAndZoom(): [number, number, number];
 };
-export {};