@nextgis/geocoder 1.17.0 → 1.18.3

package/lib/geocoder.global.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/geocoder; version: 1.17.0; author: NextGIS */
+/** Bundle of @nextgis/geocoder; version: 1.18.3; author: NextGIS */
 var Geocoder = (function (exports) {
     'use strict';
 
@@ -536,6 +536,47 @@ var Geocoder = (function (exports) {
         return typeof val === 'string' ? !!val : defined(val);
     }
 
+    function getBoundsCoordinates(b) {
+        var westNorth = [b[0], b[1]];
+        var eastNorth = [b[2], b[1]];
+        var eastSouth = [b[2], b[3]];
+        var westSouth = [b[0], b[3]];
+        return [westNorth, eastNorth, eastSouth, westSouth, westNorth];
+    }
+
+    function degrees2meters(lng, lat) {
+        lat = lat > 85.06 ? 85.06 : lat < -85.06 ? -85.06 : lat;
+        var x = (lng * 20037508.34) / 180;
+        var y = Math.log(Math.tan(((90 + lat) * Math.PI) / 360)) / (Math.PI / 180);
+        y = (y * 20037508.34) / 180;
+        return [x, y];
+    }
+    // export function degrees2meters2(lon: number, lat: number): [number, number] {
+    //   const radius = 6378137.0;
+    //   const x = (radius * lon * Math.PI) / 180.0;
+    //   const y =
+    //     radius * Math.log(Math.tan(Math.PI / 4.0 + (lat * Math.PI) / 360.0));
+    //   return [x, y];
+    // }
+    // export function meters2degress2(x: number, y: number): LngLatArray {
+    //   const radius = 6378137.0;
+    //   const lon = (180 / Math.PI) * (x / radius);
+    //   const lat = (360 / Math.PI) * (Math.atan(Math.exp(y / radius)) - Math.PI / 4);
+    //   return [lon, lat];
+    // }
+    // const lon = -77.035974;
+    // const lat = 38.898717;
+    // console.log(degrees2meters(lon, lat), degrees2meters2(lon, lat));
+    // const x = -8575605.398443861;
+    // const y = 4707174.018280405;
+    // console.log(meters2degress(x, y), meters2degress2(x, y));
+
+    function isLngLatBoundsArray(array) {
+        return (Array.isArray(array) &&
+            array.length === 4 &&
+            array.every(function (x) { return typeof x === 'number'; }));
+    }
+
     /**
      * Copy the values of all of the enumerable own properties from one or more source objects to a
      * target object. Returns the target object.
@@ -617,11 +658,29 @@ var Geocoder = (function (exports) {
         return newObj;
     }
 
+    function round(val, toFixed) {
+        var n = toFixed ? Number('1e+' + toFixed) : 1;
+        return Math.round((val + Number.EPSILON) * n) / n;
+    }
+
+    function isObject$1(val) {
+        return Object.prototype.toString.call(val) === '[object Object]';
+    }
+    function isArray(val) {
+        return Object.prototype.toString.call(val) === '[object Array]';
+    }
+
     function fixUrlStr(url) {
         // remove double slash
         return url.replace(/([^:]\/)\/+/g, '$1');
     }
 
+    /**
+     * 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.
+     */
     var BaseGeocoder = /** @class */ (function () {
         function BaseGeocoder(options) {
             if (options) {
@@ -722,6 +781,11 @@ var Geocoder = (function (exports) {
         return Geocoder;
     }(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.
+     */
     var BaseProvider = /** @class */ (function (_super) {
         __extends(BaseProvider, _super);
         function BaseProvider() {
@@ -2419,110 +2483,426 @@ var Geocoder = (function (exports) {
      */
     var NgwConnector = NgwConnector$1;
 
+    function reEscape(s) {
+        return s.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+    }
+    function like(b, a, iLike) {
+        a = String(a);
+        b = String(b);
+        if (a === b)
+            return true;
+        if (iLike && a.toUpperCase() === b.toUpperCase())
+            return true;
+        var re = "^".concat(reEscape(a), "$").replace(/%/g, '.*').replace('_', '.');
+        return new RegExp(re, iLike ? 'i' : '').exec(b) !== null;
+    }
+    var operationsAliases = {
+        // greater(>)
+        gt: function (a, b) { return a > b; },
+        // lower(<)
+        lt: function (a, b) { return a < b; },
+        // greater or equal(>=)
+        ge: function (a, b) { return a >= b; },
+        // lower or equal(<=)
+        le: function (a, b) { return a <= b; },
+        // equal(=)
+        eq: function (a, b) { return a === b; },
+        //  not equal(!=)
+        ne: function (a, b) { return a !== b; },
+        in: function (a, b) { return b.indexOf(a) !== -1; },
+        notin: function (a, b) { return b.indexOf(a) === -1; },
+        // LIKE SQL statement(for strings compare)
+        like: function (a, b) {
+            return like(a, b);
+        },
+        // ILIKE SQL statement(for strings compare)
+        ilike: function (a, b) {
+            return like(a, b, true);
+        },
+    };
+    function isPropertyFilter(filter) {
+        var pf = filter;
+        if (pf.length === 3 &&
+            typeof pf[0] === 'string' &&
+            typeof pf[1] === 'string') {
+            return true;
+        }
+        return false;
+    }
+    function propertiesFilter(properties, filters) {
+        var logic = typeof filters[0] === 'string' ? filters[0] : 'all';
+        var filterFunction = function (p) {
+            if (isPropertyFilter(p)) {
+                var field_1 = p[0], operation = p[1], value_1 = p[2];
+                var operationExec = operationsAliases[operation];
+                if (operationExec) {
+                    if (operation === 'like' || operation === 'ilike') {
+                        if (typeof field_1 === 'string') {
+                            var prop_1 = '';
+                            var value_ = field_1.replace(/^%?(\w+)%?$/, function (match, cleanField) {
+                                prop_1 = properties[cleanField];
+                                return field_1.replace(cleanField, value_1);
+                            });
+                            return operationExec(prop_1, value_);
+                        }
+                    }
+                    return operationExec(properties[field_1], value_1);
+                }
+                return false;
+            }
+            else {
+                return propertiesFilter(properties, p);
+            }
+        };
+        var filters_ = filters.filter(function (x) { return Array.isArray(x); });
+        return logic === 'any'
+            ? filters_.some(filterFunction)
+            : filters_.every(filterFunction);
+    }
+
+    var FEATURE_REQUEST_PARAMS = {
+        srs: 4326,
+        geom_format: 'geojson',
+    };
+    function updateItemRequestParam(params, options) {
+        var extensions = options.extensions, geom = options.geom, fields = options.fields, srs = options.srs, ilike = options.ilike, like = options.like;
+        if (extensions) {
+            params.extensions = extensions.join(',');
+        }
+        if (fields !== undefined) {
+            params.fields = Array.isArray(fields) ? fields.join(',') : '';
+        }
+        if (geom !== undefined) {
+            params.geom = geom ? 'yes' : 'no';
+            if (!geom) {
+                delete params.srs;
+                delete params.geom_format;
+            }
+        }
+        if (defined(ilike)) {
+            params.ilike = ilike;
+        }
+        else if (defined(like)) {
+            params.like = like;
+        }
+        if (defined(srs)) {
+            params.srs = srs;
+        }
+    }
+    // NGW REST API is not able to filtering by combined queries
+    // therefore the filter is divided into several requests
+    function createFeatureFieldFilterQueries(opt) {
+        var queries = getQueries(opt);
+        return CancelablePromise.all(queries).then(function (itemsParts) {
+            // this list of ids used for optimization
+            var ids = [];
+            var items = [];
+            for (var _i = 0, itemsParts_1 = itemsParts; _i < itemsParts_1.length; _i++) {
+                var part = itemsParts_1[_i];
+                for (var _a = 0, part_1 = part; _a < part_1.length; _a++) {
+                    var item = part_1[_a];
+                    if (!ids.includes(item.id)) {
+                        items.push(item);
+                        ids.push(item.id);
+                    }
+                }
+            }
+            var offset = opt.offset !== undefined ? opt.offset : 0;
+            var limit = opt.limit !== undefined ? opt.limit : items.length;
+            if (opt.offset || opt.limit) {
+                return items.splice(offset, limit);
+            }
+            return items;
+        });
+    }
+    function createParam(pf) {
+        var field = pf[0], operation = pf[1], value = pf[2];
+        var isFldStr = field !== 'id' ? 'fld_' : '';
+        var vStart = '';
+        var vEnd = '';
+        var field_ = String(field)
+            .trim()
+            .replace(/^(%?)(.+?)(%?)$/, function (m, a, b, c) {
+            vStart = a;
+            vEnd = c;
+            return b;
+        });
+        var v = vStart + value + vEnd;
+        return ["".concat(isFldStr).concat(field_, "__").concat(operation), v];
+    }
+    function getQueries(opt, _queries, _parentAllParams) {
+        if (_queries === void 0) { _queries = []; }
+        if (_parentAllParams === void 0) { _parentAllParams = []; }
+        var filters = opt.filters;
+        var logic = typeof filters[0] === 'string' ? filters[0] : 'all';
+        var filters_ = filters.filter(function (x) { return Array.isArray(x); });
+        if (logic === 'any') {
+            for (var _i = 0, filters_1 = filters_; _i < filters_1.length; _i++) {
+                var f = filters_1[_i];
+                if (isPropertyFilter(f)) {
+                    _queries.push(fetchNgwLayerItemsRequest(__assign(__assign({}, opt), { paramList: __spreadArray(__spreadArray([], _parentAllParams, true), [createParam(f)], false) })));
+                }
+                else {
+                    getQueries(__assign(__assign({}, opt), { filters: f }), _queries, __spreadArray([], _parentAllParams, true));
+                }
+            }
+        }
+        else if (logic === 'all') {
+            var filters_3 = [];
+            var propertiesFilterList = [];
+            for (var _a = 0, filters_2 = filters_; _a < filters_2.length; _a++) {
+                var f = filters_2[_a];
+                if (isPropertyFilter(f)) {
+                    filters_3.push(createParam(f));
+                }
+                else {
+                    propertiesFilterList.push(f);
+                }
+            }
+            if (propertiesFilterList.length) {
+                for (var _b = 0, propertiesFilterList_1 = propertiesFilterList; _b < propertiesFilterList_1.length; _b++) {
+                    var x = propertiesFilterList_1[_b];
+                    getQueries(__assign(__assign({}, opt), { filters: x }), _queries, __spreadArray(__spreadArray([], _parentAllParams, true), filters_3, true));
+                }
+            }
+            else {
+                _queries.push(fetchNgwLayerItemsRequest(__assign(__assign({}, opt), { paramList: __spreadArray(__spreadArray([], _parentAllParams, true), filters_3, true) })));
+            }
+        }
+        return _queries;
+    }
+    function createWktFromCoordArray(coord) {
+        var polygon = coord.map(function (_a) {
+            var lng = _a[0], lat = _a[1];
+            var _b = degrees2meters(lng, lat).map(function (c) { return round(c); }), x = _b[0], y = _b[1];
+            return x + ' ' + y;
+        });
+        return "POLYGON((".concat(polygon.join(', '), "))");
+    }
+    function fetchNgwLayerItemsRequest(options) {
+        var params = __assign({}, FEATURE_REQUEST_PARAMS);
+        var limit = options.limit, cache = options.cache, signal = options.signal, offset = options.offset, orderBy = options.orderBy, paramList = options.paramList, connector = options.connector, geomFormat = options.geomFormat, intersects = options.intersects, resourceId = options.resourceId;
+        if (limit) {
+            if (limit !== Number.POSITIVE_INFINITY) {
+                params.limit = limit;
+            }
+        }
+        else {
+            // Strict restriction on loading data from large layers
+            params.limit = 7000;
+        }
+        if (offset) {
+            params.offset = offset;
+        }
+        if (geomFormat) {
+            params.geom_format = geomFormat;
+        }
+        updateItemRequestParam(params, options);
+        if (orderBy) {
+            params.order_by = orderBy.join(',');
+        }
+        if (Array.isArray(intersects)) {
+            var coordinates = isLngLatBoundsArray(intersects)
+                ? getBoundsCoordinates(intersects)
+                : intersects;
+            params.intersects = createWktFromCoordArray(coordinates);
+        }
+        else if (typeof intersects === 'string') {
+            params.intersects = intersects;
+        }
+        if (paramList) {
+            params.paramList = paramList;
+        }
+        var reqParams = __assign({ id: resourceId }, params);
+        return connector.get('feature_layer.feature.collection', { cache: cache, signal: signal }, reqParams);
+    }
+
+    function prepareNgwFieldsToPropertiesFilter(fields) {
+        var f;
+        var _loop_1 = function () {
+            var field = fields[f];
+            if (isObject$1(field)) {
+                var date = field;
+                if (defined(date.year) && defined(date.month) && defined(date.day)) {
+                    var dt_1 = [
+                        date.year,
+                        date.month - 1,
+                        date.day,
+                    ];
+                    if ('hour' in date) {
+                        [date.hour, date.minute, date.second].forEach(function (x) {
+                            dt_1.push(x);
+                        });
+                    }
+                    fields[f] = new (Date.bind.apply(Date, __spreadArray([void 0], dt_1, false)))().toISOString();
+                }
+            }
+            else if (f === 'id' && typeof field === 'string') {
+                fields[f] = field.split(',').map(Number);
+            }
+        };
+        for (f in fields) {
+            _loop_1();
+        }
+        return fields;
+    }
+
+    function fetchNgwLayerItems(options) {
+        var filters = options.filters;
+        if (filters) {
+            return createFeatureFieldFilterQueries(__assign(__assign({}, options), { filters: filters })).then(function (data) {
+                var _a;
+                var clientFilterValidate = (_a = options.clientFilterValidate) !== null && _a !== void 0 ? _a : isFilterWithAnyCase(filters);
+                // Additional client-side filter check
+                if (clientFilterValidate) {
+                    data = data.filter(function (y) {
+                        var fields = prepareNgwFieldsToPropertiesFilter(__assign(__assign({}, y.fields), { id: y.id }));
+                        var result = propertiesFilter(fields, filters);
+                        return result;
+                    });
+                }
+                return data;
+            });
+        }
+        else {
+            return fetchNgwLayerItemsRequest(options);
+        }
+    }
+    function isFilterWithAnyCase(filters) {
+        if (filters[0] === 'any') {
+            return true;
+        }
+        for (var i = 1; i < filters.length; i++) {
+            var p = filters[i];
+            if (isArray(p)) {
+                var deep = isFilterWithAnyCase(p);
+                if (deep) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     var NgwProvider = /** @class */ (function (_super) {
         __extends(NgwProvider, _super);
         function NgwProvider(options) {
-            var _this = _super.call(this, options) || this;
+            var _this = this;
+            var _a;
+            _this = _super.call(this, options) || this;
             _this.caseInsensitive = true;
-            _this.searchUrl = 'https://maxim.nextgis.com';
             _this.searchResources = [];
-            _this.requests = [];
+            _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,
-                    });
+                    new NgwConnector(__assign({ baseUrl: _this.searchUrl }, options.connectorOptions));
             _this.searchResources = options.searchResources;
             return _this;
         }
         NgwProvider.prototype.abort = function () {
-            this.requests.forEach(function (x) {
-                x.cancel();
+            this._abortControllers.forEach(function (a) {
+                a.abort();
             });
-            this.requests = [];
+            this._abortControllers.length = 0;
         };
-        NgwProvider.prototype.search = function (like) {
+        NgwProvider.prototype.search = function (query) {
+            var _a, _b;
             return __asyncGenerator(this, arguments, function search_1() {
-                var _loop_1, this_1, _i, _a, resource;
+                var signal, _i, _c, config, searchMethod, limit, resourceId, resource, options, request, entries, _loop_1, _d, _e, item, er_1;
                 var _this = this;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_f) {
+                    switch (_f.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) {
+                            signal = this._makeSignal();
+                            _i = 0, _c = this.searchResources;
+                            _f.label = 1;
+                        case 1:
+                            if (!(_i < _c.length)) return [3 /*break*/, 11];
+                            config = _c[_i];
+                            if (signal.aborted) {
+                                return [3 /*break*/, 11];
+                            }
+                            searchMethod = config.searchMethod;
+                            limit = (_a = config.limit) !== null && _a !== void 0 ? _a : NgwProvider.limit;
+                            resourceId = (_b = config.id) !== null && _b !== void 0 ? _b : config.resourceId;
+                            _f.label = 2;
+                        case 2:
+                            _f.trys.push([2, 9, , 10]);
+                            return [4 /*yield*/, __await(this.connector.getResourceOrFail(resourceId, {
+                                    cache: true,
+                                }))];
+                        case 3:
+                            resource = _f.sent();
+                            options = {
+                                connector: this.connector,
+                                resourceId: resourceId,
+                                signal: signal,
+                                limit: limit,
+                            };
+                            if (searchMethod === 'like') {
+                                options.like = query;
+                            }
+                            else {
+                                options.ilike = query;
+                            }
+                            request = fetchNgwLayerItems(options);
+                            return [4 /*yield*/, __await(request)];
+                        case 4:
+                            entries = _f.sent();
+                            _loop_1 = function (item) {
+                                return __generator(this, function (_g) {
+                                    switch (_g.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;
+                                            item.result = function () { return _this.result(item); };
+                                            return [4 /*yield*/, __await(item)];
+                                        case 1: return [4 /*yield*/, _g.sent()];
                                         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*/];
+                                            _g.sent();
+                                            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:
+                            _d = 0, _e = this._items({
+                                entries: entries,
+                                query: query,
+                                config: config,
+                                resourceItem: resource,
+                            });
+                            _f.label = 5;
+                        case 5:
+                            if (!(_d < _e.length)) return [3 /*break*/, 8];
+                            item = _e[_d];
+                            return [5 /*yield**/, _loop_1(item)];
+                        case 6:
+                            _f.sent();
+                            _f.label = 7;
+                        case 7:
+                            _d++;
+                            return [3 /*break*/, 5];
+                        case 8: return [3 /*break*/, 10];
+                        case 9:
+                            er_1 = _f.sent();
+                            if (er_1 &&
+                                'name' in er_1 &&
+                                er_1.name !== 'CancelError') {
+                                console.warn(er_1);
+                            }
+                            return [3 /*break*/, 10];
+                        case 10:
                             _i++;
                             return [3 /*break*/, 1];
-                        case 4: return [2 /*return*/];
+                        case 11: return [2 /*return*/];
                     }
                 });
             });
         };
         NgwProvider.prototype.result = function (item) {
+            var signal = this._makeSignal();
             var req = this.connector
-                .get('feature_layer.feature.item_extent', null, {
+                .get('feature_layer.feature.item_extent', { signal: signal }, {
                 id: item.resourceId,
                 fid: item.featureId,
             })
@@ -2533,25 +2913,47 @@ var Geocoder = (function (exports) {
                     extent: [e.minLon, e.minLat, e.maxLon, e.maxLat],
                 };
             });
-            this.requests.push(req);
             return req;
         };
-        NgwProvider.prototype._items = function (entries) {
-            var _this = this;
+        NgwProvider.prototype._makeSignal = function () {
+            var abortController = new AbortController();
+            this._abortControllers.push(abortController);
+            return abortController.signal;
+        };
+        NgwProvider.prototype._items = function (_a) {
+            var _b;
+            var entries = _a.entries, query = _a.query, config = _a.config, resourceItem = _a.resourceItem;
             var items = [];
-            entries.forEach(function (entry) {
-                var meta = _this.searchResources.find(function (x) { return x.id === entry.resourceId; });
-                if (meta) {
+            var labelField = undefined;
+            if (resourceItem.feature_layer) {
+                labelField = (_b = resourceItem.feature_layer.fields.find(function (f) { return f.label_field; })) === null || _b === void 0 ? void 0 : _b.keyname;
+            }
+            var meta = this.searchResources.find(function (x) { var _a; return (_a = x.id) !== null && _a !== void 0 ? _a : x.resourceId === resourceItem.resource.id; });
+            if (meta) {
+                entries.forEach(function (entry) {
+                    var text = labelField ? entry.fields[labelField] : entry.id;
+                    if (config.renderSearch) {
+                        text = config.renderSearch({
+                            item: entry,
+                            resourceItem: resourceItem,
+                        });
+                    }
+                    else if (labelField) {
+                        text = entry.fields[labelField];
+                    }
                     items.push({
-                        query: entry.query,
-                        text: entry.label,
+                        query: query,
+                        text: text,
                         featureId: entry.id,
-                        resourceId: entry.resourceId,
+                        resourceId: resourceItem.resource.id,
+                        item: entry,
+                        resourceItem: resourceItem,
                     });
-                }
-            });
+                });
+            }
             return items;
         };
+        NgwProvider.limit = 300;
         return NgwProvider;
     }(BaseProvider));
 
@@ -2653,6 +3055,12 @@ var Geocoder = (function (exports) {
         return NominatimProvider;
     }(BaseProvider));
 
+    /**
+     * Modern geocoder on async generators. May use different data providers.
+     *
+     * @packageDocumentation
+     * @module geocoder
+     */
     function create(options) {
         return new Geocoder(options);
     }