@nextgis/geocoder 1.16.8 → 1.18.3

package/lib/geocoder.esm-bundler.js

@@ -1,454 +1,268 @@
-/** Bundle of @nextgis/geocoder; version: 1.16.8; author: NextGIS */
+/** Bundle of @nextgis/geocoder; version: 1.18.3; author: NextGIS */
 import CancelablePromise from '@nextgis/cancelable-promise';
 import { objectAssign, fixUrlStr } from '@nextgis/utils';
 import NgwConnector from '@nextgis/ngw-connector';
+import { fetchNgwLayerItems } from '@nextgis/ngw-kit';
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __await(v) {
-    return this instanceof __await ? (this.v = v, this) : new __await(v);
-}
-
-function __asyncGenerator(thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-}
-
-function __asyncValues(o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+/**
+ * Represents the base class for a geocoder.
+ * This abstract class provides the basic methods that every geocoder should implement.
+ *
+ * @template O - The type of options that can be passed to the geocoder.
+ */
+class BaseGeocoder {
+    constructor(options) {
+        if (options) {
+            objectAssign(this, options);
+        }
+    }
 }
 
-var BaseGeocoder = /** @class */ (function () {
-    function BaseGeocoder(options) {
-        if (options) {
-            objectAssign(this, options);
-        }
-    }
-    return BaseGeocoder;
-}());
-
-var ID = 0;
-var Geocoder = /** @class */ (function (_super) {
-    __extends(Geocoder, _super);
-    function Geocoder(options) {
-        var _this = _super.call(this, options) || this;
-        _this.providers = [];
-        if (options && options.providers) {
-            _this.providers = options.providers;
-        }
-        return _this;
-    }
-    Geocoder.prototype.abort = function () {
-        this.providers.forEach(function (x) {
-            if (x.abort) {
-                x.abort();
-            }
-        });
-    };
-    Geocoder.prototype.search = function (query) {
-        return __asyncGenerator(this, arguments, function search_1() {
-            var _i, _a, provider, results, results_1, results_1_1, r, e_1_1;
-            var e_1, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _i = 0, _a = this.providers;
-                        _c.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 19];
-                        provider = _a[_i];
-                        _c.label = 2;
-                    case 2:
-                        _c.trys.push([2, 17, , 18]);
-                        results = provider.search(query);
-                        _c.label = 3;
-                    case 3:
-                        _c.trys.push([3, 10, 11, 16]);
-                        results_1 = (e_1 = void 0, __asyncValues(results));
-                        _c.label = 4;
-                    case 4: return [4 /*yield*/, __await(results_1.next())];
-                    case 5:
-                        if (!(results_1_1 = _c.sent(), !results_1_1.done)) return [3 /*break*/, 9];
-                        r = results_1_1.value;
-                        return [4 /*yield*/, __await(__assign(__assign({}, r), { provider: provider, _id: ID++ }))];
-                    case 6: return [4 /*yield*/, _c.sent()];
-                    case 7:
-                        _c.sent();
-                        _c.label = 8;
-                    case 8: return [3 /*break*/, 4];
-                    case 9: return [3 /*break*/, 16];
-                    case 10:
-                        e_1_1 = _c.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 16];
-                    case 11:
-                        _c.trys.push([11, , 14, 15]);
-                        if (!(results_1_1 && !results_1_1.done && (_b = results_1.return))) return [3 /*break*/, 13];
-                        return [4 /*yield*/, __await(_b.call(results_1))];
-                    case 12:
-                        _c.sent();
-                        _c.label = 13;
-                    case 13: return [3 /*break*/, 15];
-                    case 14:
-                        if (e_1) throw e_1.error;
-                        return [7 /*endfinally*/];
-                    case 15: return [7 /*endfinally*/];
-                    case 16: return [3 /*break*/, 18];
-                    case 17:
-                        _c.sent();
-                        return [3 /*break*/, 18];
-                    case 18:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 19: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Geocoder.prototype.result = function (item) {
-        if (item.provider) {
-            return item.provider.result(item);
-        }
-        return CancelablePromise.resolve(undefined);
-    };
-    return Geocoder;
-}(BaseGeocoder));
+let ID = 0;
+class Geocoder extends BaseGeocoder {
+    constructor(options) {
+        super(options);
+        this.providers = [];
+        if (options && options.providers) {
+            this.providers = options.providers;
+        }
+    }
+    abort() {
+        this.providers.forEach((x) => {
+            if (x.abort) {
+                x.abort();
+            }
+        });
+    }
+    async *search(query) {
+        for (const provider of this.providers) {
+            try {
+                const results = provider.search(query);
+                for await (const r of results) {
+                    yield { ...r, provider, _id: ID++ };
+                }
+            }
+            catch (er) {
+                //
+            }
+        }
+    }
+    result(item) {
+        if (item.provider) {
+            return item.provider.result(item);
+        }
+        return CancelablePromise.resolve(undefined);
+    }
+}
 
-var BaseProvider = /** @class */ (function (_super) {
-    __extends(BaseProvider, _super);
-    function BaseProvider() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return BaseProvider;
-}(BaseGeocoder));
+/**
+ * Abstract base class representing a search provider.
+ * It builds upon the BaseGeocoder functionalities with provider-specific properties.
+ * @template O - Options type which extends BaseProviderOptions.
+ */
+class BaseProvider extends BaseGeocoder {
+}
 
-var NgwProvider = /** @class */ (function (_super) {
-    __extends(NgwProvider, _super);
-    function NgwProvider(options) {
-        var _this = _super.call(this, options) || this;
-        _this.caseInsensitive = true;
-        _this.searchUrl = 'https://maxim.nextgis.com';
-        _this.searchResources = [];
-        _this.requests = [];
-        _this.connector =
-            options.connector ||
-                new NgwConnector({
-                    baseUrl: _this.searchUrl,
-                });
-        _this.searchResources = options.searchResources;
-        return _this;
-    }
-    NgwProvider.prototype.abort = function () {
-        this.requests.forEach(function (x) {
-            x.cancel();
-        });
-        this.requests = [];
-    };
-    NgwProvider.prototype.search = function (like) {
-        return __asyncGenerator(this, arguments, function search_1() {
-            var _loop_1, this_1, _i, _a, resource;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _loop_1 = function (resource) {
-                            var limit, request, resp, entries, _loop_2, _c, _d, item;
-                            return __generator(this, function (_e) {
-                                switch (_e.label) {
-                                    case 0:
-                                        limit = resource.limit || 300;
-                                        request = this_1.connector.get('feature_layer.store', {
-                                            headers: { RANGE: "items=0-".concat(limit) },
-                                        }, {
-                                            id: resource.id,
-                                            like: like,
-                                        });
-                                        this_1.requests.push(request);
-                                        request.catch(function (er) {
-                                            console.warn(er);
-                                        });
-                                        return [4 /*yield*/, __await(request)];
-                                    case 1:
-                                        resp = _e.sent();
-                                        entries = [];
-                                        if (resp) {
-                                            resp.forEach(function (x) {
-                                                entries.push(__assign({ query: like, resourceId: resource.id }, x));
-                                            });
-                                        }
-                                        _loop_2 = function (item) {
-                                            return __generator(this, function (_f) {
-                                                switch (_f.label) {
-                                                    case 0:
-                                                        item.result = function () { return _this.result(item); };
-                                                        return [4 /*yield*/, __await(item)];
-                                                    case 1: return [4 /*yield*/, _f.sent()];
-                                                    case 2:
-                                                        _f.sent();
-                                                        return [2 /*return*/];
-                                                }
-                                            });
-                                        };
-                                        _c = 0, _d = this_1._items(entries);
-                                        _e.label = 2;
-                                    case 2:
-                                        if (!(_c < _d.length)) return [3 /*break*/, 5];
-                                        item = _d[_c];
-                                        return [5 /*yield**/, _loop_2(item)];
-                                    case 3:
-                                        _e.sent();
-                                        _e.label = 4;
-                                    case 4:
-                                        _c++;
-                                        return [3 /*break*/, 2];
-                                    case 5: return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_1 = this;
-                        _i = 0, _a = this.searchResources;
-                        _b.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 4];
-                        resource = _a[_i];
-                        return [5 /*yield**/, _loop_1(resource)];
-                    case 2:
-                        _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NgwProvider.prototype.result = function (item) {
-        var req = this.connector
-            .get('feature_layer.feature.item_extent', null, {
-            id: item.resourceId,
-            fid: item.featureId,
-        })
-            .then(function (x) {
-            var e = x.extent;
-            return {
-                text: item.text,
-                extent: [e.minLon, e.minLat, e.maxLon, e.maxLat],
-            };
-        });
-        this.requests.push(req);
-        return req;
-    };
-    NgwProvider.prototype._items = function (entries) {
-        var _this = this;
-        var items = [];
-        entries.forEach(function (entry) {
-            var meta = _this.searchResources.find(function (x) { return x.id === entry.resourceId; });
-            if (meta) {
-                items.push({
-                    query: entry.query,
-                    text: entry.label,
-                    featureId: entry.id,
-                    resourceId: entry.resourceId,
-                });
-            }
-        });
-        return items;
-    };
-    return NgwProvider;
-}(BaseProvider));
+class NgwProvider extends BaseProvider {
+    constructor(options) {
+        var _a;
+        super(options);
+        this.caseInsensitive = true;
+        this.searchResources = [];
+        this._abortControllers = [];
+        if (!options.searchUrl && !((_a = options.connectorOptions) === null || _a === void 0 ? void 0 : _a.baseUrl)) {
+            throw new Error('The `searchUrl` of `connectorOptions.baseUrl` are required');
+        }
+        this.connector =
+            options.connector ||
+                new NgwConnector({
+                    baseUrl: this.searchUrl,
+                    ...options.connectorOptions,
+                });
+        this.searchResources = options.searchResources;
+    }
+    abort() {
+        this._abortControllers.forEach((a) => {
+            a.abort();
+        });
+        this._abortControllers.length = 0;
+    }
+    async *search(query) {
+        var _a, _b;
+        const signal = this._makeSignal();
+        for (const config of this.searchResources) {
+            if (signal.aborted) {
+                break;
+            }
+            const { searchMethod } = config;
+            const limit = (_a = config.limit) !== null && _a !== void 0 ? _a : NgwProvider.limit;
+            //
+            const resourceId = (_b = config.id) !== null && _b !== void 0 ? _b : config.resourceId;
+            try {
+                const resource = await this.connector.getResourceOrFail(resourceId, {
+                    cache: true,
+                });
+                const options = {
+                    connector: this.connector,
+                    resourceId,
+                    signal,
+                    limit,
+                };
+                if (searchMethod === 'like') {
+                    options.like = query;
+                }
+                else {
+                    options.ilike = query;
+                }
+                const request = fetchNgwLayerItems(options);
+                const entries = await request;
+                for (const item of this._items({
+                    entries,
+                    query,
+                    config,
+                    resourceItem: resource,
+                })) {
+                    item.result = () => this.result(item);
+                    yield item;
+                }
+            }
+            catch (er) {
+                if (er &&
+                    'name' in er &&
+                    er.name !== 'CancelError') {
+                    console.warn(er);
+                }
+            }
+        }
+    }
+    result(item) {
+        const signal = this._makeSignal();
+        const req = this.connector
+            .get('feature_layer.feature.item_extent', { signal }, {
+            id: item.resourceId,
+            fid: item.featureId,
+        })
+            .then((x) => {
+            const e = x.extent;
+            return {
+                text: item.text,
+                extent: [e.minLon, e.minLat, e.maxLon, e.maxLat],
+            };
+        });
+        return req;
+    }
+    _makeSignal() {
+        const abortController = new AbortController();
+        this._abortControllers.push(abortController);
+        return abortController.signal;
+    }
+    _items({ entries, query, config, resourceItem, }) {
+        var _a;
+        const items = [];
+        let labelField = undefined;
+        if (resourceItem.feature_layer) {
+            labelField = (_a = resourceItem.feature_layer.fields.find((f) => f.label_field)) === null || _a === void 0 ? void 0 : _a.keyname;
+        }
+        const meta = this.searchResources.find((x) => { var _a; return (_a = x.id) !== null && _a !== void 0 ? _a : x.resourceId === resourceItem.resource.id; });
+        if (meta) {
+            entries.forEach((entry) => {
+                let text = labelField ? entry.fields[labelField] : entry.id;
+                if (config.renderSearch) {
+                    text = config.renderSearch({
+                        item: entry,
+                        resourceItem,
+                    });
+                }
+                else if (labelField) {
+                    text = entry.fields[labelField];
+                }
+                items.push({
+                    query: query,
+                    text,
+                    featureId: entry.id,
+                    resourceId: resourceItem.resource.id,
+                    item: entry,
+                    resourceItem,
+                });
+            });
+        }
+        return items;
+    }
+}
+NgwProvider.limit = 300;
 
-var NominatimProvider = /** @class */ (function (_super) {
-    __extends(NominatimProvider, _super);
-    function NominatimProvider(options) {
-        var _this = _super.call(this, options) || this;
-        _this.searchUrl = 'https://nominatim.openstreetmap.org';
-        _this._requests = [];
-        return _this;
-    }
-    NominatimProvider.prototype.abort = function () {
-        this._requests.forEach(function (x) { return x.cancel(); });
-        this._requests = [];
-    };
-    NominatimProvider.prototype.search = function (val) {
-        return __asyncGenerator(this, arguments, function search_1() {
-            var url, request, items, _loop_1, _i, items_1, i;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        url = fixUrlStr(
-                        // `${this.baseUrl}/search?format=geojson&polygon_geojson=1${window.locale === 'ru' ? '&accept-language=ru-RU,en-US' : ''}&q=${val}`
-                        "".concat(this.searchUrl, "/search?format=geojson&polygon_geojson=1&q=").concat(val));
-                        request = new CancelablePromise(function (resolve, reject, onCancel) {
-                            var xhr = new XMLHttpRequest();
-                            xhr.open('GET', url, true);
-                            xhr.onload = function () {
-                                try {
-                                    var geojson = JSON.parse(xhr.responseText);
-                                    var features = geojson.features.map(function (x) {
-                                        return {
-                                            geom: x,
-                                            extent: x.bbox,
-                                            text: x.properties && x.properties.display_name,
-                                            query: val,
-                                        };
-                                    });
-                                    resolve(features);
-                                }
-                                catch (er) {
-                                    reject(er);
-                                }
-                            };
-                            xhr.onerror = function (er) {
-                                reject(er);
-                            };
-                            onCancel(function () {
-                                xhr.abort();
-                            });
-                            xhr.send();
-                        }).catch(function (er) {
-                            if (er.name === 'CancelError') ;
-                            throw er;
-                        });
-                        this._requests.push(request);
-                        return [4 /*yield*/, __await(request)];
-                    case 1:
-                        items = _a.sent();
-                        if (!items) return [3 /*break*/, 5];
-                        _loop_1 = function (i) {
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        i.result = function () { return _this.result(i); };
-                                        return [4 /*yield*/, __await(i)];
-                                    case 1: return [4 /*yield*/, _b.sent()];
-                                    case 2:
-                                        _b.sent();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        };
-                        _i = 0, items_1 = items;
-                        _a.label = 2;
-                    case 2:
-                        if (!(_i < items_1.length)) return [3 /*break*/, 5];
-                        i = items_1[_i];
-                        return [5 /*yield**/, _loop_1(i)];
-                    case 3:
-                        _a.sent();
-                        _a.label = 4;
-                    case 4:
-                        _i++;
-                        return [3 /*break*/, 2];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NominatimProvider.prototype.result = function (model) {
-        return CancelablePromise.resolve({
-            text: model.text,
-            extent: model.extent || [],
-            geom: model.geom,
-        });
-    };
-    return NominatimProvider;
-}(BaseProvider));
+class NominatimProvider extends BaseProvider {
+    constructor(options) {
+        super(options);
+        this.searchUrl = 'https://nominatim.openstreetmap.org';
+        this._requests = [];
+    }
+    abort() {
+        this._requests.forEach((x) => x.cancel());
+        this._requests = [];
+    }
+    async *search(val) {
+        // RFC2616 accept - language string
+        const url = fixUrlStr(
+        // `${this.baseUrl}/search?format=geojson&polygon_geojson=1${window.locale === 'ru' ? '&accept-language=ru-RU,en-US' : ''}&q=${val}`
+        `${this.searchUrl}/search?format=geojson&polygon_geojson=1&q=${val}`);
+        const request = new CancelablePromise((resolve, reject, onCancel) => {
+            const xhr = new XMLHttpRequest();
+            xhr.open('GET', url, true);
+            xhr.onload = () => {
+                try {
+                    const geojson = JSON.parse(xhr.responseText);
+                    const features = geojson.features.map((x) => {
+                        return {
+                            geom: x,
+                            extent: x.bbox,
+                            text: x.properties && x.properties.display_name,
+                            query: val,
+                        };
+                    });
+                    resolve(features);
+                }
+                catch (er) {
+                    reject(er);
+                }
+            };
+            xhr.onerror = (er) => {
+                reject(er);
+            };
+            onCancel(() => {
+                xhr.abort();
+            });
+            xhr.send();
+        }).catch((er) => {
+            if (er.name === 'CancelError') ;
+            throw er;
+        });
+        this._requests.push(request);
+        const items = await request;
+        if (items) {
+            for (const i of items) {
+                i.result = () => this.result(i);
+                yield i;
+            }
+        }
+    }
+    result(model) {
+        return CancelablePromise.resolve({
+            text: model.text,
+            extent: model.extent || [],
+            geom: model.geom,
+        });
+    }
+}
 
-function create(options) {
-    return new Geocoder(options);
+/**
+ * Modern geocoder on async generators. May use different data providers.
+ *
+ * @packageDocumentation
+ * @module geocoder
+ */
+function create(options) {
+    return new Geocoder(options);
 }
 
 export { BaseProvider, Geocoder, NgwProvider, NominatimProvider, create };