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

package/svelte/vanilla.js

@@ -1,4 +1,4 @@
-import GC from "./GeocodingControl.svelte";
+import GeocodingControlComponent from "./GeocodingControl.svelte";
 const finalizationRegistry = new FinalizationRegistry((gc) => {
     gc.$destroy();
 });
@@ -6,22 +6,31 @@ export class GeocodingControl extends EventTarget {
     #gc;
     constructor({ target, ...options }) {
         super();
-        this.#gc = new GC({
+        this.#gc = new GeocodingControlComponent({
             target,
             props: options,
         });
         for (const eventName of [
             "select",
             "pick",
-            "featuresListed",
-            "featuresMarked",
+            "featureslisted",
+            "featuresmarked",
             "response",
-            "optionsVisibilityChange",
-            "reverseToggle",
-            "queryChange",
+            "optionsvisibilitychange",
+            "reversetoggle",
+            "querychange",
         ]) {
-            this.#gc.$on(eventName, (event) => this.dispatchEvent(event));
+            this.#gc.$on(eventName, (event) => {
+                // Use the new `emit` method for type-safe dispatching
+                this.#emit(eventName, event.detail);
+            });
         }
+        this.#gc.$on("select", (event) => {
+            const geocodingEvent = new CustomEvent(event.type, {
+                detail: event.detail,
+            });
+            this.dispatchEvent(geocodingEvent);
+        });
         finalizationRegistry.register(this, this.#gc);
     }
     setOptions(options) {
@@ -42,4 +51,18 @@ export class GeocodingControl extends EventTarget {
     blur() {
         this.#gc?.blur();
     }
+    addEventListener(type, callback, options) {
+        super.addEventListener(type, callback, options);
+    }
+    removeEventListener(type, callback, options) {
+        super.removeEventListener(type, callback, options);
+    }
+    dispatchEvent(event) {
+        return super.dispatchEvent(event);
+    }
+    #emit(type, detail) {
+        return super.dispatchEvent(new CustomEvent(type, {
+            detail,
+        }));
+    }
 }

package/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.
@@ -207,6 +209,12 @@ export type ControlOptions = {
      * Default value is `undefined` - all available feature types are returned.
      */
     types?: string[];
+    /**
+     * Use `limit` value for reverse geocoding even if `types` is not an array with a single element.
+     * Will work only if enabled on the server.
+     * Default value is `false`.
+     */
+    exhaustiveReverseGeocoding?: boolean;
     /**
      * If set to `true` then use all types except for those listed in `types`.
      * Default value is `false`.
@@ -251,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/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 {};