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

package/svelte/maplibregl-controller.js

@@ -2,8 +2,7 @@ import { feature, featureCollection } from "@turf/helpers";
 import union from "@turf/union";
 import MarkerIcon from "./MarkerIcon.svelte";
 import { setMask } from "./mask";
-const emptyGeojson = featureCollection([]);
-export function createMapLibreGlMapController(map, maplibregl, marker = true, showResultMarkers = true, flyToOptions = {}, fitBoundsOptions = {}, fullGeometryStyle = {
+const defaultGeometryStyle = {
     fill: {
         paint: {
             "fill-color": "#000",
@@ -22,50 +21,70 @@ export function createMapLibreGlMapController(map, maplibregl, marker = true, sh
         },
         filter: ["!", ["has", "isMask"]],
     },
-}) {
+};
+const RESULT_SOURCE = "mtlr-gc-full-geom";
+const RESULT_LAYER_FILL = "mtlr-gc-full-geom-fill";
+const RESULT_LAYER_LINE = "mtlr-gc-full-geom-line";
+export function createMapLibreGlMapController(map, maplibregl, marker = true, showResultMarkers = true, flyToOptions = {}, fitBoundsOptions = {}, fullGeometryStyle = defaultGeometryStyle, showPolyMarker = false) {
     let eventHandler;
     const markers = [];
     let selectedMarker;
     let reverseMarker;
     let savedData; // used to restore features on style switch
-    function addFullGeometryLayer() {
-        if (!map.getSource("full-geom") &&
-            (fullGeometryStyle?.fill || fullGeometryStyle?.line)) {
-            map.addSource("full-geom", {
+    function syncFullGeometryLayer() {
+        if (!map.loaded) {
+            map.once("load", syncFullGeometryLayer);
+            return;
+        }
+        const effFullGeometryStyle = !fullGeometryStyle
+            ? undefined
+            : fullGeometryStyle === true
+                ? defaultGeometryStyle
+                : fullGeometryStyle;
+        if (!effFullGeometryStyle?.fill && !effFullGeometryStyle?.line) {
+            return;
+        }
+        const source = map.getSource(RESULT_SOURCE);
+        if (source) {
+            source.setData(savedData ?? featureCollection([]));
+        }
+        else if (savedData) {
+            map.addSource(RESULT_SOURCE, {
                 type: "geojson",
-                data: emptyGeojson,
+                data: savedData,
             });
         }
-        if (!map.getLayer("full-geom-fill") && fullGeometryStyle?.fill) {
+        else {
+            return;
+        }
+        if (!map.getLayer(RESULT_LAYER_FILL) && effFullGeometryStyle?.fill) {
             map.addLayer({
-                ...fullGeometryStyle?.fill,
-                id: "full-geom-fill",
+                ...effFullGeometryStyle?.fill,
+                id: RESULT_LAYER_FILL,
                 type: "fill",
-                source: "full-geom",
+                source: RESULT_SOURCE,
             });
         }
-        if (!map.getLayer("full-geom-line") && fullGeometryStyle?.line) {
+        if (!map.getLayer(RESULT_LAYER_LINE) && effFullGeometryStyle?.line) {
             map.addLayer({
-                ...fullGeometryStyle?.line,
-                id: "full-geom-line",
+                ...effFullGeometryStyle?.line,
+                id: RESULT_LAYER_LINE,
                 type: "line",
-                source: "full-geom",
+                source: RESULT_SOURCE,
             });
         }
-        if (savedData) {
-            setData(savedData);
-        }
-    }
-    if (map.loaded()) {
-        addFullGeometryLayer();
     }
-    else {
-        map.once("load", () => {
-            addFullGeometryLayer();
-        });
+    function setAndSaveData(data) {
+        savedData = data;
+        syncFullGeometryLayer();
     }
     map.on("styledata", () => {
-        addFullGeometryLayer();
+        // timeout prevents collision with svelte-maplibre library
+        setTimeout(() => {
+            if (savedData) {
+                syncFullGeometryLayer();
+            }
+        });
     });
     const handleMapClick = (e) => {
         eventHandler?.({
@@ -87,13 +106,6 @@ export function createMapLibreGlMapController(map, maplibregl, marker = true, sh
         });
         return new maplibregl.Marker({ element, offset: [1, -13] });
     }
-    function setData(data) {
-        savedData = data;
-        if (!data) {
-            return;
-        }
-        map.getSource("full-geom")?.setData(data);
-    }
     return {
         setEventHandler(handler) {
             if (handler) {
@@ -131,23 +143,25 @@ export function createMapLibreGlMapController(map, maplibregl, marker = true, sh
                 }
             }
             else if (coordinates) {
-                reverseMarker = (typeof marker === "object"
-                    ? new maplibregl.Marker(marker)
-                    : createMarker())
-                    .setLngLat(coordinates)
-                    .addTo(map);
-                reverseMarker.getElement().classList.add("marker-reverse");
+                if (marker instanceof Function) {
+                    reverseMarker = marker(map) ?? undefined;
+                }
+                else {
+                    reverseMarker = (typeof marker === "object"
+                        ? new maplibregl.Marker(marker)
+                        : createMarker())
+                        .setLngLat(coordinates)
+                        .addTo(map);
+                    reverseMarker.getElement().classList.add("marker-reverse");
+                }
             }
         },
         setMarkers(markedFeatures, picked) {
-            if (!marker) {
-                return;
-            }
             for (const marker of markers) {
                 marker.remove();
             }
             markers.length = 0;
-            setData(emptyGeojson);
+            setAndSaveData(undefined);
             if (!maplibregl) {
                 return;
             }
@@ -163,14 +177,14 @@ export function createMapLibreGlMapController(map, maplibregl, marker = true, sh
                         setMask({
                             ...picked,
                             geometry: unioned.geometry,
-                        }, setData);
+                        }, setAndSaveData);
                         handled = true;
                     }
                     else {
                         const geometries = picked.geometry.geometries.filter((geometry) => geometry.type === "LineString" ||
                             geometry.type === "MultiLineString");
                         if (geometries.length > 0) {
-                            setData({
+                            setAndSaveData({
                                 ...picked,
                                 geometry: { type: "GeometryCollection", geometries },
                             });
@@ -183,19 +197,26 @@ export function createMapLibreGlMapController(map, maplibregl, marker = true, sh
                 }
                 else if (picked.geometry.type === "Polygon" ||
                     picked.geometry.type === "MultiPolygon") {
-                    setMask(picked, setData);
+                    setMask(picked, setAndSaveData);
                 }
                 else if (picked.geometry.type === "LineString" ||
                     picked.geometry.type === "MultiLineString") {
-                    setData(picked);
+                    setAndSaveData(picked);
                     return; // no pin for (multi)linestrings
                 }
-                if (marker) {
-                    markers.push((typeof marker === "object"
+                if (!showPolyMarker && picked.geometry.type !== "Point") {
+                    return;
+                }
+                if (marker instanceof Function) {
+                    const m = marker(map, picked);
+                    if (m) {
+                        markers.push(m);
+                    }
+                }
+                else if (marker) {
+                    markers.push(typeof marker === "object"
                         ? new maplibregl.Marker(marker)
-                        : createMarker())
-                        .setLngLat(picked.center)
-                        .addTo(map));
+                        : createMarker().setLngLat(picked.center).addTo(map));
                 }
             }
             if (showResultMarkers) {
@@ -203,19 +224,28 @@ export function createMapLibreGlMapController(map, maplibregl, marker = true, sh
                     if (feature === picked) {
                         continue;
                     }
-                    const marker = (typeof showResultMarkers === "object"
-                        ? new maplibregl.Marker(showResultMarkers)
-                        : createMarker(true))
-                        .setLngLat(feature.center)
-                        .setPopup(new maplibregl.Popup({
-                        offset: [1, -27],
-                        closeButton: false,
-                        closeOnMove: true,
-                        className: "maptiler-gc-popup",
-                    }).setText(feature.place_type[0] === "reverse"
-                        ? feature.place_name
-                        : feature.place_name.replace(/,.*/, "")))
-                        .addTo(map);
+                    let marker;
+                    if (showResultMarkers instanceof Function) {
+                        marker = showResultMarkers(map, feature);
+                        if (!marker) {
+                            continue;
+                        }
+                    }
+                    else {
+                        marker = (typeof showResultMarkers === "object"
+                            ? new maplibregl.Marker(showResultMarkers)
+                            : createMarker(true))
+                            .setLngLat(feature.center)
+                            .setPopup(new maplibregl.Popup({
+                            offset: [1, -27],
+                            closeButton: false,
+                            closeOnMove: true,
+                            className: "maptiler-gc-popup",
+                        }).setText(feature.place_type[0] === "reverse"
+                            ? feature.place_name
+                            : feature.place_name.replace(/,.*/, "")))
+                            .addTo(map);
+                    }
                     const element = marker.getElement();
                     element.addEventListener("click", (e) => {
                         e.stopPropagation();

package/svelte/maplibregl.js

@@ -1,14 +1,17 @@
 import * as maplibregl from "maplibre-gl";
-import { MapLibreBasedGeocodingControl, } from "./MapLibreBasedGeocodingControl";
+import { crateClasses, } from "./MapLibreBasedGeocodingControl";
 export { createMapLibreGlMapController } from "./maplibregl-controller";
+const { MapLibreBasedGeocodingControl, events } = crateClasses(maplibregl.Evented, maplibregl);
 export class GeocodingControl extends MapLibreBasedGeocodingControl {
-    getMapLibreGl() {
-        return maplibregl;
-    }
     onAdd(map) {
         return super.onAddInt(map);
     }
-    getExtraProps() {
-        return {};
-    }
 }
+export const SelectEvent = events.SelectEvent;
+export const FeaturesListedEvent = events.FeaturesListedEvent;
+export const FeaturesMarkedEvent = events.FeaturesMarkedEvent;
+export const OptionsVisibilityChangeEvent = events.OptionsVisibilityChangeEvent;
+export const PickEvent = events.PickEvent;
+export const QueryChangeEvent = events.QueryChangeEvent;
+export const ResponseEvent = events.ResponseEvent;
+export const ReverseToggleEvent = events.ReverseToggleEvent;

package/svelte/maptilersdk.js

@@ -1,25 +1,30 @@
 import * as maptilersdk from "@maptiler/sdk";
-import { MapLibreBasedGeocodingControl, } from "./MapLibreBasedGeocodingControl";
+import { crateClasses, } from "./MapLibreBasedGeocodingControl";
 export { createMapLibreGlMapController } from "./maplibregl-controller";
-export class GeocodingControl extends MapLibreBasedGeocodingControl {
-    getMapLibreGl() {
-        return maptilersdk;
+const { MapLibreBasedGeocodingControl, events } = crateClasses(maptilersdk.Evented, maptilersdk, (map, div) => {
+    const sdkConfig = {};
+    if (!("getSdkConfig" in map && typeof map.getSdkConfig === "function")) {
+        throw new Error("MapTiler SDK not detected");
+    }
+    const { primaryLanguage, apiKey } = map.getSdkConfig();
+    sdkConfig.apiKey = apiKey;
+    const match = /^([a-z]{2})($|_|-)/.exec(primaryLanguage);
+    if (match) {
+        sdkConfig.language = match[1];
     }
+    div.className += " maptiler-ctrl";
+    return sdkConfig;
+});
+export class GeocodingControl extends MapLibreBasedGeocodingControl {
     onAdd(map) {
         return super.onAddInt(map);
     }
-    getExtraProps(map, div) {
-        const sdkConfig = {};
-        if (!("getSdkConfig" in map && typeof map.getSdkConfig === "function")) {
-            throw new Error("MapTiler SDK not detected");
-        }
-        const { primaryLanguage, apiKey } = map.getSdkConfig();
-        sdkConfig.apiKey = apiKey;
-        const match = /^([a-z]{2})($|_|-)/.exec(primaryLanguage);
-        if (match) {
-            sdkConfig.language = match[1];
-        }
-        div.className += " maptiler-ctrl";
-        return sdkConfig;
-    }
 }
+export const SelectEvent = events.SelectEvent;
+export const FeaturesListedEvent = events.FeaturesListedEvent;
+export const FeaturesMarkedEvent = events.FeaturesMarkedEvent;
+export const OptionsVisibilityChangeEvent = events.OptionsVisibilityChangeEvent;
+export const PickEvent = events.PickEvent;
+export const QueryChangeEvent = events.QueryChangeEvent;
+export const ResponseEvent = events.ResponseEvent;
+export const ReverseToggleEvent = events.ReverseToggleEvent;

package/svelte/openlayers-controller.d.ts

@@ -3,7 +3,7 @@ import type { AnimationOptions, FitOptions } from "ol/View";
 import { type StyleLike } from "ol/style/Style";
 import type { FlatStyleLike } from "ol/style/flat";
 import type { BBox, Feature as FeatureType, MapEvent, Position } from "./types";
-export declare function createOpenLayersMapController(map: Map, flyToOptions?: AnimationOptions, flyToBounds?: FitOptions, fullGeometryStyle?: StyleLike | FlatStyleLike): {
+export declare function createOpenLayersMapController(map: Map, flyToOptions?: AnimationOptions, flyToBounds?: FitOptions, fullGeometryStyle?: StyleLike | FlatStyleLike, 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/openlayers-controller.js

@@ -57,7 +57,7 @@ function defaultStyle(feature) {
             : undefined,
     });
 }
-export function createOpenLayersMapController(map, flyToOptions = {}, flyToBounds = {}, fullGeometryStyle = defaultStyle) {
+export function createOpenLayersMapController(map, flyToOptions = {}, flyToBounds = {}, fullGeometryStyle = defaultStyle, showPolyMarker = false) {
     let prevSelected = -1;
     let prevHovered;
     let eventHandler;
@@ -235,6 +235,9 @@ export function createOpenLayersMapController(map, flyToOptions = {}, flyToBound
                     source.addFeature(new OlFeature(fromWgs84(new OlMultiLineString(picked.geometry.coordinates))));
                     return; // no pin for (multi)linestrings
                 }
+                if (!showPolyMarker && picked.geometry.type !== "Point") {
+                    return;
+                }
                 source.addFeature(new OlFeature(fromWgs84(new OlPoint(picked.center))));
             }
             for (const feature of markedFeatures ?? []) {

package/svelte/openlayers.d.ts

@@ -1,7 +1,10 @@
 import type { Map } from "ol";
+import type { ObjectEvent } from "ol/Object";
+import type { CombinedOnSignature, EventTypes } from "ol/Observable";
 import type { AnimationOptions, FitOptions } from "ol/View";
 import { Control } from "ol/control";
 import type { Options } from "ol/control/Control";
+import type { EventsKey } from "ol/events";
 import BaseEvent from "ol/events/Event";
 import type { StyleLike } from "ol/style/Style";
 import type { FlatStyleLike } from "ol/style/flat";
@@ -11,8 +14,26 @@ type OpenLayersControlOptions = ControlOptions & Options & {
     flyTo?: boolean | (AnimationOptions & FitOptions);
     fullGeometryStyle?: StyleLike | FlatStyleLike;
 };
+type CustomEventMap = {
+    select: SelectEvent;
+    featureslisted: FeaturesListedEvent;
+    featuresmarked: FeaturesMarkedEvent;
+    optionsvisibilitychange: OptionsVisibilityChangeEvent;
+    pick: PickEvent;
+    querychange: QueryChangeEvent;
+    response: ResponseEvent;
+    reversetoggle: ReverseToggleEvent;
+};
+type CustomObjectOnSignature<ReturnType> = {
+    <K extends keyof CustomEventMap>(type: K, listener: (evt: CustomEventMap[K]) => void): ReturnType;
+} & {
+    (type: "propertychange", listener: (evt: ObjectEvent) => void): ReturnType;
+} & CombinedOnSignature<EventTypes | "propertychange" | keyof CustomEventMap, ReturnType>;
 export declare class GeocodingControl extends Control {
     #private;
+    on: CustomObjectOnSignature<EventsKey>;
+    once: CustomObjectOnSignature<EventsKey>;
+    un: CustomObjectOnSignature<EventsKey>;
     constructor(options: OpenLayersControlOptions);
     setMap(map: Map | null): void;
     setOptions(options: OpenLayersControlOptions): void;

package/svelte/openlayers.js

@@ -21,45 +21,30 @@ export class GeocodingControl extends Control {
                 ...restOptions,
             },
         });
-        for (const eventName of [
-            "select",
-            "pick",
-            "featuresListed",
-            "featuresMarked",
-            "response",
-            "optionsVisibilityChange",
-            "reverseToggle",
-            "queryChange",
-        ]) {
-            this.#gc.$on(eventName, (event) => {
-                switch (eventName) {
-                    case "select":
-                        this.dispatchEvent(new SelectEvent(event.detail));
-                        break;
-                    case "featuresListed":
-                        this.dispatchEvent(new FeaturesListedEvent(event.detail));
-                        break;
-                    case "featuresMarked":
-                        this.dispatchEvent(new FeaturesMarkedEvent(event.detail));
-                        break;
-                    case "optionsVisibilityChange":
-                        this.dispatchEvent(new OptionsVisibilityChangeEvent(event.detail));
-                        break;
-                    case "pick":
-                        this.dispatchEvent(new PickEvent(event.detail));
-                        break;
-                    case "queryChange":
-                        this.dispatchEvent(new QueryChangeEvent(event.detail));
-                        break;
-                    case "response":
-                        this.dispatchEvent(new ResponseEvent(event.detail.url, event.detail.featureCollection));
-                        break;
-                    case "reverseToggle":
-                        this.dispatchEvent(new ReverseToggleEvent(event.detail));
-                        break;
-                }
-            });
-        }
+        this.#gc.$on("select", (event) => {
+            this.dispatchEvent(new SelectEvent(event.detail.feature));
+        });
+        this.#gc.$on("pick", (event) => {
+            this.dispatchEvent(new PickEvent(event.detail.feature));
+        });
+        this.#gc.$on("featureslisted", (event) => {
+            this.dispatchEvent(new FeaturesListedEvent(event.detail.features));
+        });
+        this.#gc.$on("featuresmarked", (event) => {
+            this.dispatchEvent(new FeaturesMarkedEvent(event.detail.features));
+        });
+        this.#gc.$on("response", (event) => {
+            this.dispatchEvent(new ResponseEvent(event.detail.url, event.detail.featureCollection));
+        });
+        this.#gc.$on("optionsvisibilitychange", (event) => {
+            this.dispatchEvent(new OptionsVisibilityChangeEvent(event.detail.optionsVisible));
+        });
+        this.#gc.$on("reversetoggle", (event) => {
+            this.dispatchEvent(new ReverseToggleEvent(event.detail.reverse));
+        });
+        this.#gc.$on("querychange", (event) => {
+            this.dispatchEvent(new QueryChangeEvent(event.detail.query));
+        });
         this.#options = options;
     }
     setMap(map) {
@@ -72,7 +57,7 @@ export class GeocodingControl extends Control {
             const mapController = createOpenLayersMapController(map, typeof flyTo === "boolean" ? undefined : flyTo, typeof flyTo === "boolean" ? undefined : flyTo, 
             // marker,
             // showResultMarkers,
-            fullGeometryStyle);
+            fullGeometryStyle, this.#options.showFullGeometry === "polygon-with-marker");
             this.#gc?.$set({ mapController });
         }
     }
@@ -110,21 +95,21 @@ export class SelectEvent extends BaseEvent {
 export class FeaturesListedEvent extends BaseEvent {
     features;
     constructor(features) {
-        super("featuresListed");
+        super("featureslisted");
         this.features = features;
     }
 }
 export class FeaturesMarkedEvent extends BaseEvent {
     features;
     constructor(features) {
-        super("featuresMarked");
+        super("featuresmarked");
         this.features = features;
     }
 }
 export class OptionsVisibilityChangeEvent extends BaseEvent {
     optionsVisible;
     constructor(optionsVisible) {
-        super("optionsVisibilityChange");
+        super("optionsvisibilitychange");
         this.optionsVisible = optionsVisible;
     }
 }
@@ -138,7 +123,7 @@ export class PickEvent extends BaseEvent {
 export class QueryChangeEvent extends BaseEvent {
     query;
     constructor(query) {
-        super("queryChange");
+        super("querychange");
         this.query = query;
     }
 }
@@ -154,7 +139,7 @@ export class ResponseEvent extends BaseEvent {
 export class ReverseToggleEvent extends BaseEvent {
     reverse;
     constructor(reverse) {
-        super("reverseToggle");
+        super("reversetoggle");
         this.reverse = reverse;
     }
 }

package/svelte/react.d.ts

@@ -1,5 +1,5 @@
-import type { ControlOptions, DispatcherType, MapController } from "./types";
-type EventNames = keyof DispatcherType;
+import type { ControlOptions, DispatcherTypeCC, MapController } from "./types";
+type EventNames = keyof DispatcherTypeCC;
 type EventHandlerFnName<T extends EventNames> = `on${Capitalize<T>}`;
 type CallbackProperties<T> = {
     [K in keyof T as EventHandlerFnName<Extract<K, EventNames>>]?: (event: T[K]) => void;
@@ -7,7 +7,7 @@ type CallbackProperties<T> = {
 type MapControllerProp = {
     mapController?: MapController;
 };
-export type Props = ControlOptions & CallbackProperties<DispatcherType> & MapControllerProp;
+export type Props = ControlOptions & CallbackProperties<DispatcherTypeCC> & MapControllerProp;
 export type Methods = {
     blur(): void;
     focus(): void;
@@ -15,5 +15,5 @@ export type Methods = {
     clearMap(): void;
     clearList(): void;
 };
-declare const ReactGeocodingControl: import("react").ForwardRefExoticComponent<ControlOptions & CallbackProperties<DispatcherType> & MapControllerProp & import("react").RefAttributes<Methods>>;
+declare const ReactGeocodingControl: import("react").ForwardRefExoticComponent<ControlOptions & CallbackProperties<DispatcherTypeCC> & MapControllerProp & import("react").RefAttributes<Methods>>;
 export { ReactGeocodingControl as GeocodingControl };

package/svelte/types.d.ts

@@ -123,6 +123,7 @@ export type ControlOptions = {
      * Default value is `false`.
      */
     showResultsWhileTyping?: boolean;
+    autocompleteTimeout?: number;
     /**
      * Set to `false` to disable fuzzy search.
      * Default value is `true`
@@ -188,15 +189,16 @@ export type ControlOptions = {
     clearButtonTitle?: string;
     /**
      * Set to `false` to hide place/POI type. If set to `"always"` then type is shown for all items.
-     * If set to `"ifNeeded"` then type is shown only for places/POIs not determined from the icon.
-     * Default value is `"ifNeeded"`.
+     * If set to `"if-needed"` (deprecated `"ifNeeded"`) then type is shown only for places/POIs not determined from the icon.
+     * Default value is `"if-needed"`.
      */
-    showPlaceType?: false | "always" | "ifNeeded";
+    showPlaceType?: false | "always" | "ifNeeded" | "if-needed";
     /**
      * Set to `true` to show full feature geometry of the chosen result. Otherwise only marker will be shown.
+     * If `"polygon-with-marker"` is specified, then also a marker will be shown in the hotspot or center of polygon features.
      * Default value is `true`.
      */
-    showFullGeometry?: boolean;
+    showFullGeometry?: boolean | "polygon-with-marker";
     /**
      * Limit search to specified country(ies).
      * Default value is `undefined` - use all countries.
@@ -257,16 +259,34 @@ export type ControlOptions = {
      */
     markerOnSelected?: boolean;
 };
-export type DispatcherType = {
-    featuresListed: Feature[] | undefined;
-    featuresMarked: Feature[] | undefined;
-    optionsVisibilityChange: boolean;
-    pick: Feature | undefined;
-    queryChange: string;
+export type DispatcherTypeCC = {
+    featuresListed: {
+        features: Feature[] | undefined;
+    };
+    featuresMarked: {
+        features: Feature[] | undefined;
+    };
+    optionsVisibilityChange: {
+        optionsVisible: boolean;
+    };
+    pick: {
+        feature: Feature | undefined;
+    };
+    queryChange: {
+        query: string;
+    };
     response: {
         url: string;
         featureCollection: FeatureCollection;
     };
-    reverseToggle: boolean;
-    select: Feature | undefined;
+    reverseToggle: {
+        reverse: boolean;
+    };
+    select: {
+        feature: Feature | undefined;
+    };
+};
+export type DispatcherType = {
+    [T in keyof DispatcherTypeCC as Lowercase<T>]: DispatcherTypeCC[T];
 };
+export type EnsureMatchingKeys<T, U> = keyof T extends keyof U ? keyof U extends keyof T ? true : never : never;

package/svelte/vanilla.d.ts

@@ -1,7 +1,17 @@
-import type { ControlOptions, MapController } from "./types";
+import type { ControlOptions, DispatcherType, MapController } from "./types";
 type Options = ControlOptions & {
     mapController?: MapController;
 };
+interface GeocodingControlEvent<T> extends CustomEvent<T> {
+    readonly target: GeocodingControl;
+    readonly currentTarget: GeocodingControl;
+}
+type CustomEventListenerOrEventListenerObject<K extends keyof CustomEventMap> = ((evt: CustomEventMap[K]) => void) | {
+    handleEvent(object: CustomEventMap[K]): void;
+};
+type CustomEventMap = {
+    [T in keyof DispatcherType]: GeocodingControlEvent<DispatcherType[T]>;
+};
 export declare class GeocodingControl extends EventTarget {
     #private;
     constructor({ target, ...options }: Options & {
@@ -13,5 +23,8 @@ export declare class GeocodingControl extends EventTarget {
     clearList(): void;
     focus(): void;
     blur(): void;
+    addEventListener<K extends keyof CustomEventMap>(type: K, callback: CustomEventListenerOrEventListenerObject<K> | null, options?: AddEventListenerOptions | boolean): void;
+    removeEventListener<K extends keyof CustomEventMap>(type: K, callback: CustomEventListenerOrEventListenerObject<K> | null, options?: EventListenerOptions | boolean): void;
+    dispatchEvent<K extends keyof CustomEventMap>(event: CustomEventMap[K]): boolean;
 }
 export {};