@nextgis/leaflet-map-adapter 1.8.1 → 1.9.0

package/lib/leaflet-map-adapter.esm-bundler.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/leaflet-map-adapter; version: 1.8.1; author: NextGIS */
+/** Bundle of @nextgis/leaflet-map-adapter; version: 1.9.0; author: NextGIS */
 import { EventEmitter } from 'events';
 import { Control, DomEvent, GeoJSON, FeatureGroup, DivIcon, Marker, CircleMarker, ImageOverlay as ImageOverlay$1, Layer, Util, CRS, GridLayer, DomUtil, TileLayer as TileLayer$1, Map } from 'leaflet';
 import { debounce as debounce$1, defined } from '@nextgis/utils';
@@ -450,7 +450,9 @@ class GeoJsonAdapter extends BaseAdapter {
     getBounds() {
         if (this.layer) {
             const bounds = this.layer.getBounds();
-            return boundsToArray(bounds);
+            if (bounds.isValid()) {
+                return boundsToArray(bounds);
+            }
         }
     }
     setOpacity(value) {
@@ -497,7 +499,7 @@ class GeoJsonAdapter extends BaseAdapter {
             }
         }
     }
-    async _openPopup(def, options = {}, type, latlng) {
+    async _openPopup(def, options = {}, type, latLng) {
         var _a, _b;
         const { feature, layer } = def;
         const { minWidth, autoPan, maxWidth, closeButton: closeButton_, } = { minWidth: 300, ...options };
@@ -512,8 +514,9 @@ class GeoJsonAdapter extends BaseAdapter {
                 this._removePopup(popup);
             }
         };
-        const content = options.createPopupContent
-            ? await options.createPopupContent({
+        let content;
+        if (options.createPopupContent) {
+            content = await options.createPopupContent({
                 layer,
                 feature,
                 target: this,
@@ -521,17 +524,24 @@ class GeoJsonAdapter extends BaseAdapter {
                 close,
                 onClose,
                 ...createFeaturePositionOptions(feature),
-            })
-            : options.popupContent;
+            });
+        }
+        else {
+            content = options.popupContent;
+        }
         if (content && layer) {
-            popup = layer.bindPopup(content, {
+            const popupOptions = {
                 minWidth,
                 autoPan,
-                maxWidth,
+                // maxWidth,
                 closeButton,
                 closeOnClick: false,
                 autoClose: false,
-            });
+            };
+            if (defined(maxWidth)) {
+                popupOptions.maxWidth = maxWidth;
+            }
+            popup = layer.bindPopup(content, popupOptions);
             const unselectOnClose = (_b = (_a = this.options.popupOptions) === null || _a === void 0 ? void 0 : _a.unselectOnClose) !== null && _b !== void 0 ? _b : true;
             if (unselectOnClose) {
                 const p = layer.getPopup();
@@ -541,9 +551,7 @@ class GeoJsonAdapter extends BaseAdapter {
                     }, this);
             }
             this._openedPopup.push([popup, _closeHandlers, def]);
-            setTimeout(() => {
-                popup.openPopup(latlng);
-            }, 0);
+            popup.openPopup(latLng);
         }
     }
     _removePopup(popup) {
@@ -705,15 +713,19 @@ class GeoJsonAdapter extends BaseAdapter {
                     }
                 }
                 this._handleMouseEvents(layer);
-                if (popup) {
-                    this._openPopup({
-                        target: this,
-                        layer,
-                        feature,
-                        ...createFeaturePositionOptions(feature),
-                    }, popupOptions, 'api');
-                }
-                this._updateTooltip({ layer, feature });
+                // The timeout is needed to display the popup immediately when adding a layer to the map.
+                // Without a timeout, the layer may not yet have a _map object
+                setTimeout(() => {
+                    if (popup) {
+                        this._openPopup({
+                            target: this,
+                            layer,
+                            feature,
+                            ...createFeaturePositionOptions(feature),
+                        }, popupOptions, 'api');
+                    }
+                    this._updateTooltip({ layer, feature });
+                });
             }
         }
     }
@@ -1308,6 +1320,15 @@ class OsmAdapter extends TileAdapter {
     }
 }
 
+function arrayToBoundsExpression(bounds) {
+    const e = bounds;
+    // top, left, bottom, right
+    return [
+        [e[3], e[0]],
+        [e[1], e[2]],
+    ];
+}
+
 class LeafletMapAdapter$1 {
     constructor() {
         this.options = { target: 'map' };
@@ -1331,10 +1352,7 @@ class LeafletMapAdapter$1 {
             this.map = new Map(this.options.target, {
                 attributionControl: false,
                 zoomControl: false,
-                maxBounds: mb && [
-                    [mb[1], mb[0]],
-                    [mb[3], mb[2]],
-                ],
+                maxBounds: mb ? arrayToBoundsExpression(mb) : undefined,
                 maxZoom,
                 minZoom,
                 center: center && [center[1], center[0]],
@@ -1371,14 +1389,52 @@ class LeafletMapAdapter$1 {
             this.map.getContainer().style.cursor = cursor;
         }
     }
-    setView(lngLat, zoom) {
-        const [lng, lat] = lngLat;
-        if (this.map) {
-            if (typeof zoom === 'number') {
-                this.map.setView([lat, lng], zoom, { animate: false });
+    setView(lngLatOrOpt, zoom) {
+        const map = this.map;
+        if (!map)
+            return;
+        if (Array.isArray(lngLatOrOpt)) {
+            const lngLat = lngLatOrOpt;
+            const [lng, lat] = lngLat;
+            if (this.map) {
+                if (typeof zoom === 'number') {
+                    this.map.setView([lat, lng], zoom, { animate: false });
+                }
+                else {
+                    this.setCenter([lng, lat]);
+                }
+            }
+        }
+        else {
+            const { zoom, center, maxBounds, bounds, minZoom, maxZoom } = lngLatOrOpt;
+            if (center && zoom !== undefined) {
+                this.setView(center, zoom);
             }
             else {
-                this.setCenter([lng, lat]);
+                if (zoom !== undefined) {
+                    this.setZoom(zoom);
+                }
+                if (center) {
+                    this.setCenter(center);
+                }
+            }
+            if (bounds) {
+                this.fitBounds(bounds);
+            }
+            if (maxBounds !== undefined) {
+                if (maxBounds) {
+                    map.setMaxBounds(arrayToBoundsExpression(maxBounds));
+                }
+                else {
+                    // @ts-ignore `null` works for unset maxBounds, but not in typing
+                    map.setMaxBounds(null);
+                }
+            }
+            if (maxZoom !== undefined) {
+                map.setMaxZoom(maxZoom);
+            }
+            if (minZoom !== undefined) {
+                map.setMinZoom(minZoom);
             }
         }
     }
@@ -1413,7 +1469,7 @@ class LeafletMapAdapter$1 {
         return [sw.lng, sw.lat, ne.lng, ne.lat];
     }
     // [west, south, east, north]
-    fitBounds(e, options = {}) {
+    fitBounds(bounds, options = {}) {
         if (this.map) {
             const { maxZoom, offset, padding } = options;
             const opt = {};
@@ -1426,11 +1482,7 @@ class LeafletMapAdapter$1 {
             if (offset) {
                 opt.padding = offset;
             }
-            // top, left, bottom, right
-            this.map.fitBounds([
-                [e[3], e[0]],
-                [e[1], e[2]],
-            ], opt);
+            this.map.fitBounds(arrayToBoundsExpression(bounds), opt);
         }
     }
     getLayerAdapter(name) {