@maptiler/geocoding-control 2.1.7 → 3.0.0-rc.2

package/dist/src/geocoder/geocoder-events.d.ts

@@ -0,0 +1,46 @@
+import { convert } from 'geo-coordinates-parser';
+import { Feature, FeatureCollection } from '../types';
+export type ReverseToggleEvent = CustomEvent<{
+    reverse: boolean;
+}>;
+export type QueryChangeEvent = CustomEvent<{
+    query: string;
+    reverseCoords: ReturnType<typeof convert> | false;
+}>;
+export type QueryClearEvent = CustomEvent<void>;
+export type RequestEvent = CustomEvent<{
+    urlObj: URL;
+}>;
+export type ResponseEvent = CustomEvent<{
+    url: string;
+    featureCollection: FeatureCollection;
+}>;
+export type SelectEvent = CustomEvent<{
+    feature: Feature | undefined;
+}>;
+export type PickEvent = CustomEvent<{
+    feature: Feature | undefined;
+}>;
+export type FeaturesShowEvent = CustomEvent<void>;
+export type FeaturesHideEvent = CustomEvent<void>;
+export type FeaturesListedEvent = CustomEvent<{
+    features: Feature[] | undefined;
+}>;
+export type FeaturesClearEvent = CustomEvent<void>;
+export type MaptilerGeocoderEventNameMap = {
+    reversetoggle: ReverseToggleEvent;
+    querychange: QueryChangeEvent;
+    queryclear: QueryClearEvent;
+    request: RequestEvent;
+    response: ResponseEvent;
+    select: SelectEvent;
+    pick: PickEvent;
+    featuresshow: FeaturesShowEvent;
+    featureshide: FeaturesHideEvent;
+    featureslisted: FeaturesListedEvent;
+    featuresclear: FeaturesClearEvent;
+    focusin: FocusEvent;
+    focusout: FocusEvent;
+};
+export type MaptilerGeocoderEvent = MaptilerGeocoderEventNameMap[keyof MaptilerGeocoderEventNameMap];
+export type MaptilerGeocoderEventName = keyof MaptilerGeocoderEventNameMap;

package/dist/src/geocoder/geocoder-feature-item.d.ts

@@ -0,0 +1,22 @@
+import { LitElement } from 'lit';
+import { Feature, ShowPlaceType } from '../types';
+export declare class MaptilerGeocoderFeatureItemElement extends LitElement {
+    #private;
+    static styles: import('lit').CSSResult;
+    feature?: Feature;
+    itemStyle: "selected" | "picked" | "default";
+    showPlaceType: ShowPlaceType;
+    missingIconsCache: Set<string>;
+    iconsBaseUrl: string;
+    private category;
+    private imageUrl;
+    private spriteIcon;
+    private index;
+    willUpdate(changedProperties: Map<string, unknown>): void;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "maptiler-geocoder-feature-item": MaptilerGeocoderFeatureItemElement;
+    }
+}

package/{svelte/types.d.ts → dist/src/geocoder/geocoder-options.d.ts}

@@ -1,74 +1,5 @@
-import type { Feature as FeatureType, Geometry } from "geojson";
-export type BBox = [minx: number, miny: number, maxx: number, maxy: number];
-export type Position = [x: number, y: number];
-export type Feature<T extends Geometry = Geometry> = FeatureType<T> & {
-    id: string;
-    text: string;
-    place_name: string;
-    place_type: string[];
-    center: Position;
-    bbox: BBox;
-    address?: string;
-    matching_text?: string;
-};
-export type FeatureCollection<T extends Geometry = Geometry> = {
-    type: "FeatureCollection";
-    features: Feature<T>[];
-};
-export type MapEvent = {
-    type: "mapClick";
-    coordinates: Position;
-} | {
-    type: "markerClick";
-    id: string;
-} | {
-    type: "markerMouseEnter";
-    id: string;
-} | {
-    type: "markerMouseLeave";
-    id: string;
-};
-export type MapController = {
-    setEventHandler(handler: undefined | ((e: MapEvent) => void)): void;
-    flyTo(center: Position, zoom?: number): void;
-    fitBounds(bbox: BBox, padding: number, maxZoom?: number): void;
-    indicateReverse(reverse: boolean): void;
-    setFeatures(features: Feature[] | undefined, picked: Feature | undefined, showPolygonMarker: boolean): void;
-    setReverseMarker(coordinates?: Position): void;
-    setSelectedMarker(index: number): void;
-    getCenterAndZoom(): [zoom: number, lon: number, lat: number] | undefined;
-};
-export type ProximityRule = {
-    /** minimal map zoom for the rule to be used */
-    minZoom?: number;
-    /** maximal map zoom for the rule to be used */
-    maxZoom?: number;
-} & ({
-    /** fixed proximity */
-    type: "fixed";
-    /** coordinates of the fixed proximity */
-    coordinates: Position;
-} | {
-    /** use map center coordinates for the proximity */
-    type: "map-center";
-} | {
-    /** resolve proximity by geolocating IP of the geocoding API call */
-    type: "server-geolocation";
-} | ({
-    /** use browser's geolocation API for proximity. If it fails, following proximity rules are iterated. */
-    type: "client-geolocation";
-    /** how long should the geolocation result be cached, in milliseconds */
-    cachedLocationExpiry?: number;
-} & PositionOptions));
-export type ControlOptions = {
-    /**
-     * Callback function to adjust URL search parameters.
-     *
-     * Default: Empty function.
-     *
-     * @deprecated Use `adjustUrl` instead.
-     */
-    adjustUrlQuery?: (sp: URLSearchParams) => void;
+import { BBox, EnableReverse, Feature, ProximityRule, ShowPlaceType, TypeRule, Worldview } from '../types';
+export type MaptilerGeocoderOptions = {
     /**
      * Callback function to adjust the geocoding URL before fetching.
      *
@@ -93,12 +24,6 @@ export type ControlOptions = {
      * Default: `undefined`.
      */
     bbox?: BBox;
-    /**
-     * CSS class for the root element.
-     *
-     * Default: `undefined`.
-     */
-    class?: string;
     /**
      * Title of the clear button.
      *
@@ -166,6 +91,12 @@ export type ControlOptions = {
      * Default: `false`.
      */
     exhaustiveReverseGeocoding?: boolean;
+    /**
+     * Enables fetching the full geometry (polygon etc.) instead of just a point on a picked feature.
+     *
+     * Default: `false`.
+     */
+    fetchFullGeometryOnPick?: boolean;
     /**
      * Additional parameters for fetch requests.
      *
@@ -179,12 +110,6 @@ export type ControlOptions = {
      * Default: A function that always returns `true`.
      */
     filter?: (feature: Feature) => boolean;
-    /**
-     * Animates the map to the selected feature from the result list.
-     *
-     * Default: `false`.
-     */
-    flyToSelected?: boolean;
     /**
      * Enables fuzzy search.
      *
@@ -221,12 +146,6 @@ export type ControlOptions = {
      * Default: `5`.
      */
     limit?: number;
-    /**
-     * Displays a marker on the selected feature from the result list.
-     *
-     * Default: `true`.
-     */
-    markerOnSelected?: boolean;
     /**
      * Minimum number of characters required to start a search.
      *
@@ -245,14 +164,11 @@ export type ControlOptions = {
      */
     noResultsMessage?: string;
     /**
-     * Style of the picked result on the map:
-     * - `"marker-only"`: Show only a marker at the center of the feature.
-     * - `"full-geometry"`: Display the full feature geometry.
-     * - `"full-geometry-including-polygon-center-marker"`: Display full geometry with a marker at the polygon center.
+     * Opens the result list above the query input instead of below. Used when mounted at the bottom of a map.
      *
-     * Default: `"full-geometry"`.
+     * Default: `false`.
      */
-    pickedResultStyle?: PickedResultStyle;
+    openListOnTop?: boolean;
     /**
      * Custom placeholder for the input box.
      *
@@ -337,55 +253,19 @@ export type ControlOptions = {
      */
     types?: TypeRule[];
     /**
-     * Specifies the zoom level to animate the map to for a geocoded result when no bounding box is present or when the result is a point.
-     * If a bounding box is present and not a point, the map will fit to the bounding box.
+     * Some of the geographical boundaries and names are disputed. When worldview option is
+     * selected, the Geocoding API responses will be aligned with the borders and names recognized
+     * by the selected country. This affects filtering by country, the context returned with
+     * the given feature and also some of the labels (e.g., Gulf of Mexico vs. Gulf of America).
      *
-     * Values are key-value pairs where the key is a `<type>` or `<type>.<category>` and the value is the zoom level.
+     * Available options:
+     * - `"ch"`: Use the worldview of Switzerland
+     * - `"us"`: Use the worldview of US
+     * - `"auto"`: Automatically determine the worldview by the location of the client
+     * - `undefined`: Do not use any particular worldview (disputed areas are returned without country information,
+     *                countries with disputed borders are returned without full geometry)
      *
-     * Default: `GeocodingControl.ZOOM_DEFAULTS`.
+     * Default: `undefined` (no worldview).
      */
-    zoom?: Record<string, number>;
-};
-export type PickedResultStyle = "marker-only" | "full-geometry" | "full-geometry-including-polygon-center-marker";
-export type EnableReverse = "never" | "always" | "button";
-export type ShowPlaceType = "never" | "always" | "if-needed";
-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: {
-        reverse: boolean;
-    };
-    select: {
-        feature: Feature | undefined;
-    };
-};
-export type DispatcherType = {
-    [T in keyof DispatcherTypeCC as Lowercase<T>]: DispatcherTypeCC[T];
+    worldview?: Worldview;
 };
-export type RedefineType<OriginalType, UpdatedType extends {
-    [K in keyof OriginalType]: OriginalType[K];
-} & {
-    [K in Exclude<keyof UpdatedType, keyof OriginalType>]: never;
-}> = UpdatedType;
-export type TypeRule = string | [
-    minZoom: number | null | undefined,
-    maxZoom: number | null | undefined,
-    type: string
-];

package/dist/src/geocoder/geocoder.d.ts

@@ -0,0 +1,113 @@
+import { LitElement } from 'lit';
+import { BBox, EnableReverse, Feature, ProximityRule, ShowPlaceType, TypeRule, Worldview } from '../types';
+import { MaptilerGeocoderEventName, MaptilerGeocoderEventNameMap } from './geocoder-events';
+import { MaptilerGeocoderOptions } from './geocoder-options';
+export declare class MaptilerGeocoderElement extends LitElement implements MaptilerGeocoderOptions {
+    #private;
+    static styles: import('lit').CSSResult;
+    adjustUrl?: (url: URL) => void;
+    apiKey?: string;
+    apiUrl?: string;
+    bbox?: BBox;
+    clearButtonTitle?: string;
+    clearListOnPick: boolean;
+    clearOnBlur: boolean;
+    collapsed: boolean;
+    country?: string | string[];
+    debounceSearch?: number;
+    enableReverse?: EnableReverse;
+    errorMessage?: string;
+    excludeTypes: boolean;
+    exhaustiveReverseGeocoding: boolean;
+    fetchFullGeometryOnPick: boolean;
+    fetchParameters?: RequestInit;
+    filter?: (feature: Feature) => boolean;
+    fuzzyMatch?: boolean | undefined;
+    iconsBaseUrl?: string;
+    keepListOpen: boolean;
+    language?: string | string[] | null;
+    limit?: number;
+    minLength?: number;
+    noResultsMessage?: string;
+    openListOnTop: boolean;
+    placeholder?: string;
+    proximity?: ProximityRule[] | null;
+    reverseActive: boolean;
+    reverseButtonTitle?: string;
+    reverseGeocodingExcludeTypes?: boolean | undefined;
+    reverseGeocodingLimit?: number;
+    reverseGeocodingTypes?: TypeRule[];
+    selectFirst?: boolean | undefined;
+    showPlaceType?: ShowPlaceType;
+    showResultsWhileTyping?: boolean | undefined;
+    types?: TypeRule[];
+    worldview?: Worldview;
+    /** Reference to the input element the user can type a query into */
+    private input;
+    /** Value to search via geocoding */
+    private searchValue;
+    /** Features found via geocoding */
+    private listFeatures?;
+    /** Index of item currently selected from the list of found features */
+    private selectedItemIndex;
+    /** Feature that has been picked by the user */
+    private picked?;
+    /** Cached found features to be used to restore the features when loading more data for picked feature */
+    private cachedFeatures;
+    /** Effectively a cache key for cached features */
+    private lastSearchUrl;
+    /** Last error that happened in geocoding, to be shown to user */
+    private error;
+    /** AbortController instance used to potentially cancel the current geocoding request*/
+    private abortController?;
+    /** Focus state of input element */
+    private focused;
+    /** Focus state of input element, delayed for a moment to not close feature list immediately after losing focus */
+    private focusedDelayed;
+    protected firstUpdated(): void;
+    /**
+     * Set the options of this instance.
+     *
+     * @param options options to set
+     */
+    setOptions(options: Partial<MaptilerGeocoderOptions>): void;
+    /**
+     * Set the content of search input box.
+     *
+     * @param value text to set
+     */
+    setQuery(value: string): void;
+    /**
+     * Set the content of search input box and immediately submit it.
+     *
+     * @param value text to set and submit
+     */
+    submitQuery(value: string): void;
+    /**
+     * Clear search result list.
+     */
+    clearList(): void;
+    /**
+     * Focus the search input box.
+     *
+     * @param options [FocusOptions](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#options)
+     */
+    focus(options?: FocusOptions): void;
+    /**
+     * Blur the search input box.
+     */
+    blur(): void;
+    addEventListener<E extends MaptilerGeocoderEventName>(type: E, listener: (this: HTMLElement, e: MaptilerGeocoderEventNameMap[E]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<E extends MaptilerGeocoderEventName>(type: E, listener: (this: HTMLElement, e: MaptilerGeocoderEventNameMap[E]) => unknown, options?: boolean | EventListenerOptions): void;
+    /** @internal */
+    handleMapChange(centerAndZoom: [zoom: number, lon: number, lat: number] | undefined): void;
+    /** @internal */
+    handleMapClick(coordinates: [lng: number, lat: number]): void;
+    willUpdate(changedProperties: Map<string, unknown>): void;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "maptiler-geocoder": MaptilerGeocoderElement;
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from './components/clear-icon';
+export * from './components/fail-icon';
+export * from './components/loading-icon';
+export * from './components/reverse-geocoding-icon';
+export * from './components/search-icon';
+export * from './geocoder/geocoder';
+export * from './geocoder/geocoder-events';
+export * from './geocoder/geocoder-options';
+export * from './types';

package/dist/src/leaflet.public.d.ts

@@ -0,0 +1,7 @@
+export * from '.';
+export * from './components/marker';
+export * from './controls/leaflet-control';
+export { LeafletGeocodingControl as GeocodingControl } from './controls/leaflet-control';
+export type * as GeocodingControlEvent from './controls/leaflet-events';
+export * from './controls/leaflet-options';
+export type { LeafletGeocodingControlOptions as GeocodingControlOptions } from './controls/leaflet-options';

package/dist/src/maplibregl.d.ts

@@ -0,0 +1,7 @@
+export * from '.';
+export * from './components/marker';
+export * from './controls/maplibregl-control';
+export { MaplibreglGeocodingControl as GeocodingControl } from './controls/maplibregl-control';
+export type * as GeocodingControlEvent from './controls/maplibregl-events';
+export * from './controls/maplibregl-options';
+export type { MaplibreglGeocodingControlOptions as GeocodingControlOptions } from './controls/maplibregl-options';

package/dist/src/maptilersdk.d.ts

@@ -0,0 +1,7 @@
+export * from '.';
+export * from './components/marker';
+export * from './controls/maptilersdk-control';
+export { MaptilerGeocodingControl as GeocodingControl } from './controls/maptilersdk-control';
+export type * as GeocodingControlEvent from './controls/maptilersdk-events';
+export * from './controls/maptilersdk-options';
+export type { MaptilerGeocodingControlOptions as GeocodingControlOptions } from './controls/maptilersdk-options';

package/dist/src/openlayers.public.d.ts

@@ -0,0 +1,7 @@
+export * from '.';
+export * from './components/marker';
+export * from './controls/openlayers-control';
+export { OpenLayersGeocodingControl as GeocodingControl } from './controls/openlayers-control';
+export type * as GeocodingControlEvent from './controls/openlayers-events';
+export * from './controls/openlayers-options';
+export type { OpenLayersGeocodingControlOptions as GeocodingControlOptions } from './controls/openlayers-options';

package/dist/src/types.d.ts

@@ -0,0 +1,46 @@
+import { Feature as FeatureType, Geometry } from 'geojson';
+export type BBox = [minx: number, miny: number, maxx: number, maxy: number];
+export type Position = [x: number, y: number];
+export type Feature<T extends Geometry = Geometry> = FeatureType<T> & {
+    id: string;
+    text: string;
+    place_name: string;
+    place_type: string[];
+    place_type_name: string[];
+    center: Position;
+    bbox: BBox;
+    address?: string;
+    matching_text?: string;
+};
+export type FeatureCollection<T extends Geometry = Geometry> = {
+    type: "FeatureCollection";
+    features: Feature<T>[];
+};
+export type ProximityRule = {
+    /** minimal map zoom for the rule to be used */
+    minZoom?: number;
+    /** maximal map zoom for the rule to be used */
+    maxZoom?: number;
+} & ({
+    /** fixed proximity */
+    type: "fixed";
+    /** coordinates of the fixed proximity */
+    coordinates: Position;
+} | {
+    /** use map center coordinates for the proximity */
+    type: "map-center";
+} | {
+    /** resolve proximity by geolocating IP of the geocoding API call */
+    type: "server-geolocation";
+} | ({
+    /** use browser's geolocation API for proximity. If it fails, following proximity rules are iterated. */
+    type: "client-geolocation";
+    /** how long should the geolocation result be cached, in milliseconds */
+    cachedLocationExpiry?: number;
+} & PositionOptions));
+export type PickedResultStyle = "marker-only" | "full-geometry" | "full-geometry-including-polygon-center-marker";
+export type EnableReverse = "never" | "always" | "button";
+export type ShowPlaceType = "never" | "always" | "if-needed";
+export type TypeRule = PlaceType | [minZoom: number | null | undefined, maxZoom: number | null | undefined, type: PlaceType];
+export type PlaceType = "continental_marine" | "country" | "major_landform" | "region" | "subregion" | "county" | "joint_municipality" | "joint_submunicipality" | "municipality" | "municipal_district" | "locality" | "neighbourhood" | "place" | "postal_code" | "address" | "road" | "poi";
+export type Worldview = "ch" | "us" | "auto";

package/dist/src/utils/geo-utils.d.ts

@@ -0,0 +1,6 @@
+import { FeatureCollection, MultiPolygon, Polygon, Position } from 'geojson';
+import { BBox } from '../types';
+export declare function wrapNum(x: number, range: [number, number], includeMax: boolean): number;
+export declare function unwrapBbox(bbox0: BBox): BBox;
+export declare function shiftPolyCollection(featureCollection: FeatureCollection<Polygon | MultiPolygon>, distance: number): FeatureCollection<Polygon | MultiPolygon>;
+export declare function shiftPolyCoords(coordinates: Position[][], distance: number): void;

package/dist/src/utils/mask.d.ts

@@ -0,0 +1,2 @@
+import { Feature, FeatureCollection, MultiPolygon, Polygon } from 'geojson';
+export declare function getMask(picked: Feature<Polygon | MultiPolygon>): FeatureCollection<Polygon | MultiPolygon> | undefined;

package/dist/src/utils/proximity.d.ts

@@ -0,0 +1,2 @@
+import { ProximityRule } from '../types';
+export declare function getProximity(centerAndZoom: [zoom: number, lon: number, lat: number] | undefined, proximity: ProximityRule[] | null | undefined, ac: AbortController): Promise<string | undefined>;