@nextgis/ngw-leaflet 1.8.0 → 1.8.4

package/lib/ngw-leaflet.esm-bundler.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-leaflet; version: 1.8.0; author: NextGIS */
+/** Bundle of @nextgis/ngw-leaflet; version: 1.8.4; author: NextGIS */
 import 'leaflet/dist/leaflet.css';
 import { Icon } from 'leaflet';
 import { NgwMap } from '@nextgis/ngw-map';

package/lib/ngw-leaflet.global.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-leaflet; version: 1.8.0; author: NextGIS */
+/** Bundle of @nextgis/ngw-leaflet; version: 1.8.4; author: NextGIS */
 var NgwLeaflet = (function () {
     'use strict';
 
@@ -16943,7 +16943,7 @@ var NgwLeaflet = (function () {
                                 this._emitLayerEvent(preEventName, id, l);
                                 this._emitLayerEvent('layer:pretoggle', id, l);
                             }
-                            if (!(toStatus && this.mapAdapter)) return [3 /*break*/, 5];
+                            if (!(toStatus && this.mapAdapter)) return [3 /*break*/, 9];
                             order = l.options.baselayer ? 0 : l.options.order;
                             if (!(l.options.baselayer && this._baselayers.length)) return [3 /*break*/, 4];
                             anotherVisibleBaselayers = this._baselayers.filter(function (x) {
@@ -16962,25 +16962,35 @@ var NgwLeaflet = (function () {
                             _i++;
                             return [3 /*break*/, 1];
                         case 4:
-                            if (l.showLayer) {
-                                l.showLayer.call(l, l.layer);
-                            }
-                            else if (l.layer !== undefined) {
-                                this.mapAdapter.showLayer(l.layer);
-                            }
+                            if (!l.showLayer) return [3 /*break*/, 6];
+                            return [4 /*yield*/, l.showLayer.call(l, l.layer)];
+                        case 5:
+                            _a.sent();
+                            return [3 /*break*/, 8];
+                        case 6:
+                            if (!(l.layer !== undefined)) return [3 /*break*/, 8];
+                            return [4 /*yield*/, this.mapAdapter.showLayer(l.layer)];
+                        case 7:
+                            _a.sent();
+                            _a.label = 8;
+                        case 8:
                             if (order !== undefined) {
                                 this.mapAdapter.setLayerOrder(l.layer, order, this._layers);
                             }
-                            return [3 /*break*/, 6];
-                        case 5:
-                            if (l.hideLayer) {
-                                l.hideLayer.call(l, l.layer);
-                            }
-                            else if (l.layer !== undefined) {
-                                this.mapAdapter.hideLayer(l.layer);
-                            }
-                            _a.label = 6;
-                        case 6:
+                            return [3 /*break*/, 13];
+                        case 9:
+                            if (!l.hideLayer) return [3 /*break*/, 11];
+                            return [4 /*yield*/, l.hideLayer.call(l, l.layer)];
+                        case 10:
+                            _a.sent();
+                            return [3 /*break*/, 13];
+                        case 11:
+                            if (!(l.layer !== undefined)) return [3 /*break*/, 13];
+                            return [4 /*yield*/, this.mapAdapter.hideLayer(l.layer)];
+                        case 12:
+                            _a.sent();
+                            _a.label = 13;
+                        case 13:
                             if (!silent) {
                                 this._emitLayerEvent(eventName, id, l);
                                 this._emitLayerEvent('layer:toggle', id, l);
@@ -16996,16 +17006,19 @@ var NgwLeaflet = (function () {
             return Promise.resolve();
         };
         WebMapLayers.prototype.updateLayer = function (layerDef) {
+            var _this = this;
             var 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(function () {
+                        return _this.showLayer(layer, { silent: true });
+                    });
                 }
             }
+            return Promise.resolve();
         };
         /**
          * Set transparency for a given layer by number from 0 to 1
@@ -19864,6 +19877,9 @@ var NgwLeaflet = (function () {
         BaseProperty.prototype.getParent = function () {
             return this.item.tree.getParent();
         };
+        BaseProperty.prototype.getChildren = function () {
+            return this.item.tree.getChildren();
+        };
         BaseProperty.prototype.isGroup = function () {
             var children = this.item.tree.getDescendants();
             return children.length;
@@ -19984,6 +20000,26 @@ var NgwLeaflet = (function () {
                     return property && property.get();
                 }));
         };
+        CheckProperty.prototype.block = function (options) {
+            this._blocked = true;
+            this._block(options);
+        };
+        CheckProperty.prototype.unBlock = function (options) {
+            this._blocked = false;
+            if (this.getValue()) {
+                this._unBlock(options);
+            }
+        };
+        CheckProperty.prototype.blockChild = function (options) {
+            var _this = this;
+            this.item.tree
+                .getDescendants()
+                .forEach(function (x) { return _this._blockChild(x, options); });
+        };
+        CheckProperty.prototype.unblockChild = function (options) {
+            var _this = this;
+            this.item.tree.getChildren().forEach(function (x) { return _this._unBlockChild(x, options); });
+        };
         CheckProperty.prototype._prepareValue = function (value) {
             return value;
         };
@@ -20005,32 +20041,12 @@ var NgwLeaflet = (function () {
                 this.unblockChild(options);
             }
         };
-        CheckProperty.prototype.block = function (options) {
-            this._blocked = true;
-            this._block(options);
-        };
         CheckProperty.prototype._block = function (options) {
             this._turnOff(options);
         };
-        CheckProperty.prototype.unBlock = function (options) {
-            this._blocked = false;
-            if (this.getValue()) {
-                this._unBlock(options);
-            }
-        };
         CheckProperty.prototype._unBlock = function (options) {
             this._turnOn(options);
         };
-        CheckProperty.prototype.blockChild = function (options) {
-            var _this = this;
-            this.item.tree
-                .getDescendants()
-                .forEach(function (x) { return _this._blockChild(x, options); });
-        };
-        CheckProperty.prototype.unblockChild = function (options) {
-            var _this = this;
-            this.item.tree.getChildren().forEach(function (x) { return _this._unBlockChild(x, options); });
-        };
         CheckProperty.prototype._blockChild = function (item, options) {
             var prop = item.properties &&
                 item.properties.property(this.name);
@@ -20086,22 +20102,22 @@ var NgwLeaflet = (function () {
         };
         ItemProperties.prototype._setPropertyHandler = function (propOpt) {
             var handlers = ItemProperties.handlers;
-            var handler = propOpt.handler;
-            if (!handler && propOpt.type) {
+            var 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) {
                 var options = __assign({}, (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);
             }
         };
@@ -20160,6 +20176,62 @@ var NgwLeaflet = (function () {
         return Item;
     }());
 
+    var WebmapLayerOpacityPropertyHandler = /** @class */ (function (_super) {
+        __extends(WebmapLayerOpacityPropertyHandler, _super);
+        function WebmapLayerOpacityPropertyHandler() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        WebmapLayerOpacityPropertyHandler.prototype.getProperty = function () {
+            var layer = this.item.layer;
+            if (layer) {
+                return layer && layer.options && layer.options.opacity !== undefined
+                    ? layer.options.opacity
+                    : 1;
+            }
+            return 1;
+        };
+        WebmapLayerOpacityPropertyHandler.prototype.update = function (value, options) {
+            var _this = this;
+            options = options || {};
+            if (this.isGroup()) {
+                this._value = this._prepareValue(value, options);
+                var children = this.getChildren();
+                for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+                    var child = children_1[_i];
+                    var property = child.properties.property(this.name);
+                    if (property) {
+                        if (options.propagation) {
+                            property.set(value, options);
+                        }
+                        else {
+                            property.update(property.get(), options);
+                        }
+                    }
+                }
+            }
+            var layer = this.item.layer;
+            if (layer) {
+                var parents = this.getParents();
+                var coef = parents.reduce(function (s, x) {
+                    var prop = x.properties.property(_this.name);
+                    var multiplier = prop ? prop.getValue() : 1;
+                    return s * multiplier;
+                }, 1);
+                var val = value * coef;
+                this.item.webMap.setLayerOpacity(layer, this._prepareValue(val));
+            }
+        };
+        WebmapLayerOpacityPropertyHandler.prototype._prepareValue = function (value, options) {
+            if (options && options.propagation && this.isGroup()) {
+                return 1;
+            }
+            // value = Number(value);
+            // return value < 0.1 ? 0.1 : value;
+            return Number(value);
+        };
+        return WebmapLayerOpacityPropertyHandler;
+    }(BaseProperty));
+
     var NgwWebmapItem = /** @class */ (function (_super) {
         __extends(NgwWebmapItem, _super);
         function NgwWebmapItem(webMap, item, options, connector, parent, noInit) {
@@ -20254,6 +20326,9 @@ var NgwLeaflet = (function () {
         NgwWebmapItem.prototype.fit = function () {
             if (this.item.item_type === 'layer') ;
         };
+        NgwWebmapItem.prototype.getLayer = function () {
+            return this.layer;
+        };
         NgwWebmapItem.prototype.getItemOptions = function (item) {
             var transparency = item.item_type === 'layer' && item.layer_transparency;
             var opacity = typeof transparency === 'number' ? (100 - transparency) / 100 : undefined;
@@ -20274,12 +20349,7 @@ var NgwLeaflet = (function () {
                 options.order = Number((this.options.order | 0) + '.' + subLevel);
             }
             if (item.item_type === 'layer') {
-                var maxZoom = item.layer_max_scale_denom
-                    ? this._mapScaleToZoomLevel(item.layer_max_scale_denom)
-                    : this.webMap.options.maxZoom;
-                var minZoom = item.layer_min_scale_denom
-                    ? this._mapScaleToZoomLevel(item.layer_min_scale_denom)
-                    : this.webMap.options.minZoom;
+                var _a = this._getZoomRange(item), maxZoom = _a.maxZoom, minZoom = _a.minZoom;
                 objectAssign(options, {
                     updateWmsParams: item.updateWmsParams,
                     url: item.url,
@@ -20302,6 +20372,23 @@ var NgwLeaflet = (function () {
         NgwWebmapItem.prototype._mapScaleToZoomLevel = function (scale) {
             return setScaleRatio(scale);
         };
+        NgwWebmapItem.prototype._getZoomRange = function (item) {
+            var minZoomMap = this.webMap.options.minZoom;
+            var maxZoomMap = this.webMap.options.maxZoom;
+            var minZoomWebmap = this.options.minZoom;
+            var maxZoomWebmap = this.options.maxZoom;
+            var minZoomLayer = item.layer_min_scale_denom
+                ? this._mapScaleToZoomLevel(item.layer_min_scale_denom)
+                : undefined;
+            var maxZoomLayer = item.layer_max_scale_denom
+                ? this._mapScaleToZoomLevel(item.layer_max_scale_denom)
+                : undefined;
+            var minZooms = [minZoomMap, minZoomWebmap, minZoomLayer].filter(Boolean);
+            var maxZooms = [maxZoomMap, maxZoomWebmap, maxZoomLayer].filter(Boolean);
+            var minZoom = Math.max.apply(Math, minZooms);
+            var maxZoom = Math.min.apply(Math, maxZooms);
+            return { minZoom: minZoom, maxZoom: maxZoom };
+        };
         NgwWebmapItem.prototype._init = function (item) {
             var _this = this;
             this.initItem(item).then(function () {
@@ -20357,6 +20444,10 @@ var NgwLeaflet = (function () {
                         }
                     },
                 },
+                {
+                    name: 'opacity',
+                    handler: WebmapLayerOpacityPropertyHandler,
+                },
             ],
         };
         return NgwWebmapItem;
@@ -20385,15 +20476,59 @@ var NgwLeaflet = (function () {
                         return this._removed;
                     };
                     OnFirstShowAdapter.prototype.showLayer = function () {
-                        this.options.visibility = true;
-                        if (this.layer.length) {
-                            this.layer.forEach(function (x) {
-                                webMap.showLayer(x);
+                        return __awaiter(this, void 0, void 0, function () {
+                            var _i, _a, x;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        this.options.visibility = true;
+                                        if (!this.layer.length) return [3 /*break*/, 5];
+                                        _i = 0, _a = this.layer;
+                                        _b.label = 1;
+                                    case 1:
+                                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                                        x = _a[_i];
+                                        return [4 /*yield*/, webMap.showLayer(x)];
+                                    case 2:
+                                        _b.sent();
+                                        _b.label = 3;
+                                    case 3:
+                                        _i++;
+                                        return [3 /*break*/, 1];
+                                    case 4: return [3 /*break*/, 7];
+                                    case 5: return [4 /*yield*/, this.loadLayer()];
+                                    case 6:
+                                        _b.sent();
+                                        _b.label = 7;
+                                    case 7: return [2 /*return*/];
+                                }
                             });
-                        }
-                        else {
-                            this.loadLayer();
-                        }
+                        });
+                    };
+                    OnFirstShowAdapter.prototype.hideLayer = function () {
+                        return __awaiter(this, void 0, void 0, function () {
+                            var _i, _a, x;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        this.options.visibility = false;
+                                        if (!this.layer) return [3 /*break*/, 4];
+                                        _i = 0, _a = this.layer;
+                                        _b.label = 1;
+                                    case 1:
+                                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                                        x = _a[_i];
+                                        return [4 /*yield*/, webMap.hideLayer(x)];
+                                    case 2:
+                                        _b.sent();
+                                        _b.label = 3;
+                                    case 3:
+                                        _i++;
+                                        return [3 /*break*/, 1];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        });
                     };
                     OnFirstShowAdapter.prototype.loadLayer = function () {
                         return __awaiter(this, void 0, void 0, function () {
@@ -20423,13 +20558,13 @@ var NgwLeaflet = (function () {
                                         if (this._removed) {
                                             webMap.removeLayer(adapter);
                                         }
+                                        this.layer.push(adapter);
                                         if (!this.options.visibility) return [3 /*break*/, 4];
                                         return [4 /*yield*/, webMap.showLayer(adapter)];
                                     case 3:
                                         _a.sent();
                                         _a.label = 4;
                                     case 4:
-                                        this.layer.push(adapter);
                                         this._creatingInProgress = false;
                                         _a.label = 5;
                                     case 5: return [2 /*return*/, this.layer];
@@ -20437,12 +20572,6 @@ var NgwLeaflet = (function () {
                             });
                         });
                     };
-                    OnFirstShowAdapter.prototype.hideLayer = function () {
-                        this.options.visibility = false;
-                        if (this.layer) {
-                            this.layer.forEach(function (x) { return webMap.hideLayer(x); });
-                        }
-                    };
                     return OnFirstShowAdapter;
                 }());
                 return [2 /*return*/, OnFirstShowAdapter];
@@ -20585,14 +20714,34 @@ var NgwLeaflet = (function () {
             delete this._webmapLayersIds;
         };
         NgwWebmapLayerAdapter.prototype.showLayer = function () {
-            if (this.layer && this.layer.properties) {
-                this.layer.properties.property('visibility').set(true);
-            }
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (this.layer && this.layer.properties) {
+                        return [2 /*return*/, this.layer.properties.property('visibility').set(true)];
+                    }
+                    return [2 /*return*/];
+                });
+            });
         };
         NgwWebmapLayerAdapter.prototype.hideLayer = function () {
-            if (this.layer && this.layer.properties) {
-                this.layer.properties.property('visibility').set(false);
-            }
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (this.layer && this.layer.properties) {
+                        return [2 /*return*/, this.layer.properties.property('visibility').set(false)];
+                    }
+                    return [2 /*return*/];
+                });
+            });
+        };
+        NgwWebmapLayerAdapter.prototype.setOpacity = function (val) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (this.layer && this.layer.properties) {
+                        return [2 /*return*/, this.layer.properties.property('opacity').set(val)];
+                    }
+                    return [2 /*return*/];
+                });
+            });
         };
         /** @deprecated use {@link NgwWebmapLayerAdapter.getBounds} instead */
         NgwWebmapLayerAdapter.prototype.getExtent = function () {
@@ -20703,6 +20852,8 @@ var NgwLeaflet = (function () {
                                         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_1.draw_order_enabled;
                                         var layer = new _this.NgwWebmapItem(_this.options.webMap, webmap_1.root_item, options, _this.options.connector);
                                         layer.emitter.on('init', function () { return resolve(layer); });
@@ -22863,7 +23014,9 @@ var NgwLeaflet = (function () {
         GeoJsonAdapter.prototype.getBounds = function () {
             if (this.layer) {
                 var bounds = this.layer.getBounds();
-                return boundsToArray(bounds);
+                if (bounds.isValid()) {
+                    return boundsToArray(bounds);
+                }
             }
         };
         GeoJsonAdapter.prototype.setOpacity = function (value) {
@@ -22918,10 +23071,10 @@ var NgwLeaflet = (function () {
             var _a, _b;
             if (options === void 0) { options = {}; }
             return __awaiter(this, void 0, void 0, function () {
-                var feature, layer, _c, minWidth, autoPan, maxWidth, closeButton_, closeButton, popup, _closeHandlers, onClose, close, content, _d, unselectOnClose, p;
+                var feature, layer, _c, minWidth, autoPan, maxWidth, closeButton_, closeButton, popup, _closeHandlers, onClose, close, content, popupOptions, unselectOnClose, p;
                 var _this = this;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
                         case 0:
                             feature = def.feature, layer = def.layer;
                             _c = __assign({ minWidth: 300 }, options), minWidth = _c.minWidth, autoPan = _c.autoPan, maxWidth = _c.maxWidth, closeButton_ = _c.closeButton;
@@ -22938,22 +23091,25 @@ var NgwLeaflet = (function () {
                             if (!options.createPopupContent) return [3 /*break*/, 2];
                             return [4 /*yield*/, options.createPopupContent(__assign({ layer: layer, feature: feature, target: this, type: type, close: close, onClose: onClose }, createFeaturePositionOptions(feature)))];
                         case 1:
-                            _d = _e.sent();
+                            content = _d.sent();
                             return [3 /*break*/, 3];
                         case 2:
-                            _d = options.popupContent;
-                            _e.label = 3;
+                            content = options.popupContent;
+                            _d.label = 3;
                         case 3:
-                            content = _d;
                             if (content && layer) {
-                                popup = layer.bindPopup(content, {
+                                popupOptions = {
                                     minWidth: minWidth,
                                     autoPan: autoPan,
-                                    maxWidth: maxWidth,
+                                    // maxWidth,
                                     closeButton: closeButton,
                                     closeOnClick: false,
                                     autoClose: false,
-                                });
+                                };
+                                if (defined(maxWidth)) {
+                                    popupOptions.maxWidth = maxWidth;
+                                }
+                                popup = layer.bindPopup(content, popupOptions);
                                 unselectOnClose = (_b = (_a = this.options.popupOptions) === null || _a === void 0 ? void 0 : _a.unselectOnClose) !== null && _b !== void 0 ? _b : true;
                                 if (unselectOnClose) {
                                     p = layer.getPopup();
@@ -22963,9 +23119,7 @@ var NgwLeaflet = (function () {
                                         }, this);
                                 }
                                 this._openedPopup.push([popup, _closeHandlers, def]);
-                                setTimeout(function () {
-                                    popup.openPopup(latlng);
-                                }, 0);
+                                popup.openPopup(latlng);
                             }
                             return [2 /*return*/];
                     }
@@ -23998,5 +24152,5 @@ var NgwLeaflet = (function () {
 
     return NgwLeaflet;
 
-}());
+})();
 //# sourceMappingURL=ngw-leaflet.global.js.map