@geosdi/ngx-geocoding 1.1.4 → 1.2.1

package/fesm2022/geosdi-ngx-geocoding.mjs

@@ -1,19 +1,19 @@
 import * as i0 from '@angular/core';
-import { NgModule, inject, Injectable } from '@angular/core';
+import { NgModule, InjectionToken, inject, Injectable } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
-import { Subject } from 'rxjs';
-import { tap, map } from 'rxjs/operators';
+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: "20.3.6", ngImport: i0, type: NgxGeocodingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.6", ngImport: i0, type: NgxGeocodingModule }); }
-    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.6", ngImport: i0, type: 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: "20.3.6", ngImport: i0, type: NgxGeocodingModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NgxGeocodingModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [],
@@ -26,27 +26,329 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.6", ngImpor
  * @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.
+ */
+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 };
+}
+
+/**
+ * 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,
+};
+/** Gli stati dell'SDK su cui si decide qualcosa. */
+const STATO_PLACES = {
+    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;
+}
+/** Il costruttore del `Geocoder`, che sta nell'SDK di base. */
+function 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` ?)");
+}
+/**
+ * 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());
+}
+/** 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);
+    });
+}
+
+/**
+ * @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
+     * @param address il testo digitato
      */
     geocode(address) {
-        const encoded = encodeURIComponent(address);
-        return this.http
-            .get(`https://nominatim.openstreetmap.org/search.php?q=${encoded}&format=jsonv2`)
-            .pipe(tap((res) => {
-            if (res.length <= 0) {
+        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);
             }
-            // return res;
-        }))
+        }), 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,
@@ -54,16 +356,222 @@ class NgxGeocodingService {
             place_id: item.place_id,
         }))));
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.6", ngImport: i0, type: NgxGeocodingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.6", ngImport: i0, type: NgxGeocodingService, providedIn: "root" }); }
+    /**
+     * 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: "20.3.6", ngImport: i0, type: NgxGeocodingService, decorators: [{
+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
  */
@@ -72,5 +580,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { NgxGeocodingModule, NgxGeocodingService };
+export { NGX_GEOCODING_CONFIG, NgxGeocodingModule, NgxGeocodingService, provideNgxGeocoding };
 //# sourceMappingURL=geosdi-ngx-geocoding.mjs.map