@nextgis/ngw-map 1.8.1 → 1.9.0

package/lib/ngw-map.esm-browser.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-map; version: 1.8.1; author: NextGIS */
+/** Bundle of @nextgis/ngw-map; version: 1.9.0; author: NextGIS */
 var events = {exports: {}};
 
 var R = typeof Reflect === 'object' ? Reflect : null;
@@ -1264,10 +1264,6 @@ function isPropertyFilter(filter) {
     }
     return false;
 }
-/** @deprecated use {@link isPropertyFilter} instead */
-function checkIfPropertyFilter(filter) {
-    return isPropertyFilter(filter);
-}
 function featureFilter(feature, filters) {
     const properties = { ...feature.properties };
     if (properties) {
@@ -1865,7 +1861,11 @@ class WebMapMain {
      * @returns The map's current zoom level (0-24).
      */
     getZoom() {
-        return this.mapAdapter.getZoom();
+        const zoom = this.mapAdapter.getZoom();
+        if (typeof zoom === 'number') {
+            return zoom;
+        }
+        throw Error('Unable to get zoom level. Perhaps the map is not have been initialized yet');
     }
     zoomIn() {
         if (this.mapAdapter.zoomIn) {
@@ -1891,27 +1891,25 @@ class WebMapMain {
             }
         }
     }
-    /**
-     * Sets the view of the map geographical center and zoom
-     * @param lngLat - Array of two numbers representing longitude and latitude of the center of the map view.
-     * @param zoom - The zoom level to set (0-24).
-     *
-     * @example
-     * ```javascript
-     * // Mount Everest 27° 59′ 17″ N, 86° 55′ 31″ E
-     * webMap.setView([86.925278, 27.988056], 12)
-     * ```
-     */
-    setView(lngLat, zoom) {
-        if (this.mapAdapter.setView && lngLat && defined(zoom)) {
-            this.mapAdapter.setView(lngLat, zoom);
+    setView(lngLatOrOpt, zoom) {
+        if (Array.isArray(lngLatOrOpt)) {
+            const lngLat = lngLatOrOpt;
+            if (this.mapAdapter.setView && lngLat && defined(zoom)) {
+                this.mapAdapter.setView(lngLat, zoom);
+            }
+            else {
+                if (lngLat) {
+                    this.mapAdapter.setCenter(lngLat);
+                }
+                if (defined(zoom)) {
+                    this.mapAdapter.setZoom(zoom);
+                }
+            }
         }
         else {
-            if (lngLat) {
-                this.mapAdapter.setCenter(lngLat);
-            }
-            if (defined(zoom)) {
-                this.mapAdapter.setZoom(zoom);
+            const viewOpt = lngLatOrOpt;
+            if (this.mapAdapter.setView) {
+                this.mapAdapter.setView(viewOpt);
             }
         }
     }
@@ -2325,12 +2323,9 @@ class WebMapLayers extends WebMapMain {
         }
         const geoJsonOptions = options;
         this._updateGeoJsonOptions(geoJsonOptions);
-        const { maxZoom, minZoom } = this.options;
         options = {
             id: String(id),
             order: _order,
-            maxZoom,
-            minZoom,
             ...options,
         };
         // options.visibility is a layer global state
@@ -2591,10 +2586,10 @@ class WebMapLayers extends WebMapMain {
                     }
                 }
                 if (l.showLayer) {
-                    l.showLayer.call(l, l.layer);
+                    await l.showLayer.call(l, l.layer);
                 }
                 else if (l.layer !== undefined) {
-                    this.mapAdapter.showLayer(l.layer);
+                    await this.mapAdapter.showLayer(l.layer);
                 }
                 if (order !== undefined) {
                     this.mapAdapter.setLayerOrder(l.layer, order, this._layers);
@@ -2602,10 +2597,10 @@ class WebMapLayers extends WebMapMain {
             }
             else {
                 if (l.hideLayer) {
-                    l.hideLayer.call(l, l.layer);
+                    await l.hideLayer.call(l, l.layer);
                 }
                 else if (l.layer !== undefined) {
-                    this.mapAdapter.hideLayer(l.layer);
+                    await this.mapAdapter.hideLayer(l.layer);
                 }
             }
             if (!silent) {
@@ -2623,13 +2618,15 @@ class WebMapLayers extends WebMapMain {
         const layer = this.getLayer(layerDef);
         if (layer) {
             if (layer.updateLayer) {
-                layer.updateLayer();
+                return Promise.resolve(layer.updateLayer());
             }
             else if (this.isLayerVisible(layer)) {
-                this.hideLayer(layer, { silent: true });
-                this.showLayer(layer, { silent: true });
+                return this.hideLayer(layer, { silent: true }).then(() => {
+                    return this.showLayer(layer, { silent: true });
+                });
             }
         }
+        return Promise.resolve();
     }
     /**
      * Set transparency for a given layer by number from 0 to 1
@@ -2863,6 +2860,17 @@ class WebMapLayers extends WebMapMain {
             attribution: tileJson.attribution,
         });
     }
+    /** @internal */
+    _emitLayerEvent(name, id, options) {
+        const name_ = String(name);
+        if (defined(id) && name_.startsWith('layer:')) {
+            const specificLayerName = name_.replace('layer:', 'layer-' + id + ':');
+            // @ts-ignore can't paste template literal key for interface
+            this.emitter.emit(specificLayerName, options);
+        }
+        // @ts-ignore
+        this.emitter.emit(name, options);
+    }
     async _onLayerClick(options) {
         const id = options.layer.id;
         this._emitLayerEvent('layer:click', id || '', options);
@@ -2912,14 +2920,6 @@ class WebMapLayers extends WebMapMain {
             }
         }
     }
-    _emitLayerEvent(name, id, options) {
-        if (defined(id) && name.startsWith('layer:')) {
-            const specificLayerName = name.replace('layer:', 'layer-' + id + ':');
-            // @ts-ignore can't paste template literal key for interface
-            this.emitter.emit(specificLayerName, options);
-        }
-        this.emitter.emit(name, options);
-    }
 }
 
 /**
@@ -4522,7 +4522,7 @@ function createFeatureFieldFilterQueries(opt, _queries = [], _parentAllParams =
     };
     if (logic === 'any') {
         filters_.forEach((f) => {
-            if (checkIfPropertyFilter(f)) {
+            if (isPropertyFilter(f)) {
                 _queries.push(fetchNgwLayerItemsRequest({
                     ...opt,
                     paramList: [..._parentAllParams, createParam(f)],
@@ -4540,7 +4540,7 @@ function createFeatureFieldFilterQueries(opt, _queries = [], _parentAllParams =
         const filters = [];
         const propertiesFilterList = [];
         for (const f of filters_) {
-            if (checkIfPropertyFilter(f)) {
+            if (isPropertyFilter(f)) {
                 filters.push(createParam(f));
             }
             else {
@@ -4685,12 +4685,23 @@ function fetchNgwLayerFeatureCollection(options) {
     });
 }
 
+function fetchNgwLayerCount({ connector, resourceId, cache = true, }) {
+    return connector
+        .get('feature_layer.feature.count', { cache }, {
+        id: resourceId,
+    })
+        .then((resp) => {
+        return resp.total_count;
+    });
+}
+
 async function createGeoJsonAdapter(props) {
     var _a, _b;
     const { item, webMap, Adapter, connector, layerOptions, addLayerOptionsPriority: alop, } = props;
     const addLayerOptionsPriority = alop !== null && alop !== void 0 ? alop : true;
     const options = layerOptions;
     const GeoJsonAdapter = Adapter || webMap.mapAdapter.layerAdapters.GEOJSON;
+    const _loadedIds = [];
     let _fullDataLoad = false;
     let _lastFilterArgs;
     let _dataPromise;
@@ -4755,8 +4766,9 @@ async function createGeoJsonAdapter(props) {
                 opt.data = undefined;
                 needUpdate = false;
             }
+            const strategy = opt.strategy || undefined;
+            this.options.strategy = strategy;
             const layer = super.addLayer(opt);
-            this.options.strategy = opt.strategy || undefined;
             _lastFilterArgs = {
                 filters: opt.propertiesFilter,
                 options: getLayerFilterOptions(opt),
@@ -4768,7 +4780,7 @@ async function createGeoJsonAdapter(props) {
             if (waitFullLoad && updatePromise) {
                 await updatePromise;
             }
-            if (this.options.strategy === 'BBOX' && !_fullDataLoad) {
+            if (strategy && strategy.startsWith('BBOX') && !_fullDataLoad) {
                 this._addBboxEventListener();
             }
             return layer;
@@ -4779,7 +4791,8 @@ async function createGeoJsonAdapter(props) {
         }
         async getBounds() {
             const hasData = this.getLayers && this.getLayers().length;
-            if (this.options.strategy === 'BBOX' || hasData) {
+            const strategy = this.options.strategy;
+            if ((strategy === null || strategy === void 0 ? void 0 : strategy.startsWith('BBOX')) || hasData) {
                 return fetchNgwResourceExtent(item, connector);
             }
             else {
@@ -4799,26 +4812,26 @@ async function createGeoJsonAdapter(props) {
             abort();
         }
         getCount() {
-            if (this._count !== undefined) {
-                return this._count;
-            }
-            return connector
-                .get('feature_layer.feature.count', { cache: true }, {
-                id: resourceId,
-            })
-                .then((resp) => {
-                if (resp) {
-                    this._count = resp.total_count;
-                    return this._count;
-                }
-            });
+            return fetchNgwLayerCount({ connector, resourceId, cache: true });
         }
         async updateLayer(filterArgs) {
+            var _a;
             filterArgs = filterArgs || _lastFilterArgs || {};
-            if (this.options.strategy === 'BBOX') {
+            if ((_a = this.options.strategy) === null || _a === void 0 ? void 0 : _a.startsWith('BBOX')) {
                 await webMap.onLoad('create');
                 filterArgs.options = filterArgs.options || {};
                 filterArgs.options.intersects = webMap.getBounds();
+                const { minZoom, maxZoom } = this.options;
+                const zoom = webMap.getZoom();
+                if (minZoom !== undefined && zoom < minZoom) {
+                    return;
+                }
+                if (maxZoom !== undefined && zoom > maxZoom) {
+                    return;
+                }
+                if (_fullDataLoad) {
+                    return;
+                }
             }
             if (removed) {
                 return;
@@ -4828,10 +4841,32 @@ async function createGeoJsonAdapter(props) {
                     ...filterArgs.options,
                     srs: this.options.srs,
                 });
+                let newData = data;
                 const count = await this.getCount();
-                _fullDataLoad = count === data.features.length;
-                await webMap.setLayerData(this, data);
-                this.emitter.emit('updated');
+                if (this.options.strategy === 'BBOX+') {
+                    newData = {
+                        type: 'FeatureCollection',
+                        features: [],
+                    };
+                    for (const f of data.features) {
+                        if (_loadedIds.indexOf(String(f.id)) === -1) {
+                            _loadedIds.push(String(f.id));
+                            newData.features.push(f);
+                        }
+                    }
+                    _fullDataLoad = count !== undefined && _loadedIds.length >= count;
+                    await webMap.addLayerData(this, newData);
+                }
+                else {
+                    _fullDataLoad = count !== undefined && data.features.length >= count;
+                    await webMap.setLayerData(this, data);
+                }
+                this.emitter.emit('updated', data);
+                webMap._emitLayerEvent('layer:updated', options.id || '', {
+                    data,
+                    newData,
+                    isFull: _fullDataLoad,
+                });
             }
             catch (er) {
                 if (er instanceof Error && er.name !== 'CancelError') {
@@ -5712,12 +5747,7 @@ class NgwWebmapItem extends Item {
             options.order = Number((this.options.order | 0) + '.' + subLevel);
         }
         if (item.item_type === 'layer') {
-            const maxZoom = item.layer_max_scale_denom
-                ? this._mapScaleToZoomLevel(item.layer_max_scale_denom)
-                : this.webMap.options.maxZoom;
-            const minZoom = item.layer_min_scale_denom
-                ? this._mapScaleToZoomLevel(item.layer_min_scale_denom)
-                : this.webMap.options.minZoom;
+            const { maxZoom, minZoom } = this._getZoomRange(item);
             objectAssign(options, {
                 updateWmsParams: item.updateWmsParams,
                 url: item.url,
@@ -5740,6 +5770,21 @@ class NgwWebmapItem extends Item {
     _mapScaleToZoomLevel(scale) {
         return setScaleRatio(scale);
     }
+    _getZoomRange(item) {
+        const minZoomWebmap = this.options.minZoom;
+        const maxZoomWebmap = this.options.maxZoom;
+        const minZoomLayer = item.layer_min_scale_denom
+            ? this._mapScaleToZoomLevel(item.layer_min_scale_denom)
+            : undefined;
+        const maxZoomLayer = item.layer_max_scale_denom
+            ? this._mapScaleToZoomLevel(item.layer_max_scale_denom)
+            : undefined;
+        const minZooms = [minZoomWebmap, minZoomLayer].filter(Boolean);
+        const maxZooms = [maxZoomWebmap, maxZoomLayer].filter(Boolean);
+        const minZoom = Math.max(...minZooms);
+        const maxZoom = Math.min(...maxZooms);
+        return { minZoom, maxZoom };
+    }
     _init(item) {
         this.initItem(item).then(() => {
             this.emitter.emit('init');
@@ -5818,15 +5863,23 @@ async function createOnFirstShowAdapter({ webMap, adapterOptions = {}, onLayerAd
         destroyed() {
             return this._removed;
         }
-        showLayer() {
+        async showLayer() {
             this.options.visibility = true;
             if (this.layer.length) {
-                this.layer.forEach((x) => {
-                    webMap.showLayer(x);
-                });
+                for (const x of this.layer) {
+                    await webMap.showLayer(x);
+                }
             }
             else {
-                this.loadLayer();
+                await this.loadLayer();
+            }
+        }
+        async hideLayer() {
+            this.options.visibility = false;
+            if (this.layer) {
+                for (const x of this.layer) {
+                    await webMap.hideLayer(x);
+                }
             }
         }
         async loadLayer() {
@@ -5850,21 +5903,15 @@ async function createOnFirstShowAdapter({ webMap, adapterOptions = {}, onLayerAd
                     if (this._removed) {
                         webMap.removeLayer(adapter);
                     }
+                    this.layer.push(adapter);
                     if (this.options.visibility) {
                         await webMap.showLayer(adapter);
                     }
-                    this.layer.push(adapter);
                     this._creatingInProgress = false;
                 }
             }
             return this.layer;
         }
-        hideLayer() {
-            this.options.visibility = false;
-            if (this.layer) {
-                this.layer.forEach((x) => webMap.hideLayer(x));
-            }
-        }
     }
     return OnFirstShowAdapter;
 }
@@ -6087,6 +6134,8 @@ class NgwWebmapLayerAdapter {
                     options.order = this.options.order;
                     options.ratio = this.options.ratio;
                     options.crossOrigin = this.options.crossOrigin;
+                    options.minZoom = this.options.minZoom;
+                    options.maxZoom = this.options.maxZoom;
                     options.drawOrderEnabled = webmap.draw_order_enabled;
                     const layer = new this.NgwWebmapItem(this.options.webMap, webmap.root_item, options, this.options.connector);
                     layer.emitter.on('init', () => resolve(layer));