@nextgis/ngw-map 1.6.0 → 1.8.2

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

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-map; version: 1.6.0; author: NextGIS */
+/** Bundle of @nextgis/ngw-map; version: 1.8.2; author: NextGIS */
 var events = {exports: {}};
 
 var R = typeof Reflect === 'object' ? Reflect : null;
@@ -2197,8 +2197,10 @@ class WebMapLayers extends WebMapMain {
      */
     async fitLayer(layerDef, options) {
         const layer = this.getLayer(layerDef);
-        if (layer && layer.getExtent) {
-            const extent = await layer.getExtent();
+        // TODO: remove backward compatibility for `getExtent`
+        const getBounds = layer && (layer.getBounds || layer.getExtent);
+        if (getBounds) {
+            const extent = await getBounds.call(layer);
             if (extent) {
                 this.fitBounds(extent, options);
             }
@@ -2401,8 +2403,10 @@ class WebMapLayers extends WebMapMain {
             if (opacity !== undefined && opacity <= 1) {
                 this.setLayerOpacity(_adapter, opacity);
             }
-            if (options.fit && _adapter.getExtent) {
-                const extent = await _adapter.getExtent();
+            // TODO: remove backward compatibility for `getExtent`
+            const getBounds = layer && (_adapter.getBounds || _adapter.getExtent);
+            if (options.fit && getBounds) {
+                const extent = await getBounds.call(_adapter);
                 if (extent) {
                     await this.fitBounds(extent);
                 }
@@ -2579,11 +2583,11 @@ class WebMapLayers extends WebMapMain {
                 const order = l.options.baselayer ? 0 : l.options.order;
                 // do not show baselayer if another on the map
                 if (l.options.baselayer && this._baselayers.length) {
-                    const anotherVisibleLayerBaseLayer = this._baselayers.find((x) => {
+                    const anotherVisibleBaselayers = this._baselayers.filter((x) => {
                         return x !== l.id && this.isLayerVisible(x);
                     });
-                    if (anotherVisibleLayerBaseLayer) {
-                        await this.hideLayer(anotherVisibleLayerBaseLayer);
+                    for (const bl of anotherVisibleBaselayers) {
+                        await this.hideLayer(bl);
                     }
                 }
                 if (l.showLayer) {
@@ -2619,13 +2623,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
@@ -4410,6 +4416,17 @@ function fetchNgwLayerExtent({ resourceId, connector, cache = true, }) {
         }
     });
 }
+function fetchNgwLayerItemExtent({ resourceId, featureId, connector, cache = true, }) {
+    return connector
+        .get('feature_layer.feature.item_extent', { cache }, { id: resourceId, fid: featureId })
+        .then((resp) => {
+        if (resp) {
+            const { maxLat, maxLon, minLat, minLon } = resp.extent;
+            const extentArray = [minLon, minLat, maxLon, maxLat];
+            return extentArray;
+        }
+    });
+}
 function fetchNgwResourceExtent(item, connector) {
     if (item.webmap) {
         return CancelablePromise.resolve(getNgwWebmapExtent(item.webmap));
@@ -4758,14 +4775,18 @@ async function createGeoJsonAdapter(props) {
             }
             return layer;
         }
+        /** @deprecated use {@link NgwGeoJsonAdapter.getBounds} instead */
         getExtent() {
+            return this.getBounds();
+        }
+        async getBounds() {
             const hasData = this.getLayers && this.getLayers().length;
             if (this.options.strategy === 'BBOX' || hasData) {
                 return fetchNgwResourceExtent(item, connector);
             }
             else {
-                if (super.getExtent) {
-                    return super.getExtent();
+                if (super.getBounds) {
+                    return super.getBounds();
                 }
             }
         }
@@ -5250,6 +5271,9 @@ class BaseProperty {
     getParent() {
         return this.item.tree.getParent();
     }
+    getChildren() {
+        return this.item.tree.getChildren();
+    }
     isGroup() {
         const children = this.item.tree.getDescendants();
         return children.length;
@@ -5364,6 +5388,24 @@ class CheckProperty extends BaseProperty {
                 return property && property.get();
             }));
     }
+    block(options) {
+        this._blocked = true;
+        this._block(options);
+    }
+    unBlock(options) {
+        this._blocked = false;
+        if (this.getValue()) {
+            this._unBlock(options);
+        }
+    }
+    blockChild(options) {
+        this.item.tree
+            .getDescendants()
+            .forEach((x) => this._blockChild(x, options));
+    }
+    unblockChild(options) {
+        this.item.tree.getChildren().forEach((x) => this._unBlockChild(x, options));
+    }
     _prepareValue(value) {
         return value;
     }
@@ -5385,30 +5427,12 @@ class CheckProperty extends BaseProperty {
             this.unblockChild(options);
         }
     }
-    block(options) {
-        this._blocked = true;
-        this._block(options);
-    }
     _block(options) {
         this._turnOff(options);
     }
-    unBlock(options) {
-        this._blocked = false;
-        if (this.getValue()) {
-            this._unBlock(options);
-        }
-    }
     _unBlock(options) {
         this._turnOn(options);
     }
-    blockChild(options) {
-        this.item.tree
-            .getDescendants()
-            .forEach((x) => this._blockChild(x, options));
-    }
-    unblockChild(options) {
-        this.item.tree.getChildren().forEach((x) => this._unBlockChild(x, options));
-    }
     _blockChild(item, options) {
         const prop = item.properties &&
             item.properties.property(this.name);
@@ -5466,22 +5490,22 @@ class ItemProperties {
     }
     _setPropertyHandler(propOpt) {
         const handlers = ItemProperties.handlers;
-        let handler = propOpt.handler;
-        if (!handler && propOpt.type) {
+        let Handler = propOpt.handler;
+        if (!Handler && propOpt.type) {
             switch (propOpt.type) {
                 case 'boolean':
-                    handler = handlers.CheckProperty;
+                    Handler = handlers.CheckProperty;
                     break;
                 case 'string':
-                    handler = handlers.BaseProperty;
+                    Handler = handlers.BaseProperty;
                     break;
                 default:
-                    handler = handlers.BaseProperty;
+                    Handler = handlers.BaseProperty;
             }
         }
-        if (handler && propOpt.name) {
+        if (Handler && propOpt.name) {
             const options = { ...(propOpt || {}) };
-            this._properties[propOpt.name] = new handler(propOpt.name, this.item, options);
+            this._properties[propOpt.name] = new Handler(propOpt.name, this.item, options);
             this._propertiesList.push(propOpt.name);
         }
     }
@@ -5537,6 +5561,55 @@ class Item {
     }
 }
 
+class WebmapLayerOpacityPropertyHandler extends BaseProperty {
+    getProperty() {
+        const layer = this.item.layer;
+        if (layer) {
+            return layer && layer.options && layer.options.opacity !== undefined
+                ? layer.options.opacity
+                : 1;
+        }
+        return 1;
+    }
+    update(value, options) {
+        options = options || {};
+        if (this.isGroup()) {
+            this._value = this._prepareValue(value, options);
+            const children = this.getChildren();
+            for (const child of children) {
+                const property = child.properties.property(this.name);
+                if (property) {
+                    if (options.propagation) {
+                        property.set(value, options);
+                    }
+                    else {
+                        property.update(property.get(), options);
+                    }
+                }
+            }
+        }
+        const layer = this.item.layer;
+        if (layer) {
+            const parents = this.getParents();
+            const coef = parents.reduce((s, x) => {
+                const prop = x.properties.property(this.name);
+                const multiplier = prop ? prop.getValue() : 1;
+                return s * multiplier;
+            }, 1);
+            const val = value * coef;
+            this.item.webMap.setLayerOpacity(layer, this._prepareValue(val));
+        }
+    }
+    _prepareValue(value, options) {
+        if (options && options.propagation && this.isGroup()) {
+            return 1;
+        }
+        // value = Number(value);
+        // return value < 0.1 ? 0.1 : value;
+        return Number(value);
+    }
+}
+
 class NgwWebmapItem extends Item {
     constructor(webMap, item, options, connector, parent, noInit) {
         super({ ...NgwWebmapItem.options, ...options });
@@ -5618,6 +5691,9 @@ class NgwWebmapItem extends Item {
     fit() {
         if (this.item.item_type === 'layer') ;
     }
+    getLayer() {
+        return this.layer;
+    }
     getItemOptions(item) {
         const transparency = item.item_type === 'layer' && item.layer_transparency;
         const opacity = typeof transparency === 'number' ? (100 - transparency) / 100 : undefined;
@@ -5719,6 +5795,10 @@ NgwWebmapItem.options = {
                 }
             },
         },
+        {
+            name: 'opacity',
+            handler: WebmapLayerOpacityPropertyHandler,
+        },
     ],
 };
 
@@ -5905,17 +5985,26 @@ class NgwWebmapLayerAdapter {
         delete this.response;
         delete this._webmapLayersIds;
     }
-    showLayer() {
+    async showLayer() {
+        if (this.layer && this.layer.properties) {
+            return this.layer.properties.property('visibility').set(true);
+        }
+    }
+    async hideLayer() {
         if (this.layer && this.layer.properties) {
-            this.layer.properties.property('visibility').set(true);
+            return this.layer.properties.property('visibility').set(false);
         }
     }
-    hideLayer() {
+    async setOpacity(val) {
         if (this.layer && this.layer.properties) {
-            this.layer.properties.property('visibility').set(false);
+            return this.layer.properties.property('opacity').set(val);
         }
     }
+    /** @deprecated use {@link NgwWebmapLayerAdapter.getBounds} instead */
     getExtent() {
+        return this.getBounds();
+    }
+    getBounds() {
         const webmap = this.response && this.response.webmap;
         if (webmap) {
             return getNgwWebmapExtent(webmap);
@@ -6133,12 +6222,16 @@ async function createWebMapAdapter({ layerOptions: options, webMap, connector, }
 }
 
 class NgwResource {
+    /** @deprecated use {@link NgwResource.getBounds} instead */
     async getExtent() {
+        return this.getBounds();
+    }
+    async getBounds() {
         if (this._extent) {
             return this._extent;
         }
         if (this.item) {
-            this._extent = await fetchNgwResourceExtent(this.item, this.connector).then();
+            this._extent = await fetchNgwResourceExtent(this.item, this.connector);
             return this._extent;
         }
     }
@@ -6574,11 +6667,11 @@ class IdentifyItem {
     constructor(options) {
         const f = options.feature;
         this.id = f.id;
+        this.geom = f.geom;
         this.label = f.label;
-        this.layerId = f.layerId;
         this.parent = f.parent;
         this.fields = f.fields;
-        this.geom = f.geom;
+        this.layerId = f.layerId;
         this.connector = options.connector;
     }
     identify(options = {}) {
@@ -6608,6 +6701,16 @@ class IdentifyItem {
             return this._resource.feature_layer;
         });
     }
+    getBounds() {
+        if (this._extent) {
+            return CancelablePromise.resolve(this._extent);
+        }
+        return fetchNgwLayerItemExtent({
+            connector: this.connector,
+            featureId: this.id,
+            resourceId: this.layerId,
+        });
+    }
     geojson() {
         if (this._geojson) {
             return CancelablePromise.resolve(this._geojson);
@@ -7200,10 +7303,10 @@ class NgwMap extends WebMap {
         }
         const ngwLayer = id && this._ngwLayers[id];
         if (ngwLayer) {
-            if (ngwLayer.layer.getExtent) {
-                const extent = await ngwLayer.layer.getExtent();
-                if (extent) {
-                    this.fitBounds(extent, options);
+            if (ngwLayer.layer.getBounds) {
+                const bounds = await ngwLayer.layer.getBounds();
+                if (bounds) {
+                    this.fitBounds(bounds, options);
                 }
             }
             else {