@geosdi/ngx-geocoding 1.2.1 → 2.0.0

package/fesm2022/geosdi-ngx-geocoding.mjs

@@ -1,584 +1,344 @@
-import * as i0 from '@angular/core';
-import { NgModule, InjectionToken, inject, Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { Subject, of, from, throwError, Observable } from 'rxjs';
-import { catchError, switchMap, map, tap } from 'rxjs/operators';
-
-/**
- * @author Vito Salvia - CNR IMAA geoSDI Group
- * @email vito.salvia@gmail.com
- */
-class NgxGeocodingModule {
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NgxGeocodingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: NgxGeocodingModule }); }
-    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NgxGeocodingModule }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NgxGeocodingModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [],
-                    imports: [],
-                    exports: [],
-                }]
-        }] });
-
-/**
- * @author Vito Salvia - CNR IMAA geoSDI Group
- * @email vito.salvia@gmail.com
- */
-/**
- * La configurazione della ricerca, che **può non esserci** : in quel caso vale
- * il comportamento storico, cioè Nominatim e basta.
- */
+import * as i0 from "@angular/core";
+import { Injectable, InjectionToken, NgModule, inject } from "@angular/core";
+import { HttpClient } from "@angular/common/http";
+import { Observable, Subject, from, of, throwError } from "rxjs";
+import { catchError, map, switchMap, tap } from "rxjs/operators";
+var NgxGeocodingModule = class NgxGeocodingModule {
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.4",
+			ngImport: i0,
+			type: NgxGeocodingModule,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.NgModule
+		});
+	}
+	static {
+		this.ɵmod = i0.ɵɵngDeclareNgModule({
+			minVersion: "14.0.0",
+			version: "22.2.4",
+			ngImport: i0,
+			type: NgxGeocodingModule
+		});
+	}
+	static {
+		this.ɵinj = i0.ɵɵngDeclareInjector({
+			minVersion: "12.0.0",
+			version: "22.2.4",
+			ngImport: i0,
+			type: NgxGeocodingModule
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: NgxGeocodingModule,
+	decorators: [{
+		type: NgModule,
+		args: [{
+			declarations: [],
+			imports: [],
+			exports: []
+		}]
+	}]
+});
 const NGX_GEOCODING_CONFIG = new InjectionToken("NGX_GEOCODING_CONFIG");
-/**
- * Dichiara da dove arrivano gli indirizzi, nei `providers` dell'applicazione :
- *
- * ```ts
- * provideNgxGeocoding({
- *     sources: ["google", "nominatim"],
- *     country: "it",
- *     bias: { lat: 40.83, lon: 14.11, radiusM: 25_000 },
- * })
- * ```
- *
- * L'ordine è quello in cui le sorgenti si provano, e una che non è utilizzabile
- * si salta : la stessa riga vale quindi per il deploy che ha la chiave Google e
- * per quello che non ce l'ha.
- *
- * Chi non la chiama non cambia niente.
- */
 function provideNgxGeocoding(config) {
-    return { provide: NGX_GEOCODING_CONFIG, useValue: config };
+	return {
+		provide: NGX_GEOCODING_CONFIG,
+		useValue: config
+	};
 }
-
-/**
- * L'SDK Maps JS dell'applicazione ospite, e l'attesa perché sia pronto.
- *
- * **Questa libreria non lo carica** : il tag lo mette in pagina chi la usa, con
- * la propria chiave —
- *
- * ```html
- * <script defer src="https://maps.googleapis.com/maps/api/js?key=…&libraries=places&language=it"></script>
- * ```
- *
- * — e le ragioni perché resti così sono due : la chiave è dell'applicazione e
- * non deve passare di qui, e caricarlo una seconda volta vorrebbe dire due
- * copie dell'SDK nella stessa pagina.
- *
- * Serve però **aspettarlo** : quel tag è di norma `defer`, quindi chi cerca un
- * indirizzo subito dopo l'avvio può arrivare prima di lui.
- *
- * Della query contano due parametri : `libraries=places`, senza cui non c'è
- * niente da aspettare, e `language`, che decide la lingua delle proposte —
- * `getPlacePredictions` non ha un parametro per chiederla.
- *
- * @author Vito Salvia - CNR IMAA geoSDI Group
- * @email vito.salvia@gmail.com
- */
-/** Quanto si aspetta l'SDK prima di rinunciare, e ogni quanto lo si guarda. */
 const ATTESA = {
-    tetto_ms: 10_000,
-    passo_ms: 100,
+	tetto_ms: 1e4,
+	passo_ms: 100
 };
-/** Gli stati dell'SDK su cui si decide qualcosa. */
 const STATO_PLACES = {
-    ok: "OK",
-    nessuno: "ZERO_RESULTS",
-    negato: "REQUEST_DENIED",
-    quota: "OVER_QUERY_LIMIT",
+	ok: "OK",
+	nessuno: "ZERO_RESULTS",
+	negato: "REQUEST_DENIED",
+	quota: "OVER_QUERY_LIMIT"
 };
-/** La libreria `places` se è già in pagina, `undefined` altrimenti. */
 function places() {
-    return window.google?.maps?.places;
+	return window.google?.maps?.places;
 }
-/** Il costruttore del `Geocoder`, che sta nell'SDK di base. */
 function geocoder() {
-    return window.google?.maps?.Geocoder;
+	return window.google?.maps?.Geocoder;
 }
-/**
- * La libreria `places`, aspettando che l'SDK finisca di caricarsi.
- *
- * Rifiuta dopo {@link ATTESA} : il chiamante ripiega sulla strada successiva,
- * perché una ricerca che non risponde mai è peggio di una che risponde meno
- * bene. Il motivo tipico di un'attesa che scade è che al tag dello script manchi
- * `libraries=places` — l'SDK c'è, ma quella libreria no.
- */
 function attendiPlaces() {
-    return attendi(places, "la libreria 'places' (manca `libraries=places` ?)");
+	return attendi(places, "la libreria 'places' (manca `libraries=places` ?)");
 }
-/**
- * Il `Geocoder`, aspettando l'SDK.
- *
- * **Non vuole `libraries=places`** : sta nell'SDK di base, ed è la ragione per
- * cui regge da ultima spiaggia anche dove Places non è disponibile.
- */
 function attendiGeocoder() {
-    return attendi(geocoder, "il Geocoder").then((costruttore) => new costruttore());
+	return attendi(geocoder, "il Geocoder").then((costruttore) => new costruttore());
 }
-/** L'attesa vera, uguale per le due parti dell'SDK. */
 function attendi(cerca, cosa) {
-    const gia = cerca();
-    if (gia)
-        return Promise.resolve(gia);
-    return new Promise((risolvi, rifiuta) => {
-        const scadenza = Date.now() + ATTESA.tetto_ms;
-        const attesa = setInterval(() => {
-            const pronto = cerca();
-            if (pronto) {
-                clearInterval(attesa);
-                risolvi(pronto);
-                return;
-            }
-            if (Date.now() > scadenza) {
-                clearInterval(attesa);
-                rifiuta(new Error(`SDK Maps senza ${cosa}`));
-            }
-        }, ATTESA.passo_ms);
-    });
+	const gia = cerca();
+	if (gia) return Promise.resolve(gia);
+	return new Promise((risolvi, rifiuta) => {
+		const scadenza = Date.now() + ATTESA.tetto_ms;
+		const attesa = setInterval(() => {
+			const pronto = cerca();
+			if (pronto) {
+				clearInterval(attesa);
+				risolvi(pronto);
+				return;
+			}
+			if (Date.now() > scadenza) {
+				clearInterval(attesa);
+				rifiuta(/* @__PURE__ */ new Error(`SDK Maps senza ${cosa}`));
+			}
+		}, ATTESA.passo_ms);
+	});
 }
-
-/**
- * @author Vito Salvia - CNR IMAA geoSDI Group
- * @email vito.salvia@gmail.com
- */
-/** Il servizio pubblico di OpenStreetMap, quando non se ne dichiara un altro. */
 const NOMINATIM = "https://nominatim.openstreetmap.org/search.php";
-/** Le sorgenti da provare quando l'applicazione non dice niente. */
 const SOLO_NOMINATIM = ["nominatim"];
-/** Quanti metri fa un grado di latitudine, per il riquadro del Geocoder. */
-const METRI_PER_GRADO = 111_320;
-/**
- * La ricerca di indirizzi, da una o più sorgenti.
- *
- * **Senza configurazione fa quello che ha sempre fatto** : interroga Nominatim,
- * che non vuole nessuna chiave. Google si accende con
- * `provideNgxGeocoding({ sources: ["google", "nominatim"] })`, e vuole che
- * l'applicazione abbia in pagina l'**SDK Maps** con `libraries=places`.
- *
- * **Perché l'SDK e non una chiamata a Google**, che è la cosa da sapere prima
- * di «semplificare» questo codice : delle API di Google dal browser si può
- * chiamare la sola **Places (New)**, l'unica che esponga CORS, e quel prodotto
- * va abilitato a parte sul progetto Cloud — dove non lo è, una `fetch` prende
- * `403 SERVICE_DISABLED`. **Places legacy** e **Geocoding** CORS non ce l'hanno
- * affatto, ma l'SDK le raggiunge da sé : passando da lui la ricerca funziona
- * con le abilitazioni che il progetto ha già.
- *
- * Dentro `google` c'è quindi una **cascata**, ed è la stessa che si scriverebbe
- * lato server :
- *
- * 1. **`AutocompleteSuggestion`** (Places **New**), che è la strada
- *    raccomandata da Google dal 1° marzo 2025 e l'unica offerta ai progetti
- *    nuovi. Sotto sta un prodotto che va **abilitato a parte** sulla console
- *    Cloud : dove non lo è risponde `403`, e si scende;
- * 2. **`AutocompleteService`** (Places legacy), che dà le stesse proposte
- *    incrementali. Google la dà per deprecata — «non disponibile per i nuovi
- *    clienti», con dodici mesi di preavviso prima di spegnerla — ma è quella
- *    che risponde sui progetti dove la New non è stata abilitata;
- * 3. **`Geocoder`**, quando nemmeno Places risponde : nessuna proposta
- *    incrementale, di norma un risultato solo, ma **porta già le coordinate** e
- *    sta nell'SDK di base, quindi non dipende da `libraries=places`.
- *
- * I gradini si scendono da sé e non si risalgono nella stessa sessione. Il
- * primo è in cima **anche se oggi, su un progetto senza la New, fallisce
- * sempre** : costa una richiesta negata per sessione, e il giorno in cui quel
- * prodotto viene abilitato la ricerca si sposta sulla strada giusta senza che
- * nessuno tocchi il codice.
- *
- * **Le proposte di Places non portano le coordinate**, che si chiedono per il
- * solo luogo scelto : vedi {@link resolve}, ed è il motivo per cui esiste.
- */
-class NgxGeocodingService {
-    constructor() {
-        this.subjectLocation = new Subject();
-        this.subjectNoResults = new Subject();
-        this.subjectRemove = new Subject();
-        this.http = inject(HttpClient);
-        this.config = inject(NGX_GEOCODING_CONFIG, {
-            optional: true,
-        });
-        /**
-         * Una sorgente che ha detto di no non si richiama per il resto della
-         * sessione : chiave senza il prodotto abilitato, referrer fuori dalle
-         * restrizioni, quota. Senza questo sarebbe una richiesta negata a ogni
-         * tasto premuto.
-         */
-        this.spente = new Set();
-        /**
-         * Dentro `google`, i gradini già scesi : `AutocompleteSuggestion` (Places
-         * New) e `AutocompleteService` (Places legacy). Da lì in poi si parte
-         * direttamente da dove si era arrivati.
-         */
-        this.suggestionSpenta = false;
-        this.placesSpenta = false;
-    }
-    /**
-     * Le proposte per quello che si sta digitando, dalla prima sorgente che
-     * risponde.
-     *
-     * @param address il testo digitato
-     */
-    geocode(address) {
-        return this.daSorgenti(address, this.sorgenti());
-    }
-    /**
-     * Le coordinate del luogo **scelto**, chieste solo adesso.
-     *
-     * Le proposte di Places arrivano senza, e risolverle tutte a ogni tasto
-     * premuto vorrebbe dire una richiesta di dettaglio per proposta. Chi le ha
-     * già — Nominatim le manda sempre, e il `Geocoder` pure — non paga niente e
-     * si riprende il luogo così com'è, quindi **chiamarla è sempre corretto** :
-     * è la riga da mettere dove si sceglie una proposta, prima di usarne `lat`
-     * e `lon`.
-     *
-     * Fallendo restituisce il luogo com'è, senza coordinate : chi ha chiamato
-     * lo sa già gestire, ed è meglio che muovere una mappa a caso.
-     *
-     * @param place la proposta scelta fra quelle di {@link geocode}
-     */
-    resolve(place) {
-        if (!place?.place_id || (place.lat && place.lon))
-            return of(place);
-        if (this.spente.has("google"))
-            return of(place);
-        if (!this.sorgenti().includes("google"))
-            return of(place);
-        // Lo stesso ordine delle proposte : chi le ha date sa dare anche il
-        // dettaglio, e chiedere il dettaglio a Places (New) quando le proposte
-        // sono arrivate dalla legacy sarebbe una richiesta negata in più.
-        if (!this.suggestionSpenta) {
-            return this.luogoDaSuggestion(place).pipe(catchError((err) => {
-                this.suggestionSpenta = true;
-                console.warn("[ngx-geocoding] dettaglio da Places (New) non " +
-                    `riuscito, si prova la legacy — ${this.perche(err)}`);
-                return this.luogoDaLegacy(place);
-            }));
-        }
-        if (this.placesSpenta)
-            return of(place);
-        return this.luogoDaLegacy(place);
-    }
-    /**
-     * Le coordinate con **Places (New)** : `Place` nasce con l'id e
-     * `fetchFields` lo **riempie**, quindi i campi si leggono dall'oggetto
-     * dopo l'attesa e non dal valore restituito.
-     */
-    luogoDaSuggestion(place) {
-        return from(attendiPlaces()).pipe(switchMap((places) => {
-            const Luogo = places.Place;
-            if (!Luogo) {
-                return throwError(() => new Error("Place non c'è in questo SDK"));
-            }
-            const luogo = new Luogo({
-                id: place.place_id,
-            });
-            return from(luogo.fetchFields({
-                fields: ["location", "formattedAddress"],
-            })).pipe(map(() => ({
-                ...place,
-                display_name: place.display_name ?? luogo.formattedAddress ?? "",
-                lat: this.testo(luogo.location?.lat()),
-                lon: this.testo(luogo.location?.lng()),
-            })));
-        }));
-    }
-    /** Le coordinate con **Places legacy**, cioè `PlacesService.getDetails`. */
-    luogoDaLegacy(place) {
-        return from(attendiPlaces()).pipe(switchMap((places) => new Observable((chi) => {
-            new places.PlacesService(document.createElement("div")).getDetails({
-                placeId: place.place_id,
-                fields: ["geometry", "formatted_address"],
-            }, (luogo, stato) => {
-                if (stato !== STATO_PLACES.ok || !luogo) {
-                    chi.error(new Error(stato));
-                    return;
-                }
-                const punto = luogo.geometry?.location;
-                chi.next({
-                    ...place,
-                    display_name: place.display_name ??
-                        luogo.formatted_address ??
-                        "",
-                    lat: this.testo(punto?.lat()),
-                    lon: this.testo(punto?.lng()),
-                });
-                chi.complete();
-            });
-        })), catchError((err) => {
-            console.warn("[ngx-geocoding] coordinate del luogo non risolte — " +
-                this.perche(err));
-            return of(place);
-        }));
-    }
-    /**
-     * Prova le sorgenti in ordine, passando alla successiva quando una rifiuta.
-     *
-     * Finite le sorgenti si rilancia un errore invece di restituire un elenco
-     * vuoto : «non ho trovato niente» e «non ho potuto cercare» sono due cose
-     * diverse, e chi mostra la barra deve poterle distinguere.
-     */
-    daSorgenti(address, restanti) {
-        const sorgente = restanti[0];
-        if (!sorgente) {
-            return throwError(() => new Error("Nessuna sorgente di geocoding disponibile"));
-        }
-        const dopo = restanti.slice(1);
-        if (this.spente.has(sorgente))
-            return this.daSorgenti(address, dopo);
-        const richiesta = sorgente === "google"
-            ? this.daGoogle(address)
-            : this.daNominatim(address);
-        return richiesta.pipe(tap((luoghi) => {
-            if (luoghi.length <= 0) {
-                this.subjectNoResults.next(null);
-            }
-        }), catchError((err) => {
-            this.spente.add(sorgente);
-            console.warn(`[ngx-geocoding] sorgente "${sorgente}" non utilizzabile, ` +
-                `non la si richiede più — ${this.perche(err)}`);
-            return this.daSorgenti(address, dopo);
-        }));
-    }
-    /**
-     * Nominatim, **identico a come questa libreria l'ha sempre chiamato** : è
-     * il comportamento su cui contano le applicazioni che la usavano prima che
-     * Google esistesse qui dentro.
-     */
-    daNominatim(address) {
-        const encoded = encodeURIComponent(address);
-        const base = this.config?.nominatimUrl ?? NOMINATIM;
-        return this.http
-            .get(`${base}?q=${encoded}&format=jsonv2`)
-            .pipe(map((res) => res.map((item) => ({
-            display_name: item.display_name,
-            lat: item.lat,
-            lon: item.lon,
-            place_id: item.place_id,
-        }))));
-    }
-    /**
-     * Google : le proposte di Places, e il `Geocoder` quando Places dice di no.
-     *
-     * `ZERO_RESULTS` **non** è un rifiuto : è una ricerca senza esiti, e
-     * confonderlo con un errore farebbe scivolare al `Geocoder` — e poi fuori
-     * da Google — alla prima ricerca sfortunata.
-     */
-    daGoogle(address) {
-        if (this.suggestionSpenta)
-            return this.dallaLegacy(address);
-        return this.daSuggestion(address).pipe(catchError((err) => {
-            this.suggestionSpenta = true;
-            console.warn("[ngx-geocoding] Places (New) non utilizzabile, si prova " +
-                `quella legacy — ${this.perche(err)}`);
-            return this.dallaLegacy(address);
-        }));
-    }
-    /** Il secondo e il terzo gradino : Places legacy, poi il `Geocoder`. */
-    dallaLegacy(address) {
-        if (this.placesSpenta)
-            return this.daGeocoder(address);
-        return this.daPlaces(address).pipe(catchError((err) => {
-            this.placesSpenta = true;
-            console.warn("[ngx-geocoding] Places legacy non utilizzabile, si prova " +
-                `il Geocoder — ${this.perche(err)}`);
-            return this.daGeocoder(address);
-        }));
-    }
-    /**
-     * Le proposte di **Places (New)**, con `AutocompleteSuggestion`.
-     *
-     * Due cose che non si vedono dalla firma : `text` di una proposta non è una
-     * stringa ma un oggetto formattabile, e va letto con `toString()` — messo
-     * in un template darebbe `[object Object]` ; e un elenco **vuoto non è un
-     * errore**, è una ricerca senza esiti, quindi non fa scendere di gradino.
-     *
-     * Se la classe non c'è nell'SDK — versione più vecchia — si solleva subito,
-     * che è il modo di scendere senza aspettare una risposta che non arriverà.
-     */
-    daSuggestion(address) {
-        const paese = this.config?.country;
-        const cerchio = this.cerchio();
-        return from(attendiPlaces()).pipe(switchMap((places) => {
-            const nuova = places.AutocompleteSuggestion;
-            if (!nuova) {
-                return throwError(() => new Error("AutocompleteSuggestion non c'è in questo SDK"));
-            }
-            return from(nuova.fetchAutocompleteSuggestions({
-                input: address,
-                ...(paese
-                    ? { includedRegionCodes: [paese], region: paese }
-                    : {}),
-                ...(cerchio ? { locationBias: cerchio } : {}),
-            })).pipe(map((risposta) => (risposta?.suggestions ?? [])
-                .map((s) => s.placePrediction)
-                .filter((p) => !!p?.placeId)
-                .map((p) => ({
-                place_id: p.placeId,
-                display_name: p.text?.toString() ?? "",
-            }))));
-        }));
-    }
-    /** Le proposte incrementali di `AutocompleteService`. */
-    daPlaces(address) {
-        const paese = this.config?.country;
-        const cerchio = this.cerchio();
-        return from(attendiPlaces()).pipe(switchMap((places) => new Observable((chi) => {
-            new places.AutocompleteService().getPlacePredictions({
-                input: address,
-                ...(paese
-                    ? {
-                        componentRestrictions: {
-                            country: paese,
-                        },
-                    }
-                    : {}),
-                ...(cerchio ? { locationBias: cerchio } : {}),
-            }, (proposte, stato) => {
-                if (stato === STATO_PLACES.nessuno) {
-                    chi.next([]);
-                    chi.complete();
-                    return;
-                }
-                if (stato !== STATO_PLACES.ok) {
-                    chi.error(new Error(stato));
-                    return;
-                }
-                chi.next((proposte ?? [])
-                    .filter((p) => !!p.place_id)
-                    .map((p) => ({
-                    place_id: p.place_id,
-                    display_name: p.description ?? "",
-                })));
-                chi.complete();
-            });
-        })));
-    }
-    /**
-     * Il `Geocoder`, l'ultima strada di Google.
-     *
-     * I suoi risultati **portano già le coordinate**, quindi su questi
-     * {@link resolve} non fa nessuna richiesta in più.
-     */
-    daGeocoder(address) {
-        const paese = this.config?.country;
-        const riquadro = this.riquadro();
-        return from(attendiGeocoder()).pipe(switchMap((geocoder) => new Observable((chi) => {
-            geocoder.geocode({
-                address,
-                ...(paese
-                    ? {
-                        componentRestrictions: {
-                            country: paese,
-                        },
-                        region: paese,
-                    }
-                    : {}),
-                ...(riquadro ? { bounds: riquadro } : {}),
-            }, (risultati, stato) => {
-                if (stato === STATO_PLACES.nessuno) {
-                    chi.next([]);
-                    chi.complete();
-                    return;
-                }
-                if (stato !== STATO_PLACES.ok) {
-                    chi.error(new Error(stato));
-                    return;
-                }
-                chi.next((risultati ?? []).map((r) => ({
-                    place_id: r.place_id,
-                    display_name: r.formatted_address ?? "",
-                    lat: this.testo(r.geometry?.location?.lat()),
-                    lon: this.testo(r.geometry?.location?.lng()),
-                })));
-                chi.complete();
-            });
-        })));
-    }
-    /** Il bias come lo vuole `AutocompleteService`. */
-    cerchio() {
-        const bias = this.config?.bias;
-        return bias
-            ? {
-                center: { lat: bias.lat, lng: bias.lon },
-                radius: bias.radiusM,
-            }
-            : undefined;
-    }
-    /**
-     * Il bias come lo vuole il `Geocoder`, che prende un **riquadro** e non un
-     * cerchio : lo si iscrive attorno al punto. La longitudine si stringe con
-     * la latitudine (`cos`), o alle nostre latitudini il riquadro verrebbe
-     * largo un terzo in più del voluto.
-     */
-    riquadro() {
-        const bias = this.config?.bias;
-        if (!bias)
-            return undefined;
-        const dLat = bias.radiusM / METRI_PER_GRADO;
-        const dLon = dLat / Math.max(Math.cos((bias.lat * Math.PI) / 180), 0.01);
-        return {
-            north: bias.lat + dLat,
-            south: bias.lat - dLat,
-            east: bias.lon + dLon,
-            west: bias.lon - dLon,
-        };
-    }
-    /** Le sorgenti dichiarate, o quella storica. */
-    sorgenti() {
-        const dichiarate = this.config?.sources ?? [];
-        return dichiarate.length ? dichiarate : SOLO_NOMINATIM;
-    }
-    /**
-     * Perché una strada ha detto di no, in una riga : dall'SDK arriva uno stato
-     * (`REQUEST_DENIED` per la chiave senza il prodotto abilitato o per il
-     * referrer, `OVER_QUERY_LIMIT` per la quota), da una http il corpo
-     * d'errore. Senza questo il motivo resta dentro un oggetto che in console
-     * va aperto, e si legge solo «si ripiega».
-     */
-    perche(err) {
-        if (err instanceof Error && err.message)
-            return err.message;
-        const dettaglio = err?.error?.error;
-        if (!dettaglio)
-            return "motivo non dichiarato";
-        return [dettaglio.status, dettaglio.message]
-            .filter((pezzo) => !!pezzo)
-            .join(" : ");
-    }
-    /**
-     * Una coordinata come stringa, o `undefined` se non c'è.
-     *
-     * `String(undefined)` darebbe `"undefined"`, che passerebbe indenne per
-     * ogni controllo di presenza e morirebbe in `Number()` — cioè una mappa
-     * portata su `NaN, NaN` senza che niente lo dica.
-     */
-    testo(valore) {
-        return valore === null || valore === undefined
-            ? undefined
-            : String(valore);
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NgxGeocodingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NgxGeocodingService, providedIn: "root" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NgxGeocodingService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: "root",
-                }]
-        }] });
-
-/**
- * @author Vito Salvia - CNR IMAA geoSDI Group
- * @email vito.salvia@gmail.com
- */
-
-/*
- * Public API Surface of ngx-geocoding
- */
-
-/**
- * Generated bundle index. Do not edit.
- */
-
+const METRI_PER_GRADO = 111320;
+var NgxGeocodingService = class NgxGeocodingService {
+	constructor() {
+		this.subjectLocation = new Subject();
+		this.subjectNoResults = new Subject();
+		this.subjectRemove = new Subject();
+		this.http = inject(HttpClient);
+		this.config = inject(NGX_GEOCODING_CONFIG, { optional: true });
+		this.spente = /* @__PURE__ */ new Set();
+		this.suggestionSpenta = false;
+		this.placesSpenta = false;
+	}
+	geocode(address) {
+		return this.daSorgenti(address, this.sorgenti());
+	}
+	resolve(place) {
+		if (!place?.place_id || place.lat && place.lon) return of(place);
+		if (this.spente.has("google")) return of(place);
+		if (!this.sorgenti().includes("google")) return of(place);
+		if (!this.suggestionSpenta) return this.luogoDaSuggestion(place).pipe(catchError((err) => {
+			this.suggestionSpenta = true;
+			console.warn(`[ngx-geocoding] dettaglio da Places (New) non riuscito, si prova la legacy — ${this.perche(err)}`);
+			return this.luogoDaLegacy(place);
+		}));
+		if (this.placesSpenta) return of(place);
+		return this.luogoDaLegacy(place);
+	}
+	luogoDaSuggestion(place) {
+		return from(attendiPlaces()).pipe(switchMap((places) => {
+			const Luogo = places.Place;
+			if (!Luogo) return throwError(() => /* @__PURE__ */ new Error("Place non c'è in questo SDK"));
+			const luogo = new Luogo({ id: place.place_id });
+			return from(luogo.fetchFields({ fields: ["location", "formattedAddress"] })).pipe(map(() => ({
+				...place,
+				display_name: place.display_name ?? luogo.formattedAddress ?? "",
+				lat: this.testo(luogo.location?.lat()),
+				lon: this.testo(luogo.location?.lng())
+			})));
+		}));
+	}
+	luogoDaLegacy(place) {
+		return from(attendiPlaces()).pipe(switchMap((places) => new Observable((chi) => {
+			new places.PlacesService(document.createElement("div")).getDetails({
+				placeId: place.place_id,
+				fields: ["geometry", "formatted_address"]
+			}, (luogo, stato) => {
+				if (stato !== STATO_PLACES.ok || !luogo) {
+					chi.error(new Error(stato));
+					return;
+				}
+				const punto = luogo.geometry?.location;
+				chi.next({
+					...place,
+					display_name: place.display_name ?? luogo.formatted_address ?? "",
+					lat: this.testo(punto?.lat()),
+					lon: this.testo(punto?.lng())
+				});
+				chi.complete();
+			});
+		})), catchError((err) => {
+			console.warn("[ngx-geocoding] coordinate del luogo non risolte — " + this.perche(err));
+			return of(place);
+		}));
+	}
+	daSorgenti(address, restanti) {
+		const sorgente = restanti[0];
+		if (!sorgente) return throwError(() => /* @__PURE__ */ new Error("Nessuna sorgente di geocoding disponibile"));
+		const dopo = restanti.slice(1);
+		if (this.spente.has(sorgente)) return this.daSorgenti(address, dopo);
+		return (sorgente === "google" ? this.daGoogle(address) : this.daNominatim(address)).pipe(tap((luoghi) => {
+			if (luoghi.length <= 0) this.subjectNoResults.next(null);
+		}), catchError((err) => {
+			this.spente.add(sorgente);
+			console.warn(`[ngx-geocoding] sorgente "${sorgente}" non utilizzabile, non la si richiede più — ${this.perche(err)}`);
+			return this.daSorgenti(address, dopo);
+		}));
+	}
+	daNominatim(address) {
+		const encoded = encodeURIComponent(address);
+		const base = this.config?.nominatimUrl ?? NOMINATIM;
+		return this.http.get(`${base}?q=${encoded}&format=jsonv2`).pipe(map((res) => res.map((item) => ({
+			display_name: item.display_name,
+			lat: item.lat,
+			lon: item.lon,
+			place_id: item.place_id
+		}))));
+	}
+	daGoogle(address) {
+		if (this.suggestionSpenta) return this.dallaLegacy(address);
+		return this.daSuggestion(address).pipe(catchError((err) => {
+			this.suggestionSpenta = true;
+			console.warn(`[ngx-geocoding] Places (New) non utilizzabile, si prova quella legacy — ${this.perche(err)}`);
+			return this.dallaLegacy(address);
+		}));
+	}
+	dallaLegacy(address) {
+		if (this.placesSpenta) return this.daGeocoder(address);
+		return this.daPlaces(address).pipe(catchError((err) => {
+			this.placesSpenta = true;
+			console.warn(`[ngx-geocoding] Places legacy non utilizzabile, si prova il Geocoder — ${this.perche(err)}`);
+			return this.daGeocoder(address);
+		}));
+	}
+	daSuggestion(address) {
+		const paese = this.config?.country;
+		const cerchio = this.cerchio();
+		return from(attendiPlaces()).pipe(switchMap((places) => {
+			const nuova = places.AutocompleteSuggestion;
+			if (!nuova) return throwError(() => /* @__PURE__ */ new Error("AutocompleteSuggestion non c'è in questo SDK"));
+			return from(nuova.fetchAutocompleteSuggestions({
+				input: address,
+				...paese ? {
+					includedRegionCodes: [paese],
+					region: paese
+				} : {},
+				...cerchio ? { locationBias: cerchio } : {}
+			})).pipe(map((risposta) => (risposta?.suggestions ?? []).map((s) => s.placePrediction).filter((p) => !!p?.placeId).map((p) => ({
+				place_id: p.placeId,
+				display_name: p.text?.toString() ?? ""
+			}))));
+		}));
+	}
+	daPlaces(address) {
+		const paese = this.config?.country;
+		const cerchio = this.cerchio();
+		return from(attendiPlaces()).pipe(switchMap((places) => new Observable((chi) => {
+			new places.AutocompleteService().getPlacePredictions({
+				input: address,
+				...paese ? { componentRestrictions: { country: paese } } : {},
+				...cerchio ? { locationBias: cerchio } : {}
+			}, (proposte, stato) => {
+				if (stato === STATO_PLACES.nessuno) {
+					chi.next([]);
+					chi.complete();
+					return;
+				}
+				if (stato !== STATO_PLACES.ok) {
+					chi.error(new Error(stato));
+					return;
+				}
+				chi.next((proposte ?? []).filter((p) => !!p.place_id).map((p) => ({
+					place_id: p.place_id,
+					display_name: p.description ?? ""
+				})));
+				chi.complete();
+			});
+		})));
+	}
+	daGeocoder(address) {
+		const paese = this.config?.country;
+		const riquadro = this.riquadro();
+		return from(attendiGeocoder()).pipe(switchMap((geocoder) => new Observable((chi) => {
+			geocoder.geocode({
+				address,
+				...paese ? {
+					componentRestrictions: { country: paese },
+					region: paese
+				} : {},
+				...riquadro ? { bounds: riquadro } : {}
+			}, (risultati, stato) => {
+				if (stato === STATO_PLACES.nessuno) {
+					chi.next([]);
+					chi.complete();
+					return;
+				}
+				if (stato !== STATO_PLACES.ok) {
+					chi.error(new Error(stato));
+					return;
+				}
+				chi.next((risultati ?? []).map((r) => ({
+					place_id: r.place_id,
+					display_name: r.formatted_address ?? "",
+					lat: this.testo(r.geometry?.location?.lat()),
+					lon: this.testo(r.geometry?.location?.lng())
+				})));
+				chi.complete();
+			});
+		})));
+	}
+	cerchio() {
+		const bias = this.config?.bias;
+		return bias ? {
+			center: {
+				lat: bias.lat,
+				lng: bias.lon
+			},
+			radius: bias.radiusM
+		} : void 0;
+	}
+	riquadro() {
+		const bias = this.config?.bias;
+		if (!bias) return void 0;
+		const dLat = bias.radiusM / METRI_PER_GRADO;
+		const dLon = dLat / Math.max(Math.cos(bias.lat * Math.PI / 180), .01);
+		return {
+			north: bias.lat + dLat,
+			south: bias.lat - dLat,
+			east: bias.lon + dLon,
+			west: bias.lon - dLon
+		};
+	}
+	sorgenti() {
+		const dichiarate = this.config?.sources ?? [];
+		return dichiarate.length ? dichiarate : SOLO_NOMINATIM;
+	}
+	perche(err) {
+		if (err instanceof Error && err.message) return err.message;
+		const dettaglio = err?.error?.error;
+		if (!dettaglio) return "motivo non dichiarato";
+		return [dettaglio.status, dettaglio.message].filter((pezzo) => !!pezzo).join(" : ");
+	}
+	testo(valore) {
+		return valore === null || valore === void 0 ? void 0 : String(valore);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.4",
+			ngImport: i0,
+			type: NgxGeocodingService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.4",
+			ngImport: i0,
+			type: NgxGeocodingService,
+			providedIn: "root"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: NgxGeocodingService,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
 export { NGX_GEOCODING_CONFIG, NgxGeocodingModule, NgxGeocodingService, provideNgxGeocoding };
-//# sourceMappingURL=geosdi-ngx-geocoding.mjs.map
+
+//# sourceMappingURL=geosdi-ngx-geocoding.mjs.map