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

package/svelte/maptilersdk.js

@@ -1,32 +0,0 @@
-import * as maptilersdk from "@maptiler/sdk";
-import { crateClasses, } from "./MapLibreBasedGeocodingControl";
-import { name, version } from "./info.json";
-export { createMapLibreGlMapController } from "./maplibregl-controller";
-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) {
-        map.telemetry?.registerModule(name, version);
-        return super.onAddInt(map);
-    }
-}
-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/mask.d.ts

@@ -1,2 +0,0 @@
-import type { Feature, FeatureCollection, MultiPolygon, Polygon } from "geojson";
-export declare function setMask(picked: Feature<Polygon | MultiPolygon>, setData: (data?: FeatureCollection<Polygon | MultiPolygon>) => void): void;

package/svelte/mask.js

@@ -1,54 +0,0 @@
-import bbox from "@turf/bbox";
-import difference from "@turf/difference";
-import flatten from "@turf/flatten";
-import { featureCollection, polygon } from "@turf/helpers";
-import union from "@turf/union";
-import { unwrapBbox } from "./geoUtils";
-export function setMask(picked, setData) {
-    const diff = difference(featureCollection([
-        polygon([
-            [
-                [180, 90],
-                [-180, 90],
-                [-180, -90],
-                [180, -90],
-                [180, 90],
-            ],
-        ]),
-        picked,
-    ]));
-    if (!diff) {
-        return;
-    }
-    diff.properties = { isMask: true };
-    const bb = unwrapBbox(bbox(picked));
-    // bigger features (continents, oceans) have bigger tolerance
-    // because of the used source data simplification
-    const tolerance = (bb[2] - bb[0]) / 360 / 1_000;
-    const leaksLeft = bb[0] < -180;
-    const leaksRight = bb[2] > 180;
-    const flattened = flatten(picked);
-    if (flattened.features.length > 1 && (leaksLeft || leaksRight)) {
-        for (const poly of flattened.features) {
-            const bb = unwrapBbox(bbox(poly));
-            if (leaksRight && bb[0] < -180 + tolerance) {
-                for (const ring of poly.geometry.coordinates) {
-                    for (const position of ring) {
-                        position[0] += 360 - tolerance;
-                    }
-                }
-            }
-            if (leaksLeft && bb[2] > 180 - tolerance) {
-                for (const ring of poly.geometry.coordinates) {
-                    for (const position of ring) {
-                        position[0] -= 360 - tolerance;
-                    }
-                }
-            }
-        }
-    }
-    setData(featureCollection([
-        flattened.features.length < 2 ? picked : (union(flattened) ?? picked),
-        diff,
-    ]));
-}

package/svelte/openlayers-controller.d.ts

@@ -1,15 +0,0 @@
-import type Map from "ol/Map";
-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): {
-    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;
-    setReverseMarker(coordinates?: Position): void;
-    setFeatures(markedFeatures: FeatureType[] | undefined, picked: FeatureType | undefined, showPolygonMarker: boolean): void;
-    setSelectedMarker(index: number): void;
-    getCenterAndZoom(): [number, x: number, y: number] | undefined;
-};

package/svelte/openlayers-controller.js

@@ -1,283 +0,0 @@
-import { Feature as OlFeature } from "ol";
-import { GeometryCollection as OlGeometryCollection, LineString as OlLineString, MultiLineString as OlMultiLineString, MultiPolygon as OlMultiPolygon, Point as OlPoint, Polygon as OlPolygon, } from "ol/geom";
-import VectorLayer from "ol/layer/Vector";
-import { fromLonLat, getUserProjection, toLonLat, transformExtent, } from "ol/proj";
-import VectorSource from "ol/source/Vector";
-import Fill from "ol/style/Fill";
-import Icon from "ol/style/Icon";
-import Stroke from "ol/style/Stroke";
-import Style, {} from "ol/style/Style";
-import Text from "ol/style/Text";
-import { setMask } from "./mask";
-const EPSG_4326 = "EPSG:4326";
-function defaultStyle(feature) {
-    const properties = feature.getProperties();
-    const { isMask } = properties;
-    const type = feature.getGeometry()?.getType();
-    const weight = isMask
-        ? 0
-        : type === "LineString" || type === "MultiLineString"
-            ? 3
-            : 2;
-    return new Style({
-        stroke: isMask
-            ? undefined
-            : new Stroke({
-                color: "#3170fe",
-                lineDash: [weight, weight],
-                width: weight,
-                lineCap: "butt",
-            }),
-        fill: isMask
-            ? new Fill({
-                color: "#00000020",
-            })
-            : undefined,
-        image: new Icon({
-            src: `/icons/marker_${properties.isReverse
-                ? "reverse"
-                : properties.isSelected
-                    ? "selected"
-                    : "unselected"}.svg`,
-            anchor: [0.5, 1],
-        }),
-        zIndex: properties.isSelected ? 2 : properties.isReverse ? 0 : 1,
-        text: properties.isSelected && properties.tooltip
-            ? new Text({
-                backgroundFill: new Fill({ color: "white" }),
-                text: properties.tooltip,
-                offsetY: -40,
-                backgroundStroke: new Stroke({
-                    color: "white",
-                    lineJoin: "round",
-                    width: 3,
-                }),
-                padding: [2, 0, 0, 2],
-            })
-            : undefined,
-    });
-}
-export function createOpenLayersMapController(map, flyToOptions = {}, flyToBounds = {}, fullGeometryStyle = defaultStyle) {
-    let prevSelected = -1;
-    let prevHovered;
-    let eventHandler;
-    let reverseMarker;
-    let indicatingReverse = false;
-    const vectorLayer = new VectorLayer({
-        updateWhileAnimating: true,
-    });
-    map.addLayer(vectorLayer);
-    const source = new VectorSource({});
-    vectorLayer.setSource(source);
-    vectorLayer.setStyle(fullGeometryStyle);
-    map.on("click", (e) => {
-        map.forEachFeatureAtPixel(e.pixel, (feature) => {
-            const id = feature.getId();
-            if (!id) {
-                return;
-            }
-            e.stopPropagation();
-            eventHandler?.({ type: "markerClick", id });
-            return feature;
-        });
-    });
-    map.on("pointermove", (e) => {
-        const featureId = map.forEachFeatureAtPixel(e.pixel, (feature) => {
-            return feature.getId();
-        });
-        if (prevHovered === featureId) {
-            return;
-        }
-        if (prevHovered) {
-            eventHandler?.({
-                type: "markerMouseLeave",
-                id: prevHovered,
-            });
-        }
-        if (featureId) {
-            eventHandler?.({
-                type: "markerMouseEnter",
-                id: featureId,
-            });
-        }
-        map.getTargetElement().style.cursor = featureId
-            ? "pointer"
-            : indicatingReverse
-                ? "crosshair"
-                : "";
-        prevHovered = featureId;
-    });
-    function getProjection() {
-        return getUserProjection() ?? map.getView().getProjection();
-    }
-    function fromWgs84(geometry) {
-        return geometry.transform(EPSG_4326, getProjection());
-    }
-    const handleMapClick = (e) => {
-        eventHandler?.({
-            type: "mapClick",
-            coordinates: toLonLat(e.coordinate, getProjection()),
-        });
-    };
-    return {
-        setEventHandler(handler) {
-            if (handler) {
-                eventHandler = handler;
-                map.on("click", handleMapClick);
-            }
-            else {
-                eventHandler = undefined;
-                map.un("click", handleMapClick);
-            }
-        },
-        flyTo(center, zoom) {
-            map.getView().animate({
-                center: fromLonLat(center, getProjection()),
-                ...(zoom ? { zoom } : {}),
-                duration: 2000,
-                ...flyToOptions,
-            });
-        },
-        fitBounds(bbox, padding, maxZoom) {
-            map.getView().fit(transformExtent(bbox, EPSG_4326, getProjection()), {
-                padding: [padding, padding, padding, padding],
-                ...(maxZoom ? { maxZoom } : {}),
-                duration: 2000,
-                ...flyToBounds,
-            });
-        },
-        indicateReverse(reverse) {
-            indicatingReverse = reverse;
-            map.getTargetElement().style.cursor = reverse ? "crosshair" : "";
-        },
-        setReverseMarker(coordinates) {
-            if (reverseMarker) {
-                if (!coordinates) {
-                    source.removeFeature(reverseMarker);
-                    reverseMarker.dispose();
-                    reverseMarker = undefined;
-                }
-                else {
-                    reverseMarker.getGeometry().setCoordinates(fromLonLat(coordinates, getProjection()));
-                }
-            }
-            else if (coordinates) {
-                reverseMarker = new OlFeature(new OlPoint(fromLonLat(coordinates, getProjection())));
-                reverseMarker.setProperties({ isReverse: true });
-                source.addFeature(reverseMarker);
-            }
-        },
-        setFeatures(markedFeatures, picked, showPolygonMarker) {
-            function setData(data) {
-                if (!data) {
-                    return;
-                }
-                for (const f of data.features) {
-                    const geom = f.geometry.type === "Polygon"
-                        ? new OlPolygon(f.geometry.coordinates)
-                        : f.geometry.type === "MultiPolygon"
-                            ? new OlMultiPolygon(f.geometry.coordinates)
-                            : null;
-                    if (!geom) {
-                        continue;
-                    }
-                    source.addFeature(new OlFeature({
-                        isMask: !!f.properties?.isMask,
-                        geometry: fromWgs84(geom),
-                    }));
-                }
-            }
-            source.clear();
-            if (reverseMarker) {
-                source.addFeature(reverseMarker);
-            }
-            block: if (picked) {
-                let handled = false;
-                if (picked.geometry.type === "GeometryCollection") {
-                    const geoms = picked.geometry.geometries
-                        .map((geometry) => geometry.type === "Polygon"
-                        ? new OlPolygon(geometry.coordinates)
-                        : geometry.type === "MultiPolygon"
-                            ? new OlMultiPolygon(geometry.coordinates)
-                            : null)
-                        .filter((a) => !!a);
-                    if (geoms.length > 0) {
-                        source.addFeature(new OlFeature(fromWgs84(new OlGeometryCollection(geoms))));
-                        handled = true;
-                    }
-                    else {
-                        for (const geometry of picked.geometry.geometries) {
-                            if (geometry.type === "LineString") {
-                                source.addFeature(new OlFeature(fromWgs84(new OlLineString(geometry.coordinates))));
-                                handled = true;
-                            }
-                            else if (geometry.type === "MultiLineString") {
-                                source.addFeature(new OlFeature(fromWgs84(new OlMultiLineString(geometry.coordinates))));
-                            }
-                            handled = true;
-                        }
-                    }
-                }
-                if (handled) {
-                    // nothing
-                }
-                else if (picked.geometry.type === "Polygon") {
-                    setMask(picked, setData);
-                }
-                else if (picked.geometry.type === "MultiPolygon") {
-                    setMask(picked, setData);
-                }
-                else if (picked.geometry.type === "LineString") {
-                    source.addFeature(new OlFeature(fromWgs84(new OlLineString(picked.geometry.coordinates))));
-                    break block; // no pin for (multi)linestrings
-                }
-                else if (picked.geometry.type === "MultiLineString") {
-                    source.addFeature(new OlFeature(fromWgs84(new OlMultiLineString(picked.geometry.coordinates))));
-                    break block; // no pin for (multi)linestrings
-                }
-                if (!showPolygonMarker && !picked.geometry.type.endsWith("Point")) {
-                    break block;
-                }
-                source.addFeature(new OlFeature(fromWgs84(new OlPoint(picked.center))));
-            }
-            for (const feature of markedFeatures ?? []) {
-                if (feature === picked) {
-                    continue;
-                }
-                const marker = new OlFeature(new OlPoint(fromLonLat(feature.center, getProjection())));
-                marker.setId(feature.id);
-                marker.setProperties({
-                    fuzzy: !!feature.matching_text,
-                    tooltip: feature.place_type[0] === "reverse"
-                        ? feature.place_name
-                        : feature.place_name.replace(/,.*/, ""),
-                });
-                source.addFeature(marker);
-            }
-        },
-        setSelectedMarker(index) {
-            const features = source.getFeatures();
-            const offset = features[0]?.getProperties().isReverse ? 1 : 0;
-            if (prevSelected > -1) {
-                features[prevSelected + offset]?.setProperties({
-                    isSelected: false,
-                });
-            }
-            if (index > -1) {
-                features[index + offset]?.setProperties({
-                    isSelected: true,
-                });
-            }
-            prevSelected = index;
-        },
-        getCenterAndZoom() {
-            const view = map.getView();
-            const center = view.getCenter();
-            const zoom = view.getZoom();
-            if (!center || zoom === undefined) {
-                return undefined;
-            }
-            return [zoom, ...toLonLat(center, getProjection())];
-        },
-    };
-}

package/svelte/openlayers.d.ts

@@ -1,109 +0,0 @@
-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";
-import type { ControlOptions, Feature, FeatureCollection } from "./types";
-export { createOpenLayersMapController } from "./openlayers-controller";
-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;
-    /**
-     * Update the control options.
-     *
-     * @param options options to update
-     */
-    setOptions(options: OpenLayersControlOptions): void;
-    /**
-     * Set the content of search input box.
-     *
-     * @param value text to set
-     * @param submit perform the search
-     */
-    setQuery(value: string, submit?: boolean): void;
-    /**
-     * Clear geocoding search results from the map.
-     */
-    clearMap(): void;
-    /**
-     * Clear search result list.
-     */
-    clearList(): void;
-    /**
-     * Set reverse geocoding mode.
-     *
-     * @param reverseActive reverse geocoding active
-     */
-    setReverseMode(reverseActive: boolean): 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;
-}
-export declare class SelectEvent extends BaseEvent {
-    feature: Feature | undefined;
-    constructor(feature: Feature | undefined);
-}
-export declare class FeaturesListedEvent extends BaseEvent {
-    features: Feature[] | undefined;
-    constructor(features: Feature[] | undefined);
-}
-export declare class FeaturesMarkedEvent extends BaseEvent {
-    features: Feature[] | undefined;
-    constructor(features: Feature[] | undefined);
-}
-export declare class OptionsVisibilityChangeEvent extends BaseEvent {
-    optionsVisible: boolean;
-    constructor(optionsVisible: boolean);
-}
-export declare class PickEvent extends BaseEvent {
-    feature: Feature | undefined;
-    constructor(feature: Feature | undefined);
-}
-export declare class QueryChangeEvent extends BaseEvent {
-    query: string;
-    constructor(query: string);
-}
-export declare class ResponseEvent extends BaseEvent {
-    url: string;
-    featureCollection: FeatureCollection;
-    constructor(url: string, featureCollection: FeatureCollection);
-}
-export declare class ReverseToggleEvent extends BaseEvent {
-    reverse: boolean;
-    constructor(reverse: boolean);
-}

package/svelte/openlayers.js

@@ -1,178 +0,0 @@
-import { Control } from "ol/control";
-import BaseEvent from "ol/events/Event";
-import GeocodingControlComponent from "./GeocodingControl.svelte";
-import { createOpenLayersMapController } from "./openlayers-controller";
-export { createOpenLayersMapController } from "./openlayers-controller";
-export class GeocodingControl extends Control {
-    #gc;
-    #options;
-    constructor(options) {
-        const div = document.createElement("div");
-        div.className = "ol-search";
-        super({
-            element: div,
-            target: options.target,
-        });
-        const { flyTo, fullGeometryStyle, ...restOptions } = options;
-        this.#gc = new GeocodingControlComponent({
-            target: div,
-            props: {
-                flyTo: flyTo === undefined ? true : !!flyTo,
-                ...restOptions,
-            },
-        });
-        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) {
-        super.setMap(map);
-        if (map) {
-            const { 
-            // marker,
-            // showResultMarkers,
-            flyTo, fullGeometryStyle, } = this.#options;
-            const mapController = createOpenLayersMapController(map, typeof flyTo === "boolean" ? undefined : flyTo, typeof flyTo === "boolean" ? undefined : flyTo, 
-            // marker,
-            // showResultMarkers,
-            fullGeometryStyle);
-            this.#gc?.$set({ mapController });
-        }
-    }
-    /**
-     * Update the control options.
-     *
-     * @param options options to update
-     */
-    setOptions(options) {
-        Object.assign(this.#options, options);
-        const { flyTo, fullGeometryStyle, ...restOptions } = this.#options;
-        this.#gc?.$set({
-            ...restOptions,
-            flyTo: flyTo === undefined ? true : !!flyTo,
-        });
-    }
-    /**
-     * Set the content of search input box.
-     *
-     * @param value text to set
-     * @param submit perform the search
-     */
-    setQuery(value, submit = true) {
-        this.#gc?.setQuery(value, submit);
-    }
-    /**
-     * Clear geocoding search results from the map.
-     */
-    clearMap() {
-        this.#gc?.clearMap();
-    }
-    /**
-     * Clear search result list.
-     */
-    clearList() {
-        this.#gc?.clearList();
-    }
-    /**
-     * Set reverse geocoding mode.
-     *
-     * @param reverseActive reverse geocoding active
-     */
-    setReverseMode(reverseActive) {
-        this.#gc?.$set({ reverseActive });
-    }
-    /**
-     * Focus the search input box.
-     *
-     * @param options [FocusOptions](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#options)
-     */
-    focus(options) {
-        this.#gc?.focus(options);
-    }
-    /**
-     * Blur the search input box.
-     */
-    blur() {
-        this.#gc?.blur();
-    }
-}
-export class SelectEvent extends BaseEvent {
-    feature;
-    constructor(feature) {
-        super("select");
-        this.feature = feature;
-    }
-}
-export class FeaturesListedEvent extends BaseEvent {
-    features;
-    constructor(features) {
-        super("featureslisted");
-        this.features = features;
-    }
-}
-export class FeaturesMarkedEvent extends BaseEvent {
-    features;
-    constructor(features) {
-        super("featuresmarked");
-        this.features = features;
-    }
-}
-export class OptionsVisibilityChangeEvent extends BaseEvent {
-    optionsVisible;
-    constructor(optionsVisible) {
-        super("optionsvisibilitychange");
-        this.optionsVisible = optionsVisible;
-    }
-}
-export class PickEvent extends BaseEvent {
-    feature;
-    constructor(feature) {
-        super("pick");
-        this.feature = feature;
-    }
-}
-export class QueryChangeEvent extends BaseEvent {
-    query;
-    constructor(query) {
-        super("querychange");
-        this.query = query;
-    }
-}
-export class ResponseEvent extends BaseEvent {
-    url;
-    featureCollection;
-    constructor(url, featureCollection) {
-        super("response");
-        this.url = url;
-        this.featureCollection = featureCollection;
-    }
-}
-export class ReverseToggleEvent extends BaseEvent {
-    reverse;
-    constructor(reverse) {
-        super("reversetoggle");
-        this.reverse = reverse;
-    }
-}

package/svelte/proximity.d.ts

@@ -1,2 +0,0 @@
-import type { MapController, ProximityRule } from "./types";
-export declare function getProximity(mapController: MapController | undefined, proximity: ProximityRule[] | null | undefined, ac: AbortController): Promise<string | undefined>;