@nextgis/geocoder 1.17.0 → 1.18.3

package/lib/geocoder.esm-browser.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 */
 class CancelError extends Error {
     constructor() {
         super();
@@ -376,6 +376,47 @@ function full(val) {
     return typeof val === 'string' ? !!val : defined(val);
 }
 
+function getBoundsCoordinates(b) {
+    const westNorth = [b[0], b[1]];
+    const eastNorth = [b[2], b[1]];
+    const eastSouth = [b[2], b[3]];
+    const 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;
+    const x = (lng * 20037508.34) / 180;
+    let 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((x) => 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.
@@ -451,11 +492,29 @@ function objectRemoveEmpty(obj) {
     return newObj;
 }
 
+function round(val, toFixed) {
+    const 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.
+ */
 class BaseGeocoder {
     constructor(options) {
         if (options) {
@@ -501,6 +560,11 @@ class Geocoder extends 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 {
 }
 
@@ -2138,59 +2202,395 @@ NgwConnector$1.errors = {
  */
 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;
+    const re = `^${reEscape(a)}$`.replace(/%/g, '.*').replace('_', '.');
+    return new RegExp(re, iLike ? 'i' : '').exec(b) !== null;
+}
+const operationsAliases = {
+    // greater(>)
+    gt: (a, b) => a > b,
+    // lower(<)
+    lt: (a, b) => a < b,
+    // greater or equal(>=)
+    ge: (a, b) => a >= b,
+    // lower or equal(<=)
+    le: (a, b) => a <= b,
+    // equal(=)
+    eq: (a, b) => a === b,
+    //  not equal(!=)
+    ne: (a, b) => a !== b,
+    in: (a, b) => b.indexOf(a) !== -1,
+    notin: (a, b) => b.indexOf(a) === -1,
+    // LIKE SQL statement(for strings compare)
+    like: (a, b) => {
+        return like(a, b);
+    },
+    // ILIKE SQL statement(for strings compare)
+    ilike: (a, b) => {
+        return like(a, b, true);
+    },
+};
+function isPropertyFilter(filter) {
+    const pf = filter;
+    if (pf.length === 3 &&
+        typeof pf[0] === 'string' &&
+        typeof pf[1] === 'string') {
+        return true;
+    }
+    return false;
+}
+function propertiesFilter(properties, filters) {
+    const logic = typeof filters[0] === 'string' ? filters[0] : 'all';
+    const filterFunction = (p) => {
+        if (isPropertyFilter(p)) {
+            const [field, operation, value] = p;
+            const operationExec = operationsAliases[operation];
+            if (operationExec) {
+                if (operation === 'like' || operation === 'ilike') {
+                    if (typeof field === 'string') {
+                        let prop = '';
+                        const value_ = field.replace(/^%?(\w+)%?$/, (match, cleanField) => {
+                            prop = properties[cleanField];
+                            return field.replace(cleanField, value);
+                        });
+                        return operationExec(prop, value_);
+                    }
+                }
+                return operationExec(properties[field], value);
+            }
+            return false;
+        }
+        else {
+            return propertiesFilter(properties, p);
+        }
+    };
+    const filters_ = filters.filter((x) => Array.isArray(x));
+    return logic === 'any'
+        ? filters_.some(filterFunction)
+        : filters_.every(filterFunction);
+}
+
+const FEATURE_REQUEST_PARAMS = {
+    srs: 4326,
+    geom_format: 'geojson',
+};
+function updateItemRequestParam(params, options) {
+    const { extensions, geom, fields, srs, ilike, like } = options;
+    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) {
+    const queries = getQueries(opt);
+    return CancelablePromise.all(queries).then((itemsParts) => {
+        // this list of ids used for optimization
+        const ids = [];
+        const items = [];
+        for (const part of itemsParts) {
+            for (const item of part) {
+                if (!ids.includes(item.id)) {
+                    items.push(item);
+                    ids.push(item.id);
+                }
+            }
+        }
+        const offset = opt.offset !== undefined ? opt.offset : 0;
+        const limit = opt.limit !== undefined ? opt.limit : items.length;
+        if (opt.offset || opt.limit) {
+            return items.splice(offset, limit);
+        }
+        return items;
+    });
+}
+function createParam(pf) {
+    const [field, operation, value] = pf;
+    const isFldStr = field !== 'id' ? 'fld_' : '';
+    let vStart = '';
+    let vEnd = '';
+    const field_ = String(field)
+        .trim()
+        .replace(/^(%?)(.+?)(%?)$/, (m, a, b, c) => {
+        vStart = a;
+        vEnd = c;
+        return b;
+    });
+    const v = vStart + value + vEnd;
+    return [`${isFldStr}${field_}__${operation}`, v];
+}
+function getQueries(opt, _queries = [], _parentAllParams = []) {
+    const { filters } = opt;
+    const logic = typeof filters[0] === 'string' ? filters[0] : 'all';
+    const filters_ = filters.filter((x) => Array.isArray(x));
+    if (logic === 'any') {
+        for (const f of filters_) {
+            if (isPropertyFilter(f)) {
+                _queries.push(fetchNgwLayerItemsRequest({
+                    ...opt,
+                    paramList: [..._parentAllParams, createParam(f)],
+                }));
+            }
+            else {
+                getQueries({
+                    ...opt,
+                    filters: f,
+                }, _queries, [..._parentAllParams]);
+            }
+        }
+    }
+    else if (logic === 'all') {
+        const filters = [];
+        const propertiesFilterList = [];
+        for (const f of filters_) {
+            if (isPropertyFilter(f)) {
+                filters.push(createParam(f));
+            }
+            else {
+                propertiesFilterList.push(f);
+            }
+        }
+        if (propertiesFilterList.length) {
+            for (const x of propertiesFilterList) {
+                getQueries({
+                    ...opt,
+                    filters: x,
+                }, _queries, [..._parentAllParams, ...filters]);
+            }
+        }
+        else {
+            _queries.push(fetchNgwLayerItemsRequest({
+                ...opt,
+                paramList: [..._parentAllParams, ...filters],
+            }));
+        }
+    }
+    return _queries;
+}
+function createWktFromCoordArray(coord) {
+    const polygon = coord.map(([lng, lat]) => {
+        const [x, y] = degrees2meters(lng, lat).map((c) => round(c));
+        return x + ' ' + y;
+    });
+    return `POLYGON((${polygon.join(', ')}))`;
+}
+function fetchNgwLayerItemsRequest(options) {
+    const params = {
+        ...FEATURE_REQUEST_PARAMS,
+    };
+    const { limit, cache, signal, offset, orderBy, paramList, connector, geomFormat, intersects, resourceId, } = options;
+    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)) {
+        const coordinates = isLngLatBoundsArray(intersects)
+            ? getBoundsCoordinates(intersects)
+            : intersects;
+        params.intersects = createWktFromCoordArray(coordinates);
+    }
+    else if (typeof intersects === 'string') {
+        params.intersects = intersects;
+    }
+    if (paramList) {
+        params.paramList = paramList;
+    }
+    const reqParams = {
+        id: resourceId,
+        ...params,
+    };
+    return connector.get('feature_layer.feature.collection', { cache, signal }, reqParams);
+}
+
+function prepareNgwFieldsToPropertiesFilter(fields) {
+    let f;
+    for (f in fields) {
+        const field = fields[f];
+        if (isObject$1(field)) {
+            const date = field;
+            if (defined(date.year) && defined(date.month) && defined(date.day)) {
+                const dt = [
+                    date.year,
+                    date.month - 1,
+                    date.day,
+                ];
+                if ('hour' in date) {
+                    [date.hour, date.minute, date.second].forEach((x) => {
+                        dt.push(x);
+                    });
+                }
+                fields[f] = new Date(...dt).toISOString();
+            }
+        }
+        else if (f === 'id' && typeof field === 'string') {
+            fields[f] = field.split(',').map(Number);
+        }
+    }
+    return fields;
+}
+
+function fetchNgwLayerItems(options) {
+    const filters = options.filters;
+    if (filters) {
+        return createFeatureFieldFilterQueries({
+            ...options,
+            filters,
+        }).then((data) => {
+            var _a;
+            const clientFilterValidate = (_a = options.clientFilterValidate) !== null && _a !== void 0 ? _a : isFilterWithAnyCase(filters);
+            // Additional client-side filter check
+            if (clientFilterValidate) {
+                data = data.filter((y) => {
+                    const fields = prepareNgwFieldsToPropertiesFilter({
+                        ...y.fields,
+                        id: y.id,
+                    });
+                    const result = propertiesFilter(fields, filters);
+                    return result;
+                });
+            }
+            return data;
+        });
+    }
+    else {
+        return fetchNgwLayerItemsRequest(options);
+    }
+}
+function isFilterWithAnyCase(filters) {
+    if (filters[0] === 'any') {
+        return true;
+    }
+    for (let i = 1; i < filters.length; i++) {
+        const p = filters[i];
+        if (isArray(p)) {
+            const deep = isFilterWithAnyCase(p);
+            if (deep) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
 class NgwProvider extends BaseProvider {
     constructor(options) {
+        var _a;
         super(options);
         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,
+                    ...options.connectorOptions,
                 });
         this.searchResources = options.searchResources;
     }
     abort() {
-        this.requests.forEach((x) => {
-            x.cancel();
+        this._abortControllers.forEach((a) => {
+            a.abort();
         });
-        this.requests = [];
-    }
-    async *search(like) {
-        for (const resource of this.searchResources) {
-            const limit = resource.limit || 300;
-            const request = this.connector.get('feature_layer.store', {
-                headers: { RANGE: `items=0-${limit}` },
-            }, {
-                id: resource.id,
-                like,
-            });
-            this.requests.push(request);
-            request.catch((er) => {
-                console.warn(er);
-            });
-            const resp = await request;
-            const entries = [];
-            if (resp) {
-                resp.forEach((x) => {
-                    entries.push({
-                        query: like,
-                        resourceId: resource.id,
-                        ...x,
-                    });
+        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;
+                }
             }
-            for (const item of this._items(entries)) {
-                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', null, {
+            .get('feature_layer.feature.item_extent', { signal }, {
             id: item.resourceId,
             fid: item.featureId,
         })
@@ -2201,25 +2601,47 @@ class NgwProvider extends BaseProvider {
                 extent: [e.minLon, e.minLat, e.maxLon, e.maxLat],
             };
         });
-        this.requests.push(req);
         return req;
     }
-    _items(entries) {
+    _makeSignal() {
+        const abortController = new AbortController();
+        this._abortControllers.push(abortController);
+        return abortController.signal;
+    }
+    _items({ entries, query, config, resourceItem, }) {
+        var _a;
         const items = [];
-        entries.forEach((entry) => {
-            const meta = this.searchResources.find((x) => x.id === entry.resourceId);
-            if (meta) {
+        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: entry.query,
-                    text: entry.label,
+                    query: query,
+                    text,
                     featureId: entry.id,
-                    resourceId: entry.resourceId,
+                    resourceId: resourceItem.resource.id,
+                    item: entry,
+                    resourceItem,
                 });
-            }
-        });
+            });
+        }
         return items;
     }
 }
+NgwProvider.limit = 300;
 
 class NominatimProvider extends BaseProvider {
     constructor(options) {
@@ -2285,6 +2707,12 @@ class NominatimProvider extends BaseProvider {
     }
 }
 
+/**
+ * Modern geocoder on async generators. May use different data providers.
+ *
+ * @packageDocumentation
+ * @module geocoder
+ */
 function create(options) {
     return new Geocoder(options);
 }